Spring Boot – Data Repository mit MongoDB erstellen
Einleitung
Nachdem wir nun gesehen haben wie man mit Spring Boot einen Rest Controller erstellt und diesen mit Postman anspricht, sollten wir uns nun Gedanken machen wie wir die Daten im System hinterlegen wollen? Es gibt viele Wege und Arten Daten zu speichern. Die klassische Variante wäre es eine SQL Datenbank wie MariaDB zu verwenden. Ich möchte euch in meinem Tutorial zeigen, wie ihr mit Spring Boot Repository Klassen die Daten in einer MongoDB abspeichern könnt.
Da wir eine MongoDB verwenden möchten brauchen wir auch eine MongoDB Instanz. Hierzu habt ihr zwei Möglichkeiten.
- Ihr installiert euch auf eurem System eine MongoDB. Die Binaries könnt ihr hier runterladen
- Ihr verwendet einen Docker Container mit einer MongoDB, wie das geht zeige ich euch hier in meinem Tutorial MongoDB mit Docker
Voraussetzunǵ
- Existierende Java 8 Installation
- Existierende Maven 3 Installation
- Existierende MongoDB Installation auf Port 2017
- Grundkenntnisse in REST
- Tutorial: Spring Boot Rest Controller
Spring Boot Data für MongoDB einbinden
Maven pom.xml erweitern
Damit unsere Applikation eine Verbindung mit der MongoDB aufbauen kann, müssen wir unsere POM aus dem Tutorial Spring Boot Rest Controller um eine weitere Spring Boot dependency erweitern.
<dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-mongodb</artifactId> </dependency>
Die o.g dependency bindet die Spring Data MongoDB libraries in unser Projekt ein.
Der folgende Codeblock zeigt die erweiterte POM:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.ertantoker.tutorial</groupId>
<artifactId>spring-boot-with-maven</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>spring-boot-with-maven</name>
<url>http://maven.apache.org</url>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.1.RELEASE</version>
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
Spring Boot Data aktivieren
Als weiteren Schritt nachdem wir die dependency eingebunden haben, müssen wir in unsere Applikation um eine Konfigurationsdatei erweitern. Die zentrale Konfigurationsdatei für Spring Boot Applikationen ist die application.properties oder application.yml. Beide Konfigurationsdateien unterscheiden sich nur darin, dass die application.properties eine klassische Key/Value Datei ist und die application.yml eine YAML Datei. In meinen Tutorials werde ich stets die YAML Variante verwenden.
Damit wir eine application.yml anlegen können müssen wir erst einmal unser Projekt um ein Verzeichnis erweitern! Maven Projekte bieten uns die Möglichkeit unsere Konfigurationsdateien in das Verzeichnis „PROJEKT_HOME/src/main/resources“ abzulegen.
Als nächstes müssen wir unserer Applikation mitteilen, unter welcher URL die lokale MongoDB Instanz zu finden ist. Hierfür erweitern wir die application.yml Datei um den folgenden Eintrag.
spring:
data:
mongodb:
uri: mongodb://localhost:27017/customerService
Die komplette YAMl Datei sollte wie folgt aussehen.
server:
port: 8080
spring:
application:
name: customer-service
data:
mongodb:
uri: mongodb://localhost:27017/customerService
Spring Boot Data Interface erstellen
Nun haben wir das Konfigurative abgeschlossen. Jetzt ist es an der Zeit unser erstes Repository Interface zu erstellen. Repositories in Spring Boot sind Java Interfaces die von dem Interface „MongoRepository<T, ID>“ erben. Spring Data ist so aufgebaut, dass durch die Repository Interface Klassen die gängigsten Zugriffsmethoden bereits schon implementiert sind. Dies bedeutet für den Entwickler weniger Entwicklungsaufwand für CRUD Funktionalitäten. Der Entwickler kann sich ganz alleine auf die Businesslogik fokussieren.
Folgendes Codebeispiel zeigt unsere CustomerRepository.java Interface
package de.ertantoker.tutorial;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface CustomerRepository extends MongoRepository<Customer, String> {
}
Somit wären wir nun auch mit der Datenbankzugriffsschicht fertig. Wie man nun die Repository Klassen um weitere Methoden erweitert, werde ich in einem anderen Tutorial, welches sich nur um Spring Data widmen wird zeigen.
Spring Boot Data MongoDB Model Klasse
Im nächsten Schritt müssen wir noch unsere Model Klasse erweitern. Die Model Klasse muss um zwei Annotations erweitert werden.
Folgender Codeblock zeigt die erweiterte Model Klasse:
package de.ertantoker.tutorial;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document
public class Customer {
@Id
private String id;
private String firstname;
private String lastname;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}
Spring Boot RestController erweitern
Nachdem wir nun auch die Model Klasse erweitert haben, werden wir nun unsere Repository Klasse in unseren bestehenden CustomerController injecten. Hierfür werden wir die Konstruktor Injection von Spring verwenden. Das bedeutet, dass wir die CustomerController.java Klasse um eine Property private CustomerResporitoy customerRepository erweitern, und diese dann über den Konstruktor initialisieren.
Folgender Codeblock zeigt die neue Implementierung des CustomerControllers.
package de.ertantoker.tutorial;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/customers")
public class CustomerController {
private CustomerRepository customerRepository;
public CustomerController(CustomerRepository customerRepository) {
this.customerRepository = customerRepository;
}
@GetMapping
public ResponseEntity<List> getCustomers() {
return new ResponseEntity<>(customerRepository.findAll(), HttpStatus.OK);
}
@PostMapping
public ResponseEntity createCustomer(@RequestBody Customer customer) {
Customer savedCustomer = customerRepository.save(customer);
return new ResponseEntity<>(savedCustomer, HttpStatus.CREATED);
}
@GetMapping("/{id}")
public ResponseEntity getCustomerById(@PathVariable String id) {
return customerRepository.findById(id)
.map(customer -> new ResponseEntity<>(customer, HttpStatus.OK))
.orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND));
}
}
Spring Boot Data Projekt testen
Nun starten wir Postman und senden folgende POST Anfrage.
Wir wir sehen wurde unsere Post Anfrage mit einem CREATED vom Server beantwortet. Das bedeutet, dass der Kunde in der MongoDB gespeichert wurde. Um das zu kontrollieren rufen wir nun folgende GET URL auf: http://localhost:8080/customers. Das Ergebnis sieht ihr wie folgt.
Wir sehen beim Ergebnis vom POST Aufruf die selbe Id wie beim GET Aufruf. Somit handelt es sich um die gleichen Objekte. Abschließend riskieren wir einen Blick in die MongoDB. Hier sehen wir, dass Spring Data die Daten die gespeichert werden um eine „_id“ und „class“ angereichert hat.
Das Ergebnis
In diesem Tutorial haben wir gesehen, wie man eine Repository Klasse anlegt um Daten in einer MongoDB zu speichern. Wir haben auch gesehen wie man einen bestehenden Spring Rest Controller erweitert, um eine Repository Klasse zu verwenden. Mit diesem Wissen kann man nun weitere Spring Boot Microservices aufbauen.
Ich hoffe euch hat mein Tutorial gefallen. Würde mich über Kritik, Anregungen und Vorschläge freuen. Solltet ihr eine spezielle Frage haben, dann schreibt einfach unten ein Kommentar.
