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 zapoznać się z podstawami Springa i skonfigurować aplikację Spring Boot. Będziesz jednak musiał zmienić zależności. Oprócz zależności sieciowej musisz uzyskać zależność Spring Data Java Persistent API (JPA) oraz sterownik 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ą należy utworzyć, jest model klienta, który przechowuje logikę danych.
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;
}
}
Z powyższej klasy klientów zobaczysz, że każdy klient będzie miał identyfikator, imię i nazwisko oraz 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 podmiot 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.
package com.onlineshopaholics.api.repository;
import org.springframework.data.repository.CrudRepository;
import com.onlineshopaholics.api.model.Customer;
public interface CustomerRepository extends CrudRepository<Customer, Integer>{}
Repozytorium klienta rozszerza interfejs CrudRepositoy<T,ID> Springa , 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.
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!";
}
}
Powyższy kontroler wyposaża REST API w operacje CRUD, używając pięciu metod interfejsu CrudRepository<T,ID> (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ć pliku application.properties znajdującego się 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=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
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. Listonosz to popularne narzędzie do testowania interfejsu API REST, którego można używać do testowania 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.
Dodaj komentarz