Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

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:

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

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:

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:

#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:

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:

@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:

@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:

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


Zum Abrufen von Benutzereinstellungen:

@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:

@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:

@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:

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:

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:


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

https://localhost:8102/user/create


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

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


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

https://localhost:8102/user/


Wir erhalten etwas zurück wie:

[
  {
    "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:

//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.

Starten Sie Ihre kostenlose Trial-Version jetzt!

Sind Sie bereit, die Leistungsfähigkeit von Spring Boot Redis Cache in der Cloud zu erleben? Melden Sie sich heute für unsere kostenlose Trial-Version an und entdecken Sie, wie unsere Cloud-Lösungen Ihre Anwendungen schneller und effizienter machen können. Nutzen Sie die Gelegenheit, um die fortschrittlichen Funktionen und die benutzerfreundliche Umgebung unserer Plattform kennenzulernen. Warten Sie nicht länger – Ihr Weg zu optimierten Spring Boot-Anwendungen beginnt hier!

Kostenlos testen!