Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision. Weiterlesen.

Das Akronym REST steht für REpresentational State Transfer, während API für Application Programming Interface steht. Zusammen verweisen sie auf eine REST-API. Eine REST-API ist ein Dienst, der Anforderungen und Antworten zwischen zwei Softwaresystemen auf einer REST-Architektur überträgt.

Die REST-Architektur erstellt Webdienste, auf die über URLs mit einem von vier Anforderungsverben zugegriffen werden kann: POST, GET, PUT und DELETE. Man könnte also sagen, dass eine REST-API eine Software ist, mit der Sie Ressourcen über URLs erstellen, lesen, aktualisieren und löschen können.

Sie können lernen, wie Sie mit Spring Boot eine REST-API erstellen.

Initialisieren der Spring Boot-Anwendung

Das erste, was Sie tun sollten, ist Machen Sie sich mit den Grundlagen des Frühlings vertraut und richten Sie eine Spring Boot-Anwendung ein. Sie müssen jedoch die Abhängigkeiten ändern. Zusätzlich zur Web-Abhängigkeit benötigen Sie die Spring Data Java Persistent API (JPA)-Abhängigkeit und den Treiber für die Datenbank, die Sie verwenden möchten (diese Anwendung verwendet MySQL).

Für diese REST-API benötigen Sie einen Controller, ein Modell und ein Repository. Die REST-API hat also die folgende Dateistruktur:

Erstellen des Modells

Die erste Klasse, die Sie erstellen müssen, ist das Kundenmodell, das die Datenlogik speichert.

Paket com.onlineshopaholics.api.model;
importieren jakarta.persistenz. Spalte;
importieren jakarta.persistenz. Juristische Person;
importieren jakarta.persistenz. Generierter Wert;
importieren jakarta.persistenz. GenerationType;
importieren jakarta.persistenz. Ausweis;
importieren jakarta.persistenz. Tisch;


@Tisch(Name="Kunde")
@Juristische Person
öffentlichKlasseKunde{
@Ausweis
@ErzeugterWert(Strategie = GenerationType. AUTO)
Privatgelände Ganzzahlige ID;


@Spalte(Name="Kundenname")
Privatgelände Zeichenfolgenname;


Privatgelände String-E-Mail;


öffentlich Ganze Zahl getId(){
zurückkehren Ausweis;
 }


öffentlichLeeresetId(Integer-ID){
Das.id = id;
 }


öffentlich Schnur getName(){
zurückkehren Name;
 }


öffentlichLeereName einsetzen(Zeichenkettenname){
Das.name = Name;
 }


öffentlich Schnur E-Mail erhalten(){
zurückkehren Email;
 }
öffentlichLeeresetE-Mail(String-E-Mail){
Das.email = E-Mail;
 }
}

In der obigen Kundenklasse sehen Sie, dass jeder Kunde eine ID, einen Namen und eine E-Mail-Adresse hat. Sie werden auch mehrere Anmerkungen bemerken, die unterschiedlichen Zwecken dienen.

  • @Entity: Deklariert die Kundenklasse als JPA-Entität. Das bedeutet, dass JPA die Felder in der Klasse verwendet, um Spalten in einer relationalen Datenbank zu erstellen.
  • @Table: Bezeichnet den Namen der Tabelle, die der Kundenmodellklasse zugeordnet wird.
  • @Id: Bezeichnet eine Eigenschaft, die die Entität in der Datenbank eindeutig identifiziert.
  • @GeneratedValue und @GenerationType: Diese arbeiten zusammen, um eine automatische Generierungsstrategie für das Feld anzugeben, mit dem sie verknüpft sind. Das ID-Feld generiert also jedes Mal automatisch einen eindeutigen Wert, wenn Sie einen neuen Kunden erstellen.
  • @Column: Bezeichnet eine Eigenschaft, die einer Spalte in der Datenbank zugeordnet ist. Die Namenseigenschaft wird also einer Kundennamensspalte in der Datenbank zugeordnet.

Erstellen des Repositorys

Dieses Repository ermöglicht Ihnen die Interaktion mit den Kundendaten in der Datenbank.

Paket com.onlineshopaholics.api.repository;
importieren org.springframework.data.repository. CrudRepository;
importieren com.onlineshopaholics.api.model. Kunde;


öffentlichSchnittstelleKundenRepositoryerweitertCrudRepository<Kunde, Ganze Zahl>{}

Das Kunden-Repository wird erweitert Springs CrudRepositoy -Schnittstelle und übergibt ihr die Customer-Modellklasse zusammen mit dem Typ des eindeutigen Bezeichners für die Entität, Integer.

Die CrudRepository-Schnittstelle bietet Zugriff auf über 10 Operationen, einschließlich der generischen CRUD-Methoden, die Sie für die REST-API benötigen. Da das CrudRepository bereits die Methoden definiert, die Sie benötigen, müssen sie nicht explizit in der CustomerRepository-Schnittstelle deklariert werden.

Erstellen des Controllers

Mit dem Controller können Sie die Daten in Ihrer Datenbank mithilfe des Modells und des Repositorys aktualisieren.

Paket com.onlineshopaholics.api.controller;
importieren java.util. Optional;


importieren org.springframework.beans.factory.annotation. Automatisch verdrahtet;
importieren org.springframework.web.bind.annotation. DeleteMapping;
importieren org.springframework.web.bind.annotation. GetMapping;
importieren org.springframework.web.bind.annotation. PfadVariable;
importieren org.springframework.web.bind.annotation. PostMapping;
importieren org.springframework.web.bind.annotation. PutMapping;
importieren org.springframework.web.bind.annotation. RequestBody;
importieren org.springframework.web.bind.annotation. RequestMapping;
importieren org.springframework.web.bind.annotation. RequestParam;
importieren org.springframework.web.bind.annotation. Antworttext;
importieren org.springframework.web.bind.annotation. RestController;


importieren com.onlineshopaholics.api.model. Kunde;
importieren com.onlineshopaholics.api.repository. Kundenverzeichnis;


@RestController
@RequestMapping("/Kunden")
öffentlichKlasseKundenController{
@Autowired
Privatgelände Kundenverzeichnis Kundenverzeichnis;


// Neuen Kunden anlegen
@PostMapping("/hinzufügen")
öffentlich Kunde addNewCustomer(@RequestBody Kunde neuerKunde){
 Kundenbenutzer = neu Kunde();
 user.setName (neuerKunde.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (Benutzer);
zurückkehren Benutzer; 
 }


// Alle Kunden anzeigen
@GetMapping("Alle ansehen")
öffentlich@ResponseBodyWiederholbargetAllCustomers(){
zurückkehren customerRepository.findAll();
 }


// bestimmten Kunden anzeigen
@GetMapping("view/{id}")
öffentlich OptionalgetKunde(@PathVariable Integer-ID){
zurückkehren customerRepository.findById (id);
 }


// einen bestehenden Kunden aktualisieren
@PutMapping("/edit/{id}")
öffentlich Schnur aktualisieren( @RequestBody KundenaktualisierungKunde, @PathVariable Integer-ID){
zurückkehren customerRepository.findById (id)
 .map (Kunde -> {
 customer.setName (updateCustomer.getName());
 customer.setEmail (updateCustomer.getEmail());
 customerRepository.save (Kunde);
zurückkehren"Kundendaten wurden erfolgreich aktualisiert!";
 }).orElseGet(() -> {
zurückkehren"Dieser Kunde existiert nicht";
 });
 }


// Kunde löschen
@DeleteMapping("löschen/{id}")
öffentlich Schnur löschen(@PfadVariable("Ausweis")Ganzzahl-ID) {
 customerRepository.deleteById (id); 
zurückkehren"Kunde wurde erfolgreich gelöscht!";
 }
}

Der obige Controller stattet die REST-API mit CRUD-Operationen aus, indem er fünf des CrudRepository verwendet Schnittstellenmethoden (jede einer bestimmten Methode zugeordnet). Der Controller verwendet auch mehrere wichtige Spring-Annotationen, mit denen er seine Funktionen ausführen kann.

  • @RestController: Diese Anmerkung dient zwei Zwecken. Es markiert eine Klasse für die Erkennung durch Komponentenscannen. Es weist Spring auch an, den Rückgabewert für alle Methoden in dieser Klasse in den Antworttext zu schreiben.
  • @RequestMapping: Definiert das Grundanforderungsmuster, das der Controller verarbeiten wird. Dieser Controller verarbeitet also alle Anfragen an „/customers“.
  • @ResponseBody: Ermöglicht einer Methode, eine vollständige Entität zurückzugeben.
  • @RequestBody: Ermöglicht Ihnen, den Anfragetext in ein Objekt umzuwandeln.
  • @RequestParam: Ermöglicht es Ihnen, eine Eigenschaft von einem Objekt zu isolieren.
  • @PathVariable: Ermöglicht es Ihnen, einen Anfragewert einem Platzhalter zuzuordnen. Es ordnet die ID, die der delete-Methode gegeben wurde, einem vorhandenen Wert in der Datenbank zu.
  • @PostMapping: Ermöglicht das Erstellen von Ressourcen.
  • @GetMapping: Ermöglicht das Lesen von Ressourcendaten.
  • @PutMapping: Ermöglicht das Aktualisieren von Ressourcen.
  • @DeleteMapping: Ermöglicht das Löschen von Ressourcen.

Verbinden der Datenbank mit Ihrer Anwendung

Um eine Datenbank mit einer beliebigen Spring-Anwendung zu verbinden, müssen Sie die application.properties Datei im Ressourcenordner. Diese Datei ist zunächst leer, sodass Sie sie mit den entsprechenden Eigenschaften für die Datenbank füllen können, die Sie verwenden möchten. Diese Anwendung verwendet eine MySQL-Datenbank, daher enthält die Datei application.properties die folgenden Daten:

spring.jpa.hibernate.ddl-auto=update
spring.jpa.open-in-view=false
spring.datasource.url=jdbc: mysql://${MYSQL_HOST: localhost}:3306/onlineshopaholics
spring.datasource.username=root
spring.datasource.password=securepw
spring.datasource.driver-class-name=com.mysql.cj.jdbc. Treiber

Die obigen Daten zeigen, dass diese Anwendung eine Verbindung zu einer MySQL-Datenbank namens onlineshopaholics herstellt, mit einem „root“-Benutzernamen und „securepw“ als Passwort. Ihr nächster Schritt besteht darin, die Datenbank und die Kundentabelle in MySQL zu erstellen.

Anfragen erstellen

Es gibt viele Tools, mit denen Sie Ihre REST-API testen können. Postman ist ein beliebtes REST-API-Testtool, und Sie können damit die von Ihnen erstellte einfache API testen. Nachdem Sie die MySQL-Tabelle erstellt und die Spring-Anwendung ausgeführt haben, können Sie Postman starten und mit den vier Anforderungsverben experimentieren.

POST-Anfrage

Mit dieser Anfrage können Sie mithilfe der REST-API neue Kunden erstellen. Um diese Anfrage abzuschließen, müssen Sie zum Kopfzeilenabschnitt Ihrer Beitragsanfrage gehen und eine neue Kopfzeile (Content-Type) erstellen. Sie sollten den Wert dieses Headers auf application/json setzen, da Sie neue Kunden mit JSON erstellen werden.

Im Text der Anfrage müssen Sie den Typ in raw ändern und Ihren JSON einfügen. Dann müssen Sie die Beitrags-URL einfügen:

Beim Senden der Anfrage wird die folgende Antwort zurückgegeben:

Sie können sehen, dass die Anfrage erfolgreich war und der neue Kunde auch eine ID hat.

GET-Anfrage

Da Sie nun einen Kunden haben, können Sie ihn mit der Get-Anforderung anzeigen, die alle Kunden zurückgibt:

Oder jeder Kunde nach ID:

PUT-Anfrage

Sie können Janet mit einem neuen Nachnamen und einer neuen E-Mail-Adresse aktualisieren.

Anfrage LÖSCHEN

Sie können Janet auch aus der Datenbank löschen.

Testen Sie Ihre Spring-REST-API mit JUnit

Mit Spring Boot können Sie jede Anwendung (einschließlich REST-APIs) mit der Testdatei von Spring testen. Softwaretests sind für Spring Boot wichtig. Jede initialisierte Spring-Anwendung verwendet JUnit zum Testen und ermöglicht es Ihnen, Anfragen an Ihre REST-APIs zu senden.