Java >> Java tutorial >  >> Tag >> Spring

Spring Boot CRUD-applikationseksempel med MongoDB

Spring

Introduktion

I dette indlæg vil jeg vise, hvordan vi kan bruge Spring Boot til at bygge et simpelt CRUD REST-applikationseksempel med MongoDB. Jeg ved, at dit første spørgsmål vil være, hvad er MongoDB?

Hvad er MongoDB?

MongoDB er en NoSQL dokumentdatabase. I denne database er poster dokumenter, der opfører sig meget som JSON-objekter. Så det er for det meste nøgle-værdi-par.

De vigtigste fordele ved at bruge MongoDB som en database er:

  • MongoDB er en dokumentdatabase uden skemaer. En samling indeholder forskellige dokumenter.
  • Strukturen af ​​et enkelt objekt er klar.
  • Ingen komplekse joinforbindelser
  • Dyb forespørgsel.
  • Nem at skalere ud

Her er de få grunde til, at du ville bruge MongoDB eller lignende NoSQL-databaser i en virksomhedsapplikation:

  • Hvis du har brug for hurtigere datahentning i JSON-stil
  • Nemt at tilføje indeks på en attribut
  • Til delingsformål – deling er processen med lagring af dataposter på tværs af flere maskiner. Du vil normalt opdele disse data i henhold til nogle kriterier, mens du gemmer på tværs af flere maskiner.
  • Hurtige opdateringer på stedet
  • Nemmere at forespørge

Forudsætninger

For at oprette denne eksempelapplikation skal du bruge:

  • Spring Boot (version 2.4.1)
  • MongoDB
  • Grad
  • Java

Spring Boot CRUD Application

Som en del af dette indlæg vil jeg bygge en REST CRUD-applikation. Dette inkluderer

  • Et bogbibliotek – Vi vil oprette en samling library i vores MongoDB-database.
  • Et bibliotek, hvor vi gemmer bøgerne efter forfatter
  • En bruger kan kalde REST API for at hente bogen efter forfatter
  • En bruger kan kalde REST API for at hente alle bøgerne fra biblioteket
  • POST – /v1/mongodbapp/books – For at tilføje en bog til biblioteket
  • GET – /v1/mongodbapp/books – For at hente alle bøgerne fra biblioteket
  • GET – /v1/mongodbapp/books/id – For at hente en bestemt bog
  • SLET – /v1/mongodbapp/books/id – For at fjerne en bog fra biblioteket

Sådan bruger du Spring Boot CRUD med MongoDB

For at komme i gang med at oprette denne applikation vil vi bruge gradle til at håndtere vores afhængigheder og bygge applikationen. Tilføj følgende afhængigheder i vores Spring Boot-applikation:

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

MongoDB-forbindelsesegenskaber

Når vi har disse afhængigheder, vil vi være i stand til at oprette forbindelse til mongo db database. Men vi mangler stadig at tilføje, hvor vores database er placeret. Vi tilføjer de nødvendige egenskaber i vores application.properties fil som nedenfor:

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

Dette giver os mulighed for at oprette forbindelse til MongoDB-databasen, der kører på værten localhost på porten 27017 og databaseskemaet er library .

Definer datamodel

Som en del af biblioteket skal vi bruge bøger. Så vores vigtigste dataobjekt er bog. Datamodellen for dette vil omfatte bogtitel, forfatter og ISBN. Dette vil være som følger:

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 vi bruger MongoDB, @Document annotation tilsidesætter samlingen books .

Tilføj lagergrænseflade

Vi skal bruge en lagergrænseflade for at hente, gemme eller slette vores bogobjekt. I repositories pakke, tilføjer vi BookRepository grænseflade


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

Dette lager har to metoder til at hente en liste over bøger efter en titel eller forfatternavn.

Tilføj Spring REST API-controller

For at gøre vores applikation til REST CRUD tilføjer vi en REST-controller. Denne controller vil indeholde POST , PUT , GET og DELETE API'er.


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 er vores REST Controller klasse. Det inkluderer

  • @RestController – for at markere dette som en REST-controller.
  • @CrossOrigin – Denne annotation tillader cross-origin ressource sharing (CORS). Dette vil tilføje CORS-adgangskontroloverskrifter i REST-svaret. Disse overskrifter er nødvendige, fordi det giver servere mulighed for ikke kun at angive, hvem der har adgang til ressourcerne, men også hvordan de kan tilgås.
  • Vi har tilføjet forskellige metoder – addABookToLibrary tilføjer bogen til databasen, getAllBooks henter bogen fra databasen.

Den komplette demo

Nu har vi tilføjet vores REST-controller, repository-metoder, vi vil bygge og køre denne applikation. Som en del af demoen vil jeg bruge POSTMAN til at få adgang til API'er.

Du kan bygge applikationen fra kommandolinjen eller fra den kodeeditor, du bruger. Jeg foretrækker kommandolinje, så jeg har allerede bygget applikationen. Når det er bygget, kan du køre programmet som følger:

java -jar mongodbapp-0.0.1-SNAPSHOT.jar .

Lad os bruge POSTMAN til at tilføje bøger til vores bibliotek.

Som vist ovenfor tilføjede vi en bog, og svaret viser tilføjet bog i databasen.

Følgende API er en GET API til at hente alle bøgerne fra databasen.

For nu at vise slet bogen fra biblioteket, vil vi bruge DELETE API.

Koden til denne eksempelapplikation er tilgængelig i mit github-lager.

Hvis du vil se disse data i MongoDB-databasen, kan du få adgang til MongoDB-kompasværktøjet og få adgang til samlingsbøgerne i biblioteksdatabasen.

Konklusion

I dette indlæg viste jeg, hvordan man bruger Spring Boot til at oprette REST API, mens jeg bruger MongoDB-databasen. Den tilgang, vi brugte, ligner meget, hvad vi har, mens vi bruger en almindelig SQL-database. Der er nogle ændringer, som vi skal tilføje, mens vi bruger NoSQL-databasen. Hvis du finder dette indlæg nyttigt eller har spørgsmål, som jeg kan hjælpe dig med, kan du abonnere på min blog her. Jeg præ-lancerede for nylig min bog – Simplifying Spring Security, som udkommer den 7. februar 2021. Du kan forudbestille den her.

Referencer

1. Spring Boot MongoDB References – MongoDB Reference

2. Spring Boot Blog – Blog


Java tag