Maximale Performance bei minimalen Kosten. Jetzt Server in Sekunden starten!

    Willkommen beim Spring Boot MongoDB Leitfaden

    Spring Boot ist der einfachste Weg, um schnell ein Spring-Projekt zu starten, und MongoDB ist die beliebteste NoSQL-Datenbank. Lassen Sie uns sehen, wie man Spring mit der MongoDB-Datenbank integriert.

    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, über die wir eine Verbindung zur MongoDB-Datenbank herstellen können – MongoRepository und MongoTemplate. Wir werden versuchen zu ermitteln, was eine API über die andere bietet und wann Sie eine von ihnen für Ihren Anwendungsfall wählen sollten. Wir werden das Tool Spring Initializr zur schnellen Einrichtung des Projekts verwenden. Also, fangen wir an.

    Spring Boot MongoDB Projekt Setup

    Wir werden das Tool Spring Initializr zur schnellen Einrichtung des Projekts verwenden. Wir werden nur zwei Abhängigkeiten verwenden, wie unten gezeigt:

    Laden Sie das Projekt herunter und entpacken Sie es. Dann importieren Sie es in Ihre bevorzugte IDE – Eclipse oder IntelliJ IDEA.

    Maven-Abhängigkeiten

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

    Copy Code 
    

    <?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 Beispiel</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 eine stabile Version von Spring Boot aus dem Maven Central verwenden.

    Spring Boot MongoDB Model-Klasse

    Wir haben eine einfache Model-Klasse User.java.

    Copy Code 
    

    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 die folgenden Funktionalitäten und Datenbankinteraktionen in unserer App haben:

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

    Spring Data MongoDB – MongoRepository

    Nun werden wir das Spring Data MongoDB-Repository verwenden, um auf unsere Daten zuzugreifen. Spring Data MongoRepository bietet uns gemeinsame Funktionalitäten, die wir einfach einbinden und verwenden können. Definieren wir unsere Repository-Schnittstelle:

    Copy Code 
    

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

    Definieren von MongoDB-Eigenschaften

    Bevor wir unseren Controller aufstellen, ist es wichtig, dass wir eine Verbindung mit einer lokalen Instanz von MongoDB herstellen. Wir werden Spring Boot-Eigenschaften dafür verwenden:

    Copy Code 
    

    #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

    Definieren des Spring Controllers

    Lassen Sie uns schließlich unseren Controller-Klasse erstellen:

    Copy Code 
    

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

    Definieren der APIs

    Für die von uns genannten Funktionalitäten erstellen wir nun APIs und greifen auf die Abhängigkeit userRepository zu, die intern die Spring Data MongoRepository API nutzt. Beachten Sie, dass wir in der Schnittstelle keinen Datenbankinteraktionscode schreiben müssen, da Spring Data dies für uns erledigt.

    Zum Abrufen aller Benutzer:

    Copy Code 
    

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

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

    Zum Abrufen eines Benutzers anhand der ID:

    Copy Code 
    

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

    findOne() ist eine Methode, die Spring Data MongoRepository intern bereitstellt, um ein Objekt anhand einer ID zu erhalten.

    Zum Hinzufügen eines neuen Benutzers:

    Copy Code 
    

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

    Zum Abrufen von Benutzereinstellungen:
    Copy Code 
    

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

    Zum Abrufen einer bestimmten Benutzereinstellung:
    Copy Code 
    

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

    Zum Hinzufügen einer neuen Benutzereinstellung:
    Copy Code 
    

    @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 "Schlüssel hinzugefügt";
    } else {
        return "Benutzer nicht gefunden.";
    }
}

    Spring Data MongoDB – MongoTemplate

    Wir definieren hier die MongoTemplate-Datenbankabfragen. Mit MongoTemplate sehen Sie, dass wir viel mehr Kontrolle darüber haben, was wir abfragen und welche Daten in den Ergebnissen enthalten sind.

    Definieren der DAL-Schnittstelle

    Um einen Vertrag auf der Datenzugriffsebene bereitzustellen, beginnen wir mit der Definition einer Schnittstelle, die genauso funktioniert wie unsere integrierten Spring Data-Methoden:

    Copy Code 
    

    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 der DAL-Schnittstelle

    Kommen wir nun dazu, diese Methoden zu definieren:

    Copy Code 
    

    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);
        // Jetzt enthält das User-Objekt auch die ID
        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() : "Benutzer nicht gefunden.";
    }

    @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) : "Nicht gefunden.";
    }

    @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 "Schlüssel hinzugefügt.";
        } else {
            return "Benutzer nicht gefunden.";
        }
    }
}

    Spring Data MongoDB Testlauf

    Wir können diese App einfach mit einem einzigen Befehl starten:

    Copy Code 
    

    mvn spring-boot:run

    Nachdem die App läuft, können wir versuchen, einen neuen Benutzer mit dieser API zu speichern:
    Copy Code 
    

    https://localhost:8102/user/create

    Da es sich um eine POST-Anfrage handelt, senden wir JSON-Daten wie folgt:
    Copy Code 
    

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

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

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

    Spring Data MongoDB MongoRepository Beispiel Erstellen Sie können alle Benutzer mit der API als GET-Anfrage abrufen:
    Copy Code 
    

    https://localhost:8102/user/

    Wir erhalten etwas zurück wie:
    Copy Code 
    

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

    Wenn Sie sich die oben genannte UserController-Klasse ansehen, haben wir MongoTemplate nicht eingebunden, um verwendet zu werden. Das folgende Code-Snippet zeigt die erforderlichen Änderungen, um MongoTemplate für das Lesen von Benutzereinstellungen zu verwenden:
    Copy Code 
    

    //Definieren des Data Access Layer-Objekts
private final UserDAL userDAL;

//Initialisierung des DAL-Objekts über Konstruktor-Autowiring
public UserController(UserRepository userRepository, UserDAL userDAL) {
    this.userRepository = userRepository;
    this.userDAL = userDAL;
}

//Änderung der Methodenimplementierung zur Verwendung von DAL und damit 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 "Benutzer nicht gefunden.";
    }
}

//Änderung der Methodenimplementierung zur Verwendung von DAL und damit 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 bietet viel mehr Kontrolle bei der Datenabfrage und darüber, welche Daten aus der Datenbank geholt werden.

    Spring Data Repositories bieten uns einen praktischen Ansatz, um Daten abzurufen.

    MongoTemplate ist datenbankabhängig. Das bedeutet, mit Spring Data Repositories können Sie einfach zu einer anderen Datenbank wechseln, indem Sie einfach ein anderes Spring Data Repository für MySQL, Neo4J oder etwas anderes verwenden. Dies ist mit MongoTemplate nicht möglich.

    Spring Boot MongoDB Zusammenfassung

    In dieser Lektion haben wir gesehen, wie MongoTemplate uns mehr Kontrolle über Spring Data Repositories bieten kann, aber auch etwas komplizierter sein kann, wenn tiefere Abfragen beteiligt sind. Es liegt also ganz bei Ihnen, was Sie wählen, wenn Sie Ihre Idee entwickeln. Fühlen Sie sich frei, unten Kommentare zu hinterlassen. Laden Sie den Quellcode vom untenstehenden Link herunter. Bitte stellen Sie sicher, dass Sie die MongoDB-Anmeldeinformationen ändern, bevor Sie die bereitgestellte App ausführen. Willkommen beim Spring Boot MongoDB Leitfaden

    Kostenlosen Account erstellen

    Registrieren Sie sich jetzt und erhalten Sie Zugang zu unseren Cloud Produkten.

    Jetzt loslegen

    Das könnte Sie auch interessieren: