Jak utworzyć interfejs API REST za pomocą Spring Boot

Akronim REST oznacza REpresentational State Transfer, a API oznacza Application Programming Interface. Razem odnoszą się do interfejsu API REST. REST API to usługa, która przesyła żądania i odpowiedzi między dwoma systemami oprogramowania w architekturze REST.

Architektura REST tworzy usługi internetowe, które są dostępne za pośrednictwem adresów URL przy użyciu jednego z czterech czasowników żądania: POST, GET, PUT i DELETE. Można więc powiedzieć, że REST API to oprogramowanie, które umożliwia tworzenie, odczytywanie, aktualizowanie i usuwanie zasobów za pośrednictwem adresów URL.

Możesz dowiedzieć się, jak utworzyć interfejs API REST za pomocą Spring Boot.

Inicjowanie aplikacji Spring Boot

Pierwszą rzeczą, którą powinieneś zrobić, to zapoznaj się z podstawami Springa i skonfiguruj aplikację Spring Boot. Będziesz jednak musiał zmienić zależności. Oprócz zależności sieciowej będziesz potrzebować zależności Spring Data Java Persistent API (JPA) oraz sterownika dla bazy danych, której zamierzasz używać (ta aplikacja będzie używać MySQL).

W przypadku tego interfejsu API REST potrzebny będzie kontroler, model i repozytorium. Tak więc interfejs API REST będzie miał następującą strukturę plików:

Tworzenie modelu

Pierwszą klasą, którą musisz utworzyć, jest model klienta, który przechowuje logikę danych.

pakiet com.onlineshopaholics.api.model;
import jakarta.trwałość. Kolumna;
import jakarta.trwałość. Podmiot;
import jakarta.trwałość. Wygenerowana wartość;
import jakarta.trwałość. typ generacji;
import jakarta.trwałość. ID;
import jakarta.trwałość. Tabela;
@Tabela(nazwa="klient")
@Podmiot
publicznyklasaKlient{
@ID
@Wygenerowana wartość(strategia = typ generacji. AUTOMATYCZNY)
prywatny Identyfikator liczby całkowitej;
@Kolumna(nazwa=„nazwa klienta”)
prywatny Nazwa ciągu;
prywatny Wiadomość e-mail;
publiczny Liczba całkowita getId(){
powrót ID;
 }
publicznypróżniaustaw ID(identyfikator liczby całkowitej){
Ten.id = identyfikator;
 }
publiczny Strunowy pobierzNazwę(){
powrót nazwa;
 }
publicznypróżnianazwa zestawu(Nazwa ciągu){
Ten.nazwa = nazwa;
 }
publiczny Strunowy pobierz e-mail(){
powrót e-mail;
 }
publicznypróżniaustaw e-mail(Ciąg e-mail){
Ten.e-mail = e-mail;
 }
}

Z powyższej klasy klientów zobaczysz, że każdy klient będzie miał identyfikator, imię i adres e-mail. Zauważysz również kilka adnotacji, które służą różnym celom.

• @Entity: Deklaruje klasę klienta jako jednostkę JPA. Oznacza to, że JPA użyje pól w klasie do utworzenia kolumn w relacyjnej bazie danych.
• @Table: Określa nazwę tabeli, która będzie mapowana na klasę modelu klienta.
• @Id: Wyznacza właściwość, która jednoznacznie identyfikuje jednostkę w bazie danych.
• @GeneratedValue i @GenerationType: współpracują ze sobą, aby określić strategię automatycznego generowania dla pola, z którym jest powiązana. Tak więc pole id automatycznie wygeneruje unikalną wartość za każdym razem, gdy utworzysz nowego klienta.
• @Column: Wyznacza właściwość, która jest mapowana na kolumnę w bazie danych. Tak więc właściwość name zostanie odwzorowana na kolumnę nazwy klienta w bazie danych.

Tworzenie repozytorium

To repozytorium pozwoli Ci na interakcję z danymi klientów w bazie danych.

pakiet com.onlineshopaholics.api.repository;
import org.springframework.data.repository. CrudRepository;
import com.onlineshopaholics.api.model. Klient;
publicznyinterfejsRepozytorium klientówrozciąga sięCrudRepository<Klient, Liczba całkowita>{}

Repozytorium klientów rozszerza się CrudRepositoy Springa interfejs, przekazując mu klasę modelu Customer wraz z typem unikalnego identyfikatora encji Integer.

Interfejs CrudRepository zapewnia dostęp do ponad 10 operacji, w tym ogólnych metod CRUD potrzebnych do interfejsu API REST. Tak więc, ponieważ CrudRepository już definiuje metody, których będziesz potrzebować, nie ma potrzeby jawnego deklarowania ich w interfejsie CustomerRepository.

Tworzenie kontrolera

Kontroler umożliwia aktualizację danych w Twojej bazie danych z wykorzystaniem modelu i repozytorium.

pakiet com.onlineshopaholics.api.controller;
import java.util. Opcjonalny;
import org.springframework.beans.factory.adnotation. automatyczne;
import org.springframework.web.bind.adnotacja. UsuńMapowanie;
import org.springframework.web.bind.adnotacja. GetMapping;
import org.springframework.web.bind.adnotacja. Zmienna ścieżki;
import org.springframework.web.bind.adnotacja. PostMapowanie;
import org.springframework.web.bind.adnotacja. Odwzorowanie;
import org.springframework.web.bind.adnotacja. Treść żądania;
import org.springframework.web.bind.adnotacja. Mapowanie żądań;
import org.springframework.web.bind.adnotacja. parametr żądania;
import org.springframework.web.bind.adnotacja. Ciało odpowiedzi;
import org.springframework.web.bind.adnotacja. RestController;
import com.onlineshopaholics.api.model. Klient;
import com.onlineshopaholics.api.repository. repozytorium klientów;
@RestController
@RequestMapping("/klienci")
publicznyklasaKontroler Klienta{
@Automatyczny
prywatny Repozytorium klientów Repozytorium klientów;
// utwórz nowego klienta
@PostMapping("/dodać")
publiczny Klient dodajNowegoKlienta(@RequestBody Klient nowyKlient){
 Użytkownik klienta = nowy Klient();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (użytkownik);
powrót użytkownik; 
 }
// wyświetl wszystkich klientów
@GetMapping("Pokaż wszystkie")
publiczny@ResponseBodyIterowalnezdobądź wszystkich klientów(){
powrót repozytoriumklientów.znajdźwszystko();
 }
// wyświetl konkretnego klienta
@GetMapping("widok/{identyfikator}")
publiczny OpcjonalnypobierzKlienta(@Identyfikator zmiennej całkowitej PathVariable){
powrót customerRepository.findById (identyfikator);
 }
// zaktualizuj istniejącego klienta
@PutMapping("/edytuj/{identyfikator}")
publiczny Strunowy aktualizacja(@RequestBody Aktualizacja klientaCustomer, @PathVariable Identyfikator liczby całkowitej){
powrót customerRepository.findById (identyfikator)
 .mapa (klient -> {
 klient.setName (updateCustomer.getName());
 klient.setEmail (updateCustomer.getEmail());
 customerRepository.save (klient);
powrót"Dane klienta zostały pomyślnie zaktualizowane!";
 }).lubElseGet(() -> {
powrót„Ten klient nie istnieje”;
 });
 }
// usuń klienta
@DeleteMapping("usuń/{identyfikator}")
publiczny Strunowy usuwać(@PathZmienna("ID")Identyfikator liczby całkowitej) {
 customerRepository.deleteById (identyfikator); 
powrót"Klient został pomyślnie usunięty!";
 }
}

Powyższy kontroler wyposaża REST API w operacje CRUD, używając pięciu z CrudRepository metody interfejsu (każda przypisana do określonej metody). Kontroler wykorzystuje również kilka ważnych adnotacji Springa, które pozwalają mu wykonywać swoje funkcje.

• @RestController: Ta adnotacja służy dwóm celom. Oznacza klasę do odkrycia przez skanowanie komponentów. Mówi również Springowi, aby zapisał wartość zwracaną dla wszystkich metod w tej klasie w treści odpowiedzi.
• @RequestMapping: Definiuje bazowy wzorzec żądania, który będzie obsługiwał kontroler. Tak więc ten kontroler będzie obsługiwał wszystkie żądania kierowane do „/customers”.
• @ResponseBody: Umożliwia metodzie zwrócenie całej jednostki.
• @RequestBody: Umożliwia konwersję treści żądania na obiekt.
• @RequestParam: Pozwala wyizolować jedną właściwość z obiektu.
• @PathVariable: Umożliwia mapowanie wartości żądania na symbol zastępczy. Odwzorowuje identyfikator nadany metodzie usuwania z istniejącą wartością w bazie danych.
• @PostMapping: Umożliwia tworzenie zasobów.
• @GetMapping: Umożliwia odczyt danych zasobów.
• @PutMapping: Umożliwia aktualizację zasobów.
• @DeleteMapping: Umożliwia usuwanie zasobów.

Podłączanie bazy danych do Twojej aplikacji

Aby połączyć bazę danych z dowolną aplikacją Springa, musisz użyć aplikacja.właściwości plik w folderze zasobów. Ten plik jest początkowo pusty, więc można go wypełnić odpowiednimi właściwościami bazy danych, której zamierzasz używać. Ta aplikacja będzie korzystać z bazy danych MySQL, więc plik application.properties będzie zawierał następujące dane:

spring.jpa.hibernate.ddl-auto=aktualizacja
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. Kierowca

Powyższe dane pokazują, że ta aplikacja będzie łączyć się z bazą danych MySQL o nazwie onlineshopaholics, z nazwą użytkownika „root” i hasłem „securepw”. Następnym krokiem jest utworzenie bazy danych i tabeli klientów w MySQL.

Tworzenie żądań

Istnieje wiele narzędzi, których można użyć do przetestowania interfejsu API REST. Postman to popularne narzędzie do testowania REST APIi możesz go użyć do przetestowania prostego interfejsu API, który zbudowałeś. Po utworzeniu tabeli MySQL i uruchomieniu aplikacji Spring możesz uruchomić program Postman i poeksperymentować z czterema czasownikami żądań.

Żądanie POST

To żądanie umożliwi Ci tworzenie nowych klientów przy użyciu interfejsu API REST. Aby wykonać to żądanie, musisz przejść do sekcji nagłówków swojego żądania posta i utworzyć nowy nagłówek (Content-Type). Powinieneś ustawić wartość tego nagłówka na application/json, ponieważ będziesz tworzyć nowych klientów za pomocą JSON.

W treści żądania musisz zmienić typ na surowy i wstawić swój JSON. Następnie musisz wstawić adres URL posta:

Wysłanie żądania zwróci następującą odpowiedź:

Możesz zobaczyć, że prośba się powiodła, a nowy klient również ma identyfikator.

POBIERZ Żądanie

Teraz, gdy masz klienta, możesz go wyświetlić za pomocą żądania get, które zwraca wszystkich klientów:

Lub każdy klient według identyfikatora:

Żądanie PUT

Możesz zaktualizować Janet o nowe nazwisko i adres e-mail.

USUŃ Żądanie

Możesz także usunąć Janet z bazy danych.

Przetestuj swój Spring REST API za pomocą JUnit

Dzięki Spring Boot możesz przetestować dowolną aplikację (w tym interfejsy API REST) ​​przy użyciu pliku testowego Springa. Testowanie oprogramowania jest ważne dla Spring Boot. Każda zainicjowana aplikacja Spring używa JUnit do testowania i umożliwia wysyłanie żądań do interfejsów API REST.