Was ist dieser Artikel?

Dies ist eine praktische Seite zum Erstellen einer REST-API mithilfe von Spring Boot unter Verwendung von MongoDB als Datenspeicher. Da es sich um einen Trainingsansturm handelt, möchten wir das Erleben vereinfachen, indem wir die Abläufe nacheinander zusammenfassen und kopieren.

Der Inhalt selbst ist fast das folgende Kopieren und Einfügen. Ich wollte Gradle verwenden, deshalb habe ich den Inhalt ein wenig geändert. https://stackabuse.com/spring-data-mongodb-tutorial/

Annahme

Haben Java berührt
Kann IntelliJ IDEA verwenden
Wissen, was die REST-API ist
Kann Postman verwenden
Bitte beziehen Sie sich auf diesen Bereich: https://qiita.com/notch0314/items/97c7d1bb565fdae4a712
Was Sie über NoSQL / MongoDB wissen

Implementierungsübersicht

Erstellen Sie eine REST-API mit Spring Boot. Verwenden Sie MongoDB für den Datenspeicher und CRUD die MongoDB-Daten auf Anfrage

Das fertige Produkt ist auf dem GitHub unten aufgeführt. Wenn es nicht funktioniert, lesen Sie es bitte. https://github.com/theMistletoe/MongoDB-SpringBoot-sample

Praktisches Verfahren

MongoDB-Setup

Melden Sie sich für MongoDB an https://account.mongodb.com/account/register

Klicken Sie nach der Anmeldung auf "Cluster erstellen".

Ich möchte es kostenlos machen, also wähle KOSTENLOS

Cluster-Einstellungen. Sie müssen es nicht ändern.

Der Clusteraufbau wird gestartet.

Erstellen Sie nach dem Erstellen des Clusters zunächst einen Benutzer für den Datenbankzugriff.

Wählen Sie die Kennwortauthentifizierung und geben Sie den Benutzernamen und das Kennwort ein, um einen Benutzer zu erstellen. Merken Sie sich diesen Benutzernamen und dieses Passwort, da Sie sie später verwenden werden.

Benutzer wurde erstellt

Richten Sie als Nächstes den Netzwerkzugriff ein. Sie können eine weiße Liste mithilfe von IP-Adressen definieren. Stellen Sie sie daher so ein, dass sie zum Üben eine beliebige IP-Adresse akzeptiert. (Da die Sicherheit für die Praxis nicht ausreichend ist, verwenden Sie sie bitte nicht mehr in der Produktion.)

Klicken Sie zur Bestätigung auf [ZUGRIFF VON ÜBERALL ERLAUBEN]

Machen wir eine DB Klicken Sie auf Cluster COLLECTIONS

Klicken Sie auf Meine eigenen Daten hinzufügen

Geben Sie "Jobs" für den Datenbanknamen und "Kandidat" für den zu erstellenden Sammlungsnamen ein

Nach dem Erstellen der Datenbank wird der Konsolenbildschirm angezeigt. Spätere Datenaktualisierungen werden hier wiedergegeben.

Dies ist das Ende des MongoDB-Setups.

Aufbau der Spring Boot-Umgebung

Gehen Sie zu Spring Initializr, stellen Sie die Vorlage wie im Bild gezeigt ein und laden Sie die Zip-Datei mit Generieren herunter.

Entpacken Sie die Zip-Datei und öffnen Sie sie in IntelliJ. Öffnen Sie zunächst application.properties und legen Sie die Zugriffsinformationen von MongoDB fest.


spring.data.mongodb.uri=mongodb+srv://user:<password>@cluster0.ayoho.mongodb.net/<dbname>?retryWrites=true&w=majority

Die Einstellungen für spring.data.mongodb.uri können über die MongoDB-Konsole abgerufen werden.

Verwenden Sie das Kennwort und den Datenbanknamen, die während der MongoDB-Einrichtung festgelegt wurden. (Wenn Sie die Prozedur befolgen, ist Datenbankname "Jobs")

Implementierung des Java-Programms

Jetzt schreiben wir Java. Ich kann die detaillierte Implementierung nicht erklären. Bitte versuchen Sie zu schreiben, während Sie unklare Punkte lösen. Sie können es überall platzieren, aber bitte lesen Sie die Paketinformationen oder GitHub.

`Candidate.java`


package com.example.mongoDBsample.entity;

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

@Document(collection = "candidate")
public class Candidate {
    @Id
    private String id;

    private String name;

    private double exp;

    @Indexed(unique = true)
    private String email;

    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 double getExp() {
        return exp;
    }

    public void setExp(double exp) {
        this.exp = exp;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

`CandidateRepository.java`


package com.example.mongoDBsample.repository;

import com.example.mongoDBsample.entity.Candidate;
import org.springframework.data.mongodb.repository.MongoRepository;

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

public interface CandidateRepository extends MongoRepository<Candidate, String> {
    Optional<Candidate> findByEmail(String email);

    List<Candidate> findByExpGreaterThanEqual(double exp);

    List<Candidate> findByExpBetween(double from, double to);
}

`CandidateController.java`


package com.example.mongoDBsample.controller;

import com.example.mongoDBsample.exception.ResourceNotFoundException;
import com.example.mongoDBsample.entity.Candidate;
import com.example.mongoDBsample.repository.CandidateRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/candidate")
public class CandidateController {

    @Autowired
    private CandidateRepository candidateRepository;

    @PostMapping
    @ResponseStatus(code = HttpStatus.CREATED)
    public Candidate add(@RequestBody Candidate candidate) {
        return candidateRepository.save(candidate);
    }

    @GetMapping
    public List<Candidate> getAll() {
        return candidateRepository.findAll();
    }

    @GetMapping(value = "/{id}")
    public Candidate getOne(@PathVariable String id) {
        return candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
    }

    @PutMapping(value = "/{id}")
    public Candidate update(@PathVariable String id, @RequestBody Candidate updatedCandidate) {
        Candidate candidate = candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
        candidate.setName(updatedCandidate.getName());
        candidate.setExp(updatedCandidate.getExp());
        candidate.setEmail(updatedCandidate.getEmail());
        return candidateRepository.save(candidate);
    }

    @DeleteMapping(value = "/{id}")
    @ResponseStatus(code = HttpStatus.ACCEPTED)
    public void delete(@PathVariable String id) {
        Candidate candidate = candidateRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException());
        candidateRepository.delete(candidate);
    }

    @GetMapping("/searchByEmail")
    public Candidate searchByEmail(@RequestParam(name = "email") String email) {
        return candidateRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException());

    }

    @GetMapping("/searchByExp")
    public List<Candidate> searchByExp(@RequestParam(name = "expFrom") Double expFrom, @RequestParam(name = "expTo", required = false) Double expTo) {
        List<Candidate> result = new ArrayList<>();
        if (expTo != null) {
            result = candidateRepository.findByExpBetween(expFrom, expTo);
        } else {
            result = candidateRepository.findByExpGreaterThanEqual(expFrom);
        }
        return result;
    }
}

`ResourceNotFoundException.java`


package com.example.mongoDBsample.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException() {
    }
}

Bestätigung der Umsetzung

Nachdem die Implementierung abgeschlossen ist, überprüfen wir, ob der Datenzugriff über die API möglich ist.

Starten Sie die App auf IntelliJ

Oder führen Sie zum Starten Folgendes in CUI aus

./gradlew bootRun

Benutzer registrieren

Lassen Sie uns zuerst den Benutzer registrieren. Wenn Sie eine POST-Anforderung an http: // localhost: 8080 / Candidate / senden und das folgende JSON-Objekt an den Body angehängt ist, Die registrierten Benutzerinformationen werden in der Antwort zurückgegeben.

{
    "name": "Axel",
    "exp": "10",
    "email": "[email protected]"
}

Wenn Sie sich die MongoDB-Konsole ansehen, können Sie sehen, dass die Daten hinzugefügt wurden.

Benutzer durchsuchen

Wenn Sie eine GET-Anfrage an http: // localhost: 8080 / Kandidat senden, werden alle registrierten Benutzer zurückgegeben.

Benutzerinformationen aktualisieren

In einer PUT-Anfrage an http: // localhost: 8080 / Kandidat / {Benutzer-ID} Wenn Sie das aktualisierte JSON-Objekt an den Body anhängen, werden die Registrierungsinformationen aktualisiert.

Benutzer löschen

Durch Auslösen einer DELETE-Anforderung an http: // localhost: 8080 / Kandidat / {Benutzer-ID} Sie können den Benutzer löschen.

das ist alles.

Ich denke, Sie haben MongoDB / SpringBoot erstellt, um die Grundlagen eines REST-API-Backends zu implementieren, mit dem Sie Ihren Datenspeicher verwenden können. Lassen Sie uns dies erweitern oder eine Anwendung in Zusammenarbeit mit dem Frontend erstellen!

Erstellen wir eine REST-API mit SpringBoot + MongoDB