Spring Boot MongoDB

Tutorials

MongoDB Spring

Willkommen beim Spring Boot MongoDB-Beispiel. Spring Boot ist der einfachste Weg, ein Spring-Projekt schnell zu erstellen, und MongoDB ist die beliebteste NoSQL-Datenbank. Schauen wir uns an, wie man Spring mit der MongoDB-Datenbank integrieren kann.

Spring Boot MongoDB

Wir benötigen folgende APIs, um mit Spring Boot und der MongoDB-Datenbank zu arbeiten.

Spring Data MongoDB
Spring Boot

Es gibt zwei Ansätze, wie wir uns mit der MongoDB-Datenbank verbinden können – MongoRepository und MongoTemplate. Wir werden versuchen herauszufinden, was eine API gegenüber der anderen bietet und wann Sie eine davon für Ihren Anwendungsfall wählen sollten. Wir werden das Spring Initializr-Tool verwenden, um das Projekt schnell einzurichten. Also, lassen Sie uns anfangen.

Einrichtung des Spring Boot MongoDB-Projekts

Wir werden das Spring Initializr-Tool verwenden, um das Projekt schnell einzurichten. Wir werden nur zwei Abhängigkeiten verwenden, wie unten gezeigt: Laden Sie das Projekt herunter und entpacken Sie es. Importieren Sie es dann in Ihre bevorzugte IDE – Eclipse oder IntelliJ IDEA.

Maven-Abhängigkeiten

Auch wenn wir das Setup bereits mit dem Tool abgeschlossen haben, wenn Sie es manuell einrichten möchten, verwenden wir das Maven-Build-System für dieses Projekt. Hier sind die Abhängigkeiten, die wir verwendet haben:

<?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>

Stellen Sie sicher, dass Sie die stabile Version für Spring Boot aus dem Maven-Zentralrepository verwenden.

Spring Boot MongoDB-Modellklasse

Wir haben eine einfache Modellklasse 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;
	}
}

Spring Boot MongoDB-APIs

Wir werden folgende Funktionalitäten und Datenbankinteraktionen in unserer App haben:

Alle Benutzer erhalten
Einen Benutzer mit ID erhalten
Benutzereinstellungen erhalten
Einen bestimmten Schlüssel aus der Map erhalten
Benutzereinstellung hinzufügen/aktualisieren

Spring Data MongoDB – MongoRepository

Jetzt werden wir das Spring Data MongoDB-Repository verwenden, um auf unsere Daten zuzugreifen. Spring Data MongoRepository stellt uns gemeinsame Funktionalitäten zur Verfügung, die wir leicht einbinden und verwenden können. Lassen Sie uns unser Repository-Interface definieren.

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> {
}

Definition der MongoDB-Eigenschaften

Bevor wir unseren Controller erstellen, ist es wichtig, dass wir eine Verbindung zu einer lokalen Instanz von MongoDB herstellen. Wir werden Spring Boot-Eigenschaften verwenden, um dies zu tun.

# Lokale MongoDB-Konfiguration
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-Konfiguration
server.port=8102
spring.application.name=BootMongo
server.context-path=/user

Also wird die App auf Port 8102 laufen und sich mit einer lokalen MongoDB-Instanz mit den bereitgestellten Anmeldeinformationen verbinden. Wenn Sie eine lokale Instanz ohne aktiviertes Autorisieren haben, können Sie einfach die ersten drei Zeilen der Konfiguration entfernen.

Definition des Spring Controllers

Lassen Sie uns abschließend zu unserer Controller-Klasse übergehen.

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;
	}
}

Wir haben gerade die Repository-Interface-Abhängigkeit mit Autowired verbunden und werden dies als nächstes verwenden.

Definition der APIs

Für die genannten Funktionalitäten werden wir nun APIs erstellen und auf die userRepository-Abhängigkeit zugreifen, die intern die Spring Data MongoRepository-API verwenden wird. Beachten Sie, dass wir keinen Datenbankinteraktionscode im Interface schreiben müssen, da Spring Data dies alles für uns erledigt.

Alle Benutzer abrufen

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

findAll() ist lediglich eine Methode, die Spring Data MongoRepository intern bereitstellt.

Einen Benutzer nach ID abrufen

Jetzt holen wir uns einen bestimmten Benutzer mit einer 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() ist einfach eine Methode, die Spring Data MongoRepository intern bereitstellt, um ein Objekt nach ID zu erhalten.

Einen neuen Benutzer hinzufügen

Wir werden einen neuen Benutzer in der unten stehenden Funktion hinzufügen.

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

Benutzereinstellungen abrufen

Jetzt, da wir Beispieldaten in die Datenbank eingefügt haben, versuchen wir, einen Teil davon zu extrahieren.

@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.";
	}
}

Eine bestimmte Benutzereinstellung abrufen

@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.";
	}
}

Beachten Sie in der obigen Abfrage, dass wir das Benutzerobjekt erhalten haben, dann die vollständige Einstellungsmap extrahiert haben (die Tausende von Objekten enthalten könnte) und schließlich unseren eigenen Wert erhalten haben. Dies ist ein Nachteil für Spring Data Query, wenn wir es als reine API verwenden.

Eine neue Benutzereinstellung hinzufügen

Lassen Sie uns versuchen, einige Daten zu einem vorhandenen Benutzer hinzuzufügen:

@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.";
	}
}

Mit all dem Code, den wir geschrieben haben, ist klar, dass wir keinen einzigen Code schreiben mussten, um auf die Datenbank zuzugreifen, abgesehen von der Definition des Repository-Interfaces und der automatischen Verdrahtung der Abhängigkeit. Dies ist die Bequemlichkeit, die uns die Spring Data MongoRepository API bietet, aber sie hat auch einige Nachteile. Wir werden darauf eingehen, wenn wir auch die Version mit MongoTemplate definiert haben. Fangen wir damit auch an.

Spring Data MongoDB – MongoTemplate

Hier werden wir die Datenbankabfragen für MongoTemplate definieren. Mit MongoTemplate haben wir eine viel feinere Kontrolle darüber, was wir abfragen und welche Daten in den Ergebnissen enthalten sind.

Definition des DAL-Interfaces

Um eine Vertragsbindung auf der Ebene des Datenbankzugriffs bereitzustellen, werden wir zunächst ein Interface definieren, das genauso funktioniert wie unsere in Spring Data eingebauten Methoden.

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);
}

Implementierung des DAL-Interfaces

Lassen Sie uns nun fortfahren und diese Methoden definieren.

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 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);
		 // Jetzt wird das Benutzerobjekt auch die ID enthalten 
		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.";
		}
	}
}

Die Methodenimplementierungen in der obigen Klasse verwenden die Abhängigkeit von MongoTemplate. Sehen Sie, wie die Methode getUserById (...) den Benutzer abruft. Wir konstruieren eine Abfrage und übergeben erforderliche Parameter. Was Sie mehr interessieren wird, ist die Abfrage getUserSetting . Lassen Sie uns verstehen, was oben passiert ist:

Wir haben Abfragen mit Kriterien erstellt, um Gleichheit zu überprüfen.
Die include-Methode enthält die Feldnamen, die das Ergebnis enthalten soll, wenn es aus der Datenbank extrahiert wird. Dies bedeutet, dass in diesem Fall der userSettings-Schlüssel extrahiert wird, was das Abrufen von Daten erspart, die nicht benötigt werden
Außerdem haben wir sowohl nach dem Benutzer als auch nach dem Kartenschlüssel abgefragt. Wenn eines davon nicht gefunden wird, geben wir leere Daten zurück, was bedeutet, dass der erforderliche Schlüssel nicht gefunden wurde. Dies erspart es, das Benutzerobjekt überhaupt abzurufen, wenn der erforderliche Schlüssel nicht vorhanden war

Spring Data MongoDB Test Run

Wir können diese App einfach durch Verwendung eines einzigen Befehls ausführen:

mvn spring-boot:run

Sobald die App läuft, können wir versuchen, einen neuen Benutzer zu speichern, indem wir diese API verwenden:

https://localhost:8102/user/create

Da es sich um eine POST-Anfrage handelt, senden wir auch JSON-Daten:

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

Da wir die Mongo-Antwort selbst zurückgeben, erhalten wir etwas wie:

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

Sie können alle Benutzer abrufen, indem Sie die API als GET-Anfrage verwenden:

https://localhost:8102/user/

Wir erhalten etwas Ähnliches wie:

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

Wenn Sie oben die Klasse UserController sehen, haben wir MongoTemplate nicht angeschlossen, um es zu verwenden. Im folgenden Codeausschnitt sind die erforderlichen Änderungen aufgeführt, um MongoTemplate für das Lesen von Benutzereinstellungen zu verwenden.

//definieren Sie das Data Access Layer-Objekt
private final UserDAL userDAL;

//initialisieren Sie das DAL-Objekt über den Konstruktor-Autowiring
public UserController(UserRepository userRepository, UserDAL userDAL) {
	this.userRepository = userRepository;
	this.userDAL = userDAL;
}

//Ändern Sie die Methodenimplementierung, um das DAL und daher MongoTemplate zu verwenden
@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.";
    }
}

//Ändern Sie die Methodenimplementierung, um das DAL und daher MongoTemplate zu verwenden
@RequestMapping(value = "/settings/{userId}/{key}", method = RequestMethod.GET)
public String getUserSetting(
        @PathVariable String userId, @PathVariable String key) {
    return userDAL.getUserSetting(userId, key);
}

Starten Sie die App neu und führen Sie Szenarien aus, um alle Benutzereinstellungen zu erhalten und einen bestimmten Schlüssel zu erhalten. Das folgende Bild zeigt die Ausgabe der Postman-App.

MongoTemplate vs MongoRepository

MongoTemplate bietet deutlich mehr Kontrolle, wenn es um die Abfrage von Daten und das Abrufen von Daten aus der Datenbank geht.
Spring Data Repositories geben uns einen bequemen Überblick darüber, wie Daten abgerufen werden können.
MongoTemplate ist datenbankabhängig. Das bedeutet, dass Sie mit Spring Data Repositories problemlos zu einer anderen Datenbank wechseln können, indem Sie einfach andere Spring Data Repositories für MySQL, Neo4J oder etwas anderes verwenden. Dies ist mit MongoTemplate nicht möglich.

Zusammenfassung von Spring Boot MongoDB

In dieser Lektion haben wir uns angesehen, wie MongoTemplate uns mehr Kontrolle über Spring Data Repositories geben kann, aber auch etwas komplizierter sein kann, wenn tiefere Abfragen involviert sind. Also, die Entscheidung liegt ganz bei dir, was du wählst, wenn du deine Idee entwickelst. Fühle dich frei, unten Kommentare zu hinterlassen. Lade den Quellcode über den unten stehenden Link herunter. Stelle bitte sicher, dass du die MongoDB-Anmeldeinformationen änderst, bevor du die bereitgestellte App ausführst.

Laden Sie das Beispielprojekt Spring Boot MongoDB herunter

Source:
https://www.digitalocean.com/community/tutorials/spring-boot-mongodb