Spring Boot: RESTful API mit Spring Boot und MongoDB

In diesem Tutorial wird erläutert, wie Sie einen RESTful-Webdienst mit SpringBoot und MongoDB implementieren. Dieses Tutorial verwendet bereits implementierte REST-Dienste mit Node.js- und ExpressJS-Frameworks. Hier die gleichen Beispiele, die mit SpringBoot getestet wurden.

Im Folgenden sind die Frameworks aufgeführt, die in diesem Tutorial zum Ausführen des angegebenen Beispiels verwendet werden. Wenn Sie sehr daran interessiert sind, das zu lernen REST-Webservices-Konzeptebesuchen Sie bitte den Weltklasse-Videokurs unseres Kumpels Eugen unter ERSTELLEN SIE IHRE REST-API MIT SPRING.

  • Frühlingsstiefel
  • MongoDB
  • ExpressJS
  • Node.js
  • RESTful-Konzepte

In diesem Beitrag werde ich das implementieren REST-API in einem meiner vorherigen Beiträge hier entworfen.

Erstellen Sie eine RESTful-API mit Spring Boot und MongoDB

Erstellen Sie eine RESTful-API mit Spring Boot und MongoDB

Erstellen eines einfachen Maven-Projekts in Eclipse

Die folgenden Schritte helfen Ihnen, ein einfaches Maven-Projekt in Eclipse zu erstellen. Wir haben mehrere gute Tutorials zu Maven für Anfänger. Wenn Sie nach interessanten Lektüren zu Maven suchen, lesen Sie bitte Apache Maven für Anfänger, Erstellen Sie ein Webanwendungsprojekt mit Maven Und So erstellen Sie eine Spring MVC-Anwendung mit Maven.

Auswahl des Projekttyps

SpringBoot MongoDB RESTAPI

SpringBoot MongoDB RESTAPI

Auswahl des Arbeitsbereichs und des Archetyps

SpringBoot MongoDB RESTAPI MAVEN

SpringBoot MongoDB RESTAPI MAVEN

Maven-Projekteigenschaften
SpringBoot MongoDB RESTAPI MAVEN 1

Die endgültige Projektstruktur
SpringBoot MongoDB RESTAPI MAVEN-Projekt

Da nun der grundlegende Maven-basierte Spring Boot fertig ist, möchte ich Ihnen einen Überblick über Springboot und die Idee dahinter geben.

REST-API mit Spring Boot und MongoDB

Was ist Spring Boot?

Spring Boot ist ein Ansatz zur Entwicklung von Spring-basierten Anwendungen mit sehr wenig Konfiguration. Es nutzt bestehende Spring-Projekte sowie Projekte von Drittanbietern, um produktionsreife Anwendungen zu entwickeln. Es bietet eine Reihe von Starter-Pom- oder Gradle-Build-Dateien, die zum Hinzufügen erforderlicher Abhängigkeiten und zur Erleichterung der automatischen Konfiguration verwendet werden können.

Abhängig von den Bibliotheken in seinem Klassenpfad konfiguriert Spring Boot automatisch die erforderlichen Klassen. Wenn sich beispielsweise für die Interaktion mit der Datenbank Spring Data-Bibliotheken im Klassenpfad befinden, wird automatisch eine Verbindung zur Datenbank zusammen mit der Datenquellenklasse eingerichtet.

Weitere Informationen zu Spring Boot finden Sie hier Hier.

Erstellen eines RESTful-Webdienstes

Ich werde Ihnen nicht zeigen, wie man ein erstellt RESTful-Webdienst mit Spring Boot. Die API, die ich in diesem Beitrag implementieren werde, wurde bereits in einem meiner vorherigen Beiträge hier definiert.

Spring-Boot-Starter-Elternteil

Lasst uns das aktualisieren pom.xml Zum Hinzufügen beziehen Sie sich auf den übergeordneten Pom, der lautet: spring-boot-starter-parent. Dies ist der vom Spring Boot-Projekt bereitgestellte Starter-POM. Dieser Start-Pom:

  • Richtet die Maven-Eigenschaften ein
  • Grundlegende Abhängigkeit vom Federkern
  • Einrichten des Speicherorts für Ressourcendateien
  • Einrichten von Maven-Plugins, einschließlich des von Spring Boot bereitgestellten Plugins zum Ausführen seiner Anwendung
<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>net.javabeat</groupId>
	<artifactId>springboot-rest-demo</artifactId>
	<version>0.1</version>
	<name>Spring Boot REST API Demo</name>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.2.3.RELEASE</version>
	</parent>
</project>

Spring-Boot-Starter-Web

Um einen RESTful-Dienst zu erstellen, müssten wir Folgendes verwenden: Spring Web, JSON-Verarbeitungsbibliotheken, eingebettete Tomcat- oder Tomcat-Bibliotheken, möglicherweise eine Bibliothek für Validatoren wie den Hibernate-Validator. Möglicherweise erinnern wir uns nicht an alle erforderlichen Abhängigkeiten oder müssen irgendwo nachschlagen, um zu erfahren, welche Abhängigkeiten erforderlich sind.

Um solche Probleme zu lösen, stellt Spring Boot einen POM bereit, der bereits mit den zum Erstellen einer Webanwendung erforderlichen Abhängigkeiten konfiguriert ist. Dieser POM heißt: spring-boot-starter-web. Wenn wir unsere pom.xml aktualisieren, um sie als Abhängigkeit hinzuzufügen, erhalten wir:

<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>net.javabeat</groupId>
	<artifactId>springboot-rest-demo</artifactId>
	<version>0.1</version>
	<name>Spring Boot REST API Demo</name>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.2.3.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>
</project>

Ebenso haben wir einen Pom: spring-boot-starter-data-mongodb Dazu gehören Abhängigkeiten zum Mongo-Java-Treiber, zur Spring-Transaktion und zu Spring-Daten für Mongodb. Unsere endgültige pom.xml sieht also so aus:

<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>net.javabeat</groupId>
	<artifactId>springboot-rest-demo</artifactId>
	<version>0.1</version>
	<name>Spring Boot REST API Demo</name>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.2.3.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
	</dependencies>
</project>

Spring Boot-Anwendung

Wir müssen eine Hauptklasse erstellen, die die Spring Boot-Anwendung initialisiert und ausführt. Wir kommentieren die Klasse auch mit @SpringBootApplication. Diese Annotation weist die Spring-Anwendung an, die automatische Konfiguration und den Komponentenscan zu aktivieren, und teilt der Spring-Anwendung außerdem mit, dass es sich bei dieser bestimmten Klasse auch um eine Konfiguration handelt:

package app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

 public static void main(String[] args) throws Exception {
 SpringApplication.run(new Object[] { Application.class }, args);
 }
}

Implementierung der RESTful APIs

Lassen Sie mich eine Modellklasse erstellen, um die aus der Datenbank abgerufenen Buchdetails zu speichern.

package app.model;

import org.springframework.data.annotation.Id;

public class Book {

  @Id
  private String id;
  private String name;
  private String isbn;
  private String author;
  private int pages;

  public Book(){}

  public Book(String name, String isbn, String author, int pages){
    this.name = name;
    this.isbn = isbn;
    this.author = author;
    this.pages = pages;
  }

  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getIsbn() {
    return isbn;
  }
  public void setIsbn(String isbn) {
    this.isbn = isbn;
  }
  public String getAuthor() {
    return author;
  }
  public void setAuthor(String author) {
    this.author = author;
  }
  public int getPages() {
    return pages;
  }
  public void setPages(int pages) {
    this.pages = pages;
  }
}

Fügen wir die Repository-Klasse hinzu, um mit der Datenbank zu interagieren

package app.repository;

import app.model.Book;

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

public interface BookRepository extends MongoRepository<Book, String>{
}

Das MongoRepository bietet grundlegende CRUD-Operationsmethoden und auch eine API, um alle Dokumente in der Sammlung zu finden.

Implementieren der API zum Erstellen und Abrufen von Details

Lassen Sie uns unseren Controller implementieren. Erstens gibt es die API zum Erstellen eines neuen Buchs und zum Abrufen der Details eines bestimmten Buchs:

package app.controller;
import java.util.LinkedHashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
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 app.model.Book;
import app.repository.BookRepository;

@RestController
@RequestMapping("/book")
public class BookController {

  @Autowired
  private BookRepository bookRepository;

  @RequestMapping(method = RequestMethod.POST)
  public Map<String, Object> createBook(@RequestBody Map<String, Object> bookMap){
    Book book = new Book(bookMap.get("name").toString(),
        bookMap.get("isbn").toString(),
        bookMap.get("author").toString(),
        Integer.parseInt(bookMap.get("pages").toString()));

    bookRepository.save(book);
    Map<String, Object> response = new LinkedHashMap<String, Object>();
    response.put("message", "Book created successfully");
    response.put("book", book);
    return response;
  }

  @RequestMapping(method = RequestMethod.GET, value="/{bookId}")
  public Book getBookDetails(@PathVariable("bookId") String bookId){
    return bookRepository.findOne(bookId);
  }
}

Lassen Sie uns die Anwendung ausführen, indem wir entweder das Spring Boot-Maven-Plugin verwenden, z. B. indem wir es ausführen mvn spring-boot:run oder durch Ausführen der Hauptklasse Application.java von Eclipse oder Ihrer IDE. Ich werde den Postman REST Client verwenden, um die Erstellungs-API aufzurufen:
1

Unten sehen Sie den Screenshot von Postman zum Aufrufen der Get Book Details API:
2

Implementierung der Update-API

Jetzt implementieren wir die Update-API (zeigen nur die hier implementierte Methode, sie sollte Teil der oben definierten BookController-Klasse sein):

  @RequestMapping(method = RequestMethod.PUT, value="/{bookId}")
  public Map<String, Object> editBook(@PathVariable("bookId") String bookId,
      @RequestBody Map<String, Object> bookMap){
    Book book = new Book(bookMap.get("name").toString(),
        bookMap.get("isbn").toString(),
        bookMap.get("author").toString(),
        Integer.parseInt(bookMap.get("pages").toString()));
    book.setId(bookId);

    Map<String, Object> response = new LinkedHashMap<String, Object>();
    response.put("message", "Book Updated successfully");
    response.put("book", bookRepository.save(book));
    return response;
  }

Screenshot vom Postman REST-Client nach der Ausführung des Updates:
3

Implementierung der Lösch-API

  @RequestMapping(method = RequestMethod.DELETE, value="/{bookId}")
  public Map<String, String> deleteBook(@PathVariable("bookId") String bookId){
    bookRepository.delete(bookId);
    Map<String, String> response = new HashMap<String, String>();
    response.put("message", "Book deleted successfully");

    return response;
  }

Screenshot vom Postman REST-Client nach dem Ausführen des Löschvorgangs:
4

Implementierung der Get All Books-API

  @RequestMapping(method = RequestMethod.GET)
  public Map<String, Object> getAllBooks(){
    List<Book> books = bookRepository.findAll();
    Map<String, Object> response = new LinkedHashMap<String, Object>();
    response.put("totalBooks", books.size());
    response.put("books", books);
    return response;
  }

Screenshot vom Postman REST-Client nach der Ausführung von „Alle Bücher abrufen“:

5

Damit habe ich Ihnen gezeigt, wie Sie eine REST-API für CRUD-Operationen erstellen Spring Boot und MongoDB. Man sieht, dass ich mit minimaler Konfiguration eine vollständige Implementierung der REST-API schreiben konnte. Ich hoffe, dass dieses Tutorial zum Verständnis beigetragen hat wie man eine Spring Boot-Anwendung mit MongoDB schreibt.

MongoDB ist die beliebte NoSQL-Datenbank und Spring Boot ist das neueste Framework der Spring-Community zum Ausführen der Spring-Anwendungen mit minimalen Konfigurationen. Daher bilden Spring Boot und MongoDB eine gute Kombination, um beim Aufbau der RESTful-APIs zusammenzuarbeiten.

Wenn Sie Fragen zum Schreiben einer Spring Boot-Anwendung mit MongoDB haben, schreiben Sie diese bitte in den Kommentarbereich. Sie können auch unten auf meinen Github zugreifen, um den vollständigen Code für ein Spring Boot- und MongoDB-Integrationsbeispiel zu erhalten. Viel Spaß beim Lesen!!!

Das Projekt ist auf Github zu finden Hier.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen