Java >> Java Tutorial >  >> Tag >> Spring

Spring Boot CRUD-Anwendungsbeispiel mit MongoDB

Spring

Einführung

In diesem Beitrag werde ich zeigen, wie wir Spring Boot verwenden können, um ein einfaches CRUD-REST-Anwendungsbeispiel mit MongoDB zu erstellen. Ich weiß, Ihre erste Frage lautet:Was ist MongoDB?

Was ist MongoDB?

MongoDB ist eine NoSQL-Dokumentendatenbank. In dieser Datenbank sind Datensätze Dokumente, die sich sehr ähnlich wie JSON-Objekte verhalten. Es handelt sich also hauptsächlich um Schlüssel-Wert-Paare.

Die Hauptvorteile der Verwendung von MongoDB als Datenbank sind:

  • MongoDB ist eine schemalose Dokumentendatenbank. Eine Sammlung enthält verschiedene Dokumente.
  • Die Struktur eines einzelnen Objekts ist klar.
  • Keine komplexen Verknüpfungen
  • Tiefe Abfragefähigkeit.
  • Einfache Skalierung

Hier sind einige Gründe, warum Sie MongoDB oder ähnliche NoSQL-Datenbanken in Unternehmensanwendungen verwenden sollten:

  • Wenn Sie einen schnelleren Datenabruf im JSON-Stil benötigen
  • Einfach Index zu einem Attribut hinzuzufügen
  • Für Sharding-Zwecke – Sharding ist der Vorgang des Speicherns von Datensätzen auf mehreren Computern. Normalerweise partitionieren Sie diese Daten nach bestimmten Kriterien, während Sie sie auf mehreren Computern speichern.
  • Schnelle In-Place-Updates
  • Einfacher abzufragen

Voraussetzungen

Um diese Beispielanwendung zu erstellen, benötigen Sie:

  • Spring Boot (Version 2.4.1)
  • MongoDB
  • Gradle
  • Java

Spring Boot CRUD-Anwendung

Als Teil dieses Beitrags werde ich eine REST-CRUD-Anwendung erstellen. Dazu gehört

  • Eine Buchbibliothek – Wir werden eine Sammlung erstellen library in unserer MongoDB-Datenbank.
  • Eine Bibliothek, in der wir die Bücher nach Autor geordnet aufbewahren
  • Ein Benutzer kann die REST-API aufrufen, um das Buch nach Autor abzurufen
  • Ein Benutzer kann die REST-API aufrufen, um alle Bücher aus der Bibliothek abzurufen
  • POST – /v1/mongodbapp/books – Um ein Buch zur Bibliothek hinzuzufügen
  • GET – /v1/mongodbapp/books – Um alle Bücher aus der Bibliothek abzurufen
  • GET – /v1/mongodbapp/books/id – Um ein bestimmtes Buch abzurufen
  • DELETE – /v1/mongodbapp/books/id – Um ein Buch aus der Bibliothek zu entfernen

Verwendung von Spring Boot CRUD mit MongoDB

Um mit der Erstellung dieser Anwendung zu beginnen, verwenden wir gradle, um unsere Abhängigkeiten zu handhaben und die Anwendung zu erstellen. Fügen Sie die folgenden Abhängigkeiten in unserer Spring Boot-Anwendung hinzu:

implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
implementation 'org.springframework.boot:spring-boot-starter-web'

MongoDB-Verbindungseigenschaften

Sobald wir diese Abhängigkeiten haben, können wir eine Verbindung zur Mongo-DB-Datenbank herstellen. Aber wir müssen noch hinzufügen, wo sich unsere Datenbank befindet. Wir werden die erforderlichen Eigenschaften in unserem application.properties hinzufügen Datei wie folgt:

spring.data.mongodb.host = localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=library

Dadurch können wir eine Verbindung zur MongoDB-Datenbank herstellen, die auf Host localhost ausgeführt wird auf dem Port 27017 und das Datenbankschema ist library .

Datenmodell definieren

Als Teil der Bibliothek benötigen wir Bücher. Unser Hauptdatenobjekt ist also Book. Das Datenmodell dafür enthält Buchtitel, Autor und ISBN. Dies wird wie folgt aussehen:

package com.betterjavacode.mongodbdemo.mongodbapp.models;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;



@Document(collection = "books")
public class Book
{
    @Id
    private String id;

    private String title;
    private String author;
    private String isbn;

    public Book()
    {

    }

    public Book(String title, String author, String isbn)
    {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }

    public String getId ()
    {
        return id;
    }

    public void setId (String id)
    {
        this.id = id;
    }

    public String getTitle ()
    {
        return title;
    }

    public void setTitle (String title)
    {
        this.title = title;
    }

    public String getAuthor ()
    {
        return author;
    }

    public void setAuthor (String author)
    {
        this.author = author;
    }

    public String getIsbn ()
    {
        return isbn;
    }

    public void setIsbn (String isbn)
    {
        this.isbn = isbn;
    }
}

Da wir MongoDB verwenden, @Document Anmerkung überschreibt die Sammlung books .

Repository-Schnittstelle hinzufügen

Wir benötigen eine Repository-Schnittstelle, um unser Buchobjekt abzurufen, zu speichern oder zu löschen. In repositories Paket, fügen wir BookRepository hinzu Schnittstelle


package com.betterjavacode.mongodbdemo.mongodbapp.repositories;

import com.betterjavacode.mongodbdemo.mongodbapp.models.Book;
import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

public interface BookRepository extends MongoRepository<Book, String>
{
    List findByTitleContaining(String title);
    List findByAuthor(String name);
}

Dieses Repository hat zwei Methoden, um eine Liste von Büchern nach Titel oder nach Autorennamen abzurufen.

Spring-REST-API-Controller hinzufügen

Um unsere Anwendung nun zu REST CRUD zu machen, fügen wir einen REST-Controller hinzu. Dieser Controller enthält POST , PUT , GET und DELETE APIs.


package com.betterjavacode.mongodbdemo.mongodbapp.controller;

import com.betterjavacode.mongodbdemo.mongodbapp.models.Book;
import com.betterjavacode.mongodbdemo.mongodbapp.repositories.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@CrossOrigin("http://localhost:8080")
@RestController
@RequestMapping("/v1/mongodbapp")
public class BookController
{
    @Autowired
    BookRepository bookRepository;

    @GetMapping("/books")
    public ResponseEntity<List> getAllBooks(@RequestParam(required = false) String bookTitle)
    {
        try
        {
            List listOfBooks = new ArrayList<>();
            if(bookTitle == null || bookTitle.isEmpty())
            {
                bookRepository.findAll().forEach(listOfBooks::add);
            }
            else
            {
                bookRepository.findByTitleContaining(bookTitle).forEach(listOfBooks::add);
            }

            if(listOfBooks.isEmpty())
            {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }

            return new ResponseEntity<>(listOfBooks, HttpStatus.OK);
        }
        catch (Exception e)
        {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/books/{id}")
    public ResponseEntity getBookById(@PathVariable("id") String id)
    {
        try
        {
            Optional bookOptional = bookRepository.findById(id);

            return new ResponseEntity<>(bookOptional.get(), HttpStatus.OK);
        }
        catch (Exception e)
        {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PostMapping("/books")
    public ResponseEntity addABookToLibrary(@RequestBody Book book)
    {
        try
        {
            Book createdBook = bookRepository.save(new Book(book.getTitle(), book.getAuthor(),
                    book.getIsbn()));
            return new ResponseEntity<>(createdBook, HttpStatus.CREATED);
        }
        catch (Exception e)
        {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PutMapping("/books/{id}")
    public ResponseEntity updateABook(@PathVariable("id") String id, @RequestBody Book book)
    {
        Optional bookOptional = bookRepository.findById(id);

        if(bookOptional.isPresent())
        {
            Book updatedBook = bookOptional.get();
            updatedBook.setTitle(book.getTitle());
            updatedBook.setAuthor(book.getAuthor());
            updatedBook.setIsbn(book.getIsbn());
            return new ResponseEntity<>(bookRepository.save(updatedBook), HttpStatus.OK);
        }
        else
        {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @DeleteMapping("/books/{id}")
    public ResponseEntity deleteABook(@PathVariable("id") String id)
    {
        try
        {
            bookRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        catch (Exception e)
        {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

BookController ist unsere REST-Controller-Klasse. Es enthält

  • @RestController – um dies als REST-Controller zu markieren.
  • @CrossOrigin – Diese Anmerkung ermöglicht Cross-Origin Resource Sharing (CORS). Dadurch werden der REST-Antwort CORS-Zugriffssteuerungsheader hinzugefügt. Diese Header sind notwendig, da sie es Servern ermöglichen, nicht nur anzugeben, wer auf die Ressourcen zugreifen kann, sondern auch, wie auf sie zugegriffen werden kann.
  • Wir haben verschiedene Methoden hinzugefügt – addABookToLibrary fügt das Buch zur Datenbank hinzu, getAllBooks Ruft das Buch aus der Datenbank ab.

Die vollständige Demo

Nachdem wir unseren REST-Controller und Repository-Methoden hinzugefügt haben, werden wir diese Anwendung erstellen und ausführen. Als Teil der Demo werde ich POSTMAN verwenden, um auf APIs zuzugreifen.

Sie können die Anwendung über die Befehlszeile oder den von Ihnen verwendeten Code-Editor erstellen. Ich bevorzuge die Befehlszeile, also habe ich die Anwendung bereits erstellt. Einmal erstellt, können Sie das Programm wie folgt ausführen:

java -jar mongodbapp-0.0.1-SNAPSHOT.jar .

Lassen Sie uns POSTMAN verwenden, um Bücher zu unserer Bibliothek hinzuzufügen.

Wie oben gezeigt, haben wir ein Buch hinzugefügt und die Antwort zeigt das hinzugefügte Buch in der Datenbank.

Die folgende API ist eine GET-API zum Abrufen aller Bücher aus der Datenbank.

Um nun anzuzeigen, dass das Buch aus der Bibliothek gelöscht wird, verwenden wir die DELETE-API.

Der Code für diese Beispielanwendung ist in meinem Github-Repository verfügbar.

Wenn Sie diese Daten in der MongoDB-Datenbank sehen möchten, können Sie auf das MongoDB-Kompass-Tool zugreifen und auf die Sammlungsbücher in der Bibliotheksdatenbank zugreifen.

Schlussfolgerung

In diesem Beitrag habe ich gezeigt, wie man mit Spring Boot eine REST-API erstellt, während man die MongoDB-Datenbank verwendet. Der von uns verwendete Ansatz ist dem sehr ähnlich, den wir bei der Verwendung einer regulären SQL-Datenbank haben. Es gibt einige Änderungen, die wir bei der Verwendung der NoSQL-Datenbank hinzufügen müssen. Wenn Sie diesen Beitrag nützlich finden oder Fragen haben, bei denen ich Ihnen helfen kann, können Sie hier meinen Blog abonnieren. Ich habe vor Kurzem mein Buch „Simplifying Spring Security“ vorab veröffentlicht, das am 7. Februar 2021 erscheinen wird. Sie können es hier vorbestellen.

Referenzen

1. Spring Boot MongoDB-Referenzen – MongoDB-Referenz

2. Spring Boot-Blog – Blog


Java-Tag