MongoDB çizme pranverore

Mirë se vini në shembullin Spring Boot MongoDB. Spring Boot është mënyra më e lehtë për të rrotulluar shpejt një projekt pranveror dhe MongoDB është baza e të dhënave më e njohur NoSQL. Le të shohim se si të integrojmë pranverën me bazën e të dhënave MongoDB.

MongoDB çizme pranverore

Na duhen API-të e mëposhtme për të punuar me bazën e të dhënave Spring Boot dhe MongoDB.

• Spring Data MongoDB
• Çizme pranverore

Ka dy qasje përmes të cilave ne mund të lidhemi me bazën e të dhënave MongoDB - MongoRepository dhe MongoTemplate. Ne do të përpiqemi të përcaktojmë se çfarë ofron një API mbi një tjetër dhe kur duhet të zgjidhni njërën prej tyre për rastin tuaj të përdorimit. Ne do të përdorim mjetin Spring Initializr për konfigurimin e shpejtë të projektit. Pra, le të fillojmë.

Konfigurimi i projektit të nisjes së pranverës MongoDB

Varësitë Maven

Megjithëse ne kemi përfunduar tashmë konfigurimin me mjetin, nëse dëshironi ta konfiguroni manualisht, ne përdorim sistemin e ndërtimit të Maven për këtë projekt dhe këtu janë varësitë që kemi përdorur:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-boot-mongodb</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>spring-boot-mongodb</name>
	<description>Spring Boot MongoDB Example</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

Sigurohuni që të përdorni versionin stabil për Spring Boot nga maven central.

Klasa e modelit të çizmeve të pranverës MongoDB

Ne kemi një klasë të thjeshtë modeli User.java.

package com.journaldev.bootifulmongodb.model;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document
public class User {

	@Id
	private String userId;
	private String name;
	private Date creationDate = new Date();
	private Map<String, String> userSettings = new HashMap<>();

	public String getUserId() {
		return userId;
	}

	public void setUserId(String userId) {
		this.userId = userId;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Date getCreationDate() {
		return creationDate;
	}

	public void setCreationDate(Date creationDate) {
		this.creationDate = creationDate;
	}

	public Map<String, String> getUserSettings() {
		return userSettings;
	}

	public void setUserSettings(Map<String, String> userSettings) {
		this.userSettings = userSettings;
	}
}

API-të Spring Boot MongoDB

Ne do të kemi funksionalitetet e mëposhtme dhe ndërveprimet e bazës së të dhënave në aplikacionin tonë.

• Merr të gjithë përdoruesit
• Merr një përdorues me ID
• Merr cilësimet e përdoruesit
• Merr një çelës të veçantë nga Harta
• Shto/Përditëso cilësimin e përdoruesit

Pranvera e të dhënave MongoDB - MongoRepository

Tani do të përdorim depon e Spring Data MongoDB për të hyrë në të dhënat tona. Spring Data MongoRepository na ofron funksionalitete të zakonshme që ne mund t'i shtojmë lehtësisht dhe t'i përdorim ato. Le të përcaktojmë ndërfaqen tonë të Depove.

package com.journaldev.bootifulmongodb.dal;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import com.journaldev.bootifulmongodb.model.User;

@Repository
public interface UserRepository extends MongoRepository<User, String> {
}

Përcaktimi i vetive MongoDB

Përpara se të vendosim kontrolluesin tonë, është e rëndësishme që të bëjmë një lidhje me një shembull lokal të MongoDB. Ne do të përdorim vetitë Spring Boot për ta bërë këtë.

#Local MongoDB config
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=root
spring.data.mongodb.password=root
spring.data.mongodb.database=user_db
spring.data.mongodb.port=27017
spring.data.mongodb.host=localhost

# App config
server.port=8102
spring.application.name=BootMongo
server.context-path=/user

Pra, aplikacioni do të funksionojë në portin 8102 dhe do të lidhet me një shembull lokal mongoDB me kredencialet e dhëna. Nëse keni një shembull lokal pa autorizim të aktivizuar, thjesht mund të hiqni tre linjat e para të konfigurimit.

Përcaktimi i kontrolluesit të pranverës

Më në fund le të kalojmë në krijimin e klasës sonë Controller.

package com.journaldev.bootifulmongodb.controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.journaldev.bootifulmongodb.dal.UserRepository;
import com.journaldev.bootifulmongodb.model.User;

@RestController
@RequestMapping(value = "/")
public class UserController {

	private final Logger LOG = LoggerFactory.getLogger(getClass());

	private final UserRepository userRepository;

	public UserController(UserRepository userRepository) {
		this.userRepository = userRepository;
	}
}

Ne sapo lidhëm automatikisht varësinë e ndërfaqes së depove dhe do ta përdorim këtë më pas.

Përcaktimi i API-ve

Për funksionalitetet që përmendëm, ne tani do të bëjmë API dhe do të aksesojmë varësinë e përdoruesit Repository e cila do të përdorë nga brenda Spring Data MongoRepository API. Vini re se nuk duhet të shkruajmë ndonjë kod ndërveprimi me bazën e të dhënave në ndërfaqe pasi Spring Data i bën të gjitha për ne.

Marrja e të gjithë përdoruesve

@RequestMapping(value = "", method = RequestMethod.GET)
public List<User> getAllUsers() {
	LOG.info("Getting all users.");
	return userRepository.findAll();
}

findAll() është vetëm një metodë që Spring Data MongoRepository e ofron nga brenda.

Marrja e një përdoruesi me ID

Tani, le të marrim një përdorues specifik me një ID.

@RequestMapping(value = "/{userId}", method = RequestMethod.GET)
public User getUser(@PathVariable String userId) {
	LOG.info("Getting user with ID: {}.", userId);
	return userRepository.findOne(userId);
}

findOne() është vetëm një metodë që Spring Data MongoRepository ofron nga brenda për të marrë një objekt me një ID.

Shtimi i një përdoruesi të ri

Ne do të shtojmë një përdorues të ri në funksionin e mëposhtëm.

@RequestMapping(value = "/create", method = RequestMethod.POST)
public User addNewUsers(@RequestBody User user) {
	LOG.info("Saving user.");
	return userRepository.save(user);
}

Marrja e cilësimeve të përdoruesit

Tani që kemi shtuar të dhëna të mostrës në DB, le të përpiqemi të nxjerrim një pjesë të saj.

@RequestMapping(value = "/settings/{userId}", method = RequestMethod.GET)
public Object getAllUserSettings(@PathVariable String userId) {
	User user = userRepository.findOne(userId);
	if (user != null) {
		return user.getUserSettings();
	} else {
		return "User not found.";
	}
}

Marrja e një cilësimi të veçantë të përdoruesit

@RequestMapping(value = "/settings/{userId}/{key}", method = RequestMethod.GET)
public String getUserSetting(@PathVariable String userId, @PathVariable String key) {
	User user = userRepository.findOne(userId);
	if (user != null) {
		return user.getUserSettings().get(key);
	} else {
		return "User not found.";
	}
}

Vini re në pyetjen e mësipërme, ne morëm objektin e përdoruesit, më pas nxorëm hartën e plotë të cilësimeve (e cila mund të kishte 1000 objekte) dhe më në fund morëm vlerën tonë. Ky është një dobësi për pyetjen Spring Data kur ne e përdorim atë si API të drejtpërdrejtë.

Shtimi i një cilësimi të ri të përdoruesit

Le të përpiqemi t'i shtojmë disa të dhëna një përdoruesi ekzistues:

@RequestMapping(value = "/settings/{userId}/{key}/{value}", method = RequestMethod.GET)
public String addUserSetting(@PathVariable String userId, @PathVariable String key, @PathVariable String value) {
	User user = userRepository.findOne(userId);
	if (user != null) {
		user.getUserSettings().put(key, value);
		userRepository.save(user);
		return "Key added";
	} else {
		return "User not found.";
	}
}

Me gjithë kodin që shkruam, është e qartë se nuk na duhej të shkruanim një rresht të vetëm kodi për të hyrë në bazën e të dhënave, përveç përcaktimit të ndërfaqes së depove dhe lidhjes automatike të varësisë. Kjo është lehtësia që na ofron Spring Data MongoRepository API, por ka edhe disa anë negative. Ne do ta shtjellojmë këtë kur të kemi përcaktuar edhe versionin MongoTemplate. Le të fillojmë edhe me këtë.

Pranvera e të dhënave MongoDB - MongoTemplate

Këtu do të përcaktojmë pyetjet e bazës së të dhënave MongoTemplate. Me MongoTemplate, do të shihni se ne kemi kontroll shumë më të hollësishëm mbi atë që kërkojmë dhe cilat të dhëna përfshihen në rezultate.

Përcaktimi i ndërfaqes DAL

Për të siguruar një kontratë në shtresën e hyrjes në bazën e të dhënave, ne do të fillojmë duke përcaktuar një ndërfaqe që funksionon ashtu si metodat tona të integruara të Spring Data.

package com.journaldev.bootifulmongodb.dal;

import java.util.List;

import com.journaldev.bootifulmongodb.model.User;

public interface UserDAL {

	List<User> getAllUsers();

	User getUserById(String userId);

	User addNewUser(User user);

	Object getAllUserSettings(String userId);

	String getUserSetting(String userId, String key);

	String addUserSetting(String userId, String key, String value);
}

Implementimi i ndërfaqes DAL

Le të vazhdojmë dhe të përcaktojmë këto metoda.

package com.journaldev.bootifulmongodb.dal;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import com.journaldev.bootifulmongodb.model.User;

@Repository
public class UserDALImpl implements UserDAL {

	@Autowired
	private MongoTemplate mongoTemplate;

	@Override
	public List<User> getAllUsers() {
		return mongoTemplate.findAll(User.class);
	}

	@Override
	public User getUserById(String userId) {
		Query query = new Query();
		query.addCriteria(Criteria.where("userId").is(userId));
		return mongoTemplate.findOne(query, User.class);
	}

	@Override
	public User addNewUser(User user) {
		mongoTemplate.save(user);
		// Now, user object will contain the ID as well
		return user;
	}

	@Override
	public Object getAllUserSettings(String userId) {
		Query query = new Query();
		query.addCriteria(Criteria.where("userId").is(userId));
		User user = mongoTemplate.findOne(query, User.class);
		return user != null ? user.getUserSettings() : "User not found.";
	}

	@Override
	public String getUserSetting(String userId, String key) {
		Query query = new Query();
		query.fields().include("userSettings");
		query.addCriteria(Criteria.where("userId").is(userId).andOperator(Criteria.where("userSettings." + key).exists(true)));
		User user = mongoTemplate.findOne(query, User.class);
		return user != null ? user.getUserSettings().get(key) : "Not found.";
	}

	@Override
	public String addUserSetting(String userId, String key, String value) {
		Query query = new Query();
		query.addCriteria(Criteria.where("userId").is(userId));
		User user = mongoTemplate.findOne(query, User.class);
		if (user != null) {
			user.getUserSettings().put(key, value);
			mongoTemplate.save(user);
			return "Key added.";
		} else {
			return "User not found.";
		}
	}
}

Zbatimet e metodës në klasën e mësipërme përdorin varësinë MongoTemplate. Shihni se si metoda getUserById(...) e merr përdoruesin. Ne ndërtojmë një pyetje dhe kaluam parametrat e kërkuar. Ajo që do t'ju interesojë më shumë është pyetja getUserSetting. Le të kuptojmë se çfarë ndodhi më lart:

• Ne ndërtuam pyetje me kritere për të kontrolluar barazinë.
• Metoda e përfshirjes përfshin emrat e fushave që rezultati duhet të përfshijë kur të nxirret nga DB. Kjo do të thotë, në këtë rast, çelësi i cilësimeve të përdoruesit do të nxirret i cili do të kursejë shumë të dhëna për t'u marrë, të cilat nuk janë të nevojshme
• Gjithashtu, ne kërkuam si për përdoruesin ashtu edhe për çelësin e hartës. Nëse ndonjë prej tyre nuk është gjetur, ne kthejmë të dhëna boshe që do të thotë se çelësi i kërkuar nuk u gjet. Kjo kursen nga marrja e objektit të Përdoruesit fare nëse çelësi i kërkuar nuk ishte i pranishëm

Ekzekutimi i testit të të dhënave të pranverës MongoDB

Ne mund ta ekzekutojmë këtë aplikacion thjesht duke përdorur një komandë të vetme:

mvn spring-boot:run

Pasi aplikacioni të funksionojë, mund të përpiqemi të ruajmë një përdorues të ri duke përdorur këtë API:

https://localhost:8102/user/create

Duke qenë se kjo do të jetë një kërkesë POST, ne do të dërgojmë gjithashtu të dhëna JSON:

{
  "name" : "Shubham",
  "userSettings" : {
    "bike" : "pulsar"
  }
}

Ndërsa po kthejmë vetë përgjigjen Mongo, do të marrim diçka si:

{
  "userId": "5a5f28cc3178058b0fafe1dd",
  "name": "Shubham",
  "creationDate": 1516165830856,
  "userSettings": {
    "bike" : "pulsar"
  }
}

https://localhost:8102/user/

Ne do të kthejmë diçka të tillë:

[
  {
    "userId": "5a5f28cc3178058b0fafe1dd",
    "name": "Shubham",
    "creationDate": 1516165830856,
    "userSettings": {
      "bike" : "pulsar"
    }
  }
]

//define Data Access Layer object
private final UserDAL userDAL;

//initialize DAL object via constructor autowiring
public UserController(UserRepository userRepository, UserDAL userDAL) {
	this.userRepository = userRepository;
	this.userDAL = userDAL;
}

//change method implementation to use DAL and hence MongoTemplate
@RequestMapping(value = "/settings/{userId}", method = RequestMethod.GET)
public Object getAllUserSettings(@PathVariable String userId) {
    User user = userRepository.findOne(userId);
    if (user != null) {
        return userDAL.getAllUserSettings(userId);
    } else {
        return "User not found.";
    }
}

//change method implementation to use DAL and hence MongoTemplate
@RequestMapping(value = "/settings/{userId}/{key}", method = RequestMethod.GET)
public String getUserSetting(
        @PathVariable String userId, @PathVariable String key) {
    return userDAL.getUserSetting(userId, key);
}

MongoTemplate vs MongoRepository

• MongoTemplate ofron shumë më tepër kontroll kur bëhet fjalë për kërkimin e të dhënave dhe cilat të dhëna duhet të nxirren nga baza e të dhënave.
• Depot e të dhënave të pranverës na ofrojnë një pamje të përshtatshme se si të marrim të dhëna.
• MongoTemplate varet nga baza e të dhënave. Çfarë do të thotë kjo është, me depot e Spring Data, ju mund të kaloni lehtësisht në një bazë të dhënash të ndryshme krejtësisht duke përdorur thjesht një depo të ndryshme Spring Data për MySQL ose Neo4J ose ndonjë gjë tjetër. Kjo nuk është e mundur me MongoTemplate.

Përmbledhje MongoDB Boot Spring

Në këtë mësim, ne shikuam se si MongoTemplate mund të na sigurojë më shumë kontroll mbi depot e Spring Data, por gjithashtu mund të jetë pak i komplikuar kur përfshihen pyetje më të thella. Pra, kjo është tërësisht thirrja juaj se çfarë të zgjidhni kur zhvilloni idenë tuaj. Mos ngurroni të lini komente më poshtë. Shkarkoni kodin burim nga lidhja e mëposhtme. Ju lutemi sigurohuni që të ndryshoni kredencialet e MongoDB përpara se të ekzekutoni aplikacionin e dhënë.

Shkarkoni shembullin e projektit Spring Boot MongoDB