So erstellen Sie eine REST-API mit Spring Boot

2023/01/16

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

Als Erstes sollten Sie sich mit den Grundlagen von Spring vertraut machen und eine Spring Boot-Anwendung einrichten. 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.

package com.onlineshopaholics.api.model;

import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; import jakarta.persistence.Table;


@Table(name="customer")
@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name="customername")
    private String name;
    private String email;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }

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

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.

package com.onlineshopaholics.api.repository;

import org.springframework.data.repository.CrudRepository; import com.onlineshopaholics.api.model.Customer;


public interface CustomerRepository extends CrudRepository<Customer, Integer>{}

Das Kunden-Repository erweitert die CrudRepositoy<T,ID> -Schnittstelle von Spring und übergibt ihr die Kundenmodellklasse zusammen mit dem Typ der eindeutigen Kennung 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 die benötigten Methoden bereits definiert, 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.

package com.onlineshopaholics.api.controller;

import java.util.Optional;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.onlineshopaholics.api.model.Customer;
import com.onlineshopaholics.api.repository.CustomerRepository;
@RestController
@RequestMapping("/customers")
public class CustomerController {
    @Autowired
    private CustomerRepository customerRepository;
    // create new customer
    @PostMapping("/add")
    public Customer addNewCustomer(@RequestBody Customer newCustomer){
        Customer user = new Customer();
        user.setName(newCustomer.getName());
        user.setEmail(newCustomer.getEmail());
        customerRepository.save(user);
        return user; 
    }
    // view all customers
    @GetMapping("view/all")
    public @ResponseBody Iterable<Customer> getAllCustomers(){
        return customerRepository.findAll();
    }
    // view specific customer
    @GetMapping("view/{id}")
    public Optional<Customer> getCustomer(@PathVariable Integer id) {
        return customerRepository.findById(id);
    }
    // update an existing customer
    @PutMapping("/edit/{id}")
    public String update(@RequestBody Customer updateCustomer, @PathVariable Integer id) {
        return customerRepository.findById(id)
                 .map(customer -> {
                       customer.setName(updateCustomer.getName());
                       customer.setEmail(updateCustomer.getEmail());
                       customerRepository.save(customer);
                       return "Customer details have been successfully updated!";
                 }).orElseGet(() -> {
                       return "This customer doesn't exist";
                 });
    }
    // delete customer
    @DeleteMapping("delete/{id}")
    public String delete(@PathVariable("id")Integer id) {
        customerRepository.deleteById(id); 
        return "Customer has been successfully deleted!";
    }
}

Der obige Controller stattet die REST-API mit CRUD-Vorgängen aus, indem er fünf der CrudRepository<T,ID>-Schnittstellenmethoden verwendet (jede einer bestimmten Methode zugewiesen). 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 Datei „ application.properties “ im Ordner „resources“ verwenden. 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.Driver

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, mit dem Sie die von Ihnen erstellte einfache API testen können. 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.

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) mithilfe 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.