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/
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
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.
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")
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() {
}
}
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
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": "axel@example.com"
}
Wenn Sie sich die MongoDB-Konsole ansehen, können Sie sehen, dass die Daten hinzugefügt wurden.
Wenn Sie eine GET-Anfrage an http: // localhost: 8080 / Kandidat senden, werden alle registrierten Benutzer zurückgegeben.
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.
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!
Recommended Posts