Cum se creează un API REST cu Spring Boot

Acronimul REST înseamnă REpresentational State Transfer, în timp ce API înseamnă Application Programming Interface. Împreună, se referă la un API REST. O API REST este un serviciu care transferă cereri și răspunsuri între două sisteme software, pe o arhitectură REST.

Arhitectura REST construiește servicii web care sunt accesibile prin URL-uri folosind unul dintre cele patru verbe de solicitare: POST, GET, PUT și DELETE. Deci, ați putea spune că un API REST este un software care vă permite să creați, să citiți, să actualizați și să ștergeți resurse prin adrese URL.

Puteți afla cum să creați un API REST folosind Spring Boot.

Inițializarea aplicației Spring Boot

Primul lucru pe care ar trebui să-l faci este familiarizați-vă cu elementele de bază ale primăverii și configurați o aplicație Spring Boot. Totuși, va trebui să modificați dependențele. Pe lângă dependența de web, va trebui să obțineți dependența Spring Data Java Persistent API (JPA) și driverul pentru baza de date pe care intenționați să o utilizați (această aplicație va folosi MySQL).

Pentru acest API REST, veți avea nevoie de un controler, un model și un depozit. Deci, API-ul REST va avea următoarea structură de fișiere:

Crearea modelului

Prima clasă pe care va trebui să o creați este modelul clientului, care stochează logica datelor.

pachet com.onlineshopaholics.api.model;
import jakarta.persistență. Coloană;
import jakarta.persistență. Entitate;
import jakarta.persistență. GeneratedValue;
import jakarta.persistență. GenerationType;
import jakarta.persistență. Id;
import jakarta.persistență. Masa;
@Masa(nume="client")
@Entitate
publicclasăClient{
@Id
@GeneratedValue(strategie = GenerationType. AUTO)
privat ID întreg;
@Coloană(nume="Numele clientului")
privat Nume șir;
privat șir de e-mail;
public Întreg getId(){
întoarcere id;
 }
publicgolsetId(ID întreg){
acest.id = id;
 }
public Şir getName(){
întoarcere Nume;
 }
publicgolPune un nume(nume șir){
acest.nume = nume;
 }
public Şir getEmail(){
întoarcere e-mail;
 }
publicgolsetEmail(Șir de e-mail){
acest.email = email;
 }
}

Din clasa de clienți de mai sus, veți vedea că fiecare client va avea un ID, un nume și un e-mail. Veți observa, de asemenea, câteva adnotări care servesc unor scopuri diferite.

• @Entity: Declara clasa de client ca entitate JPA. Aceasta înseamnă că JPA va folosi câmpurile din clasă pentru a crea coloane într-o bază de date relațională.
• @Table: desemnează numele tabelului care se va mapa la clasa modelului clientului.
• @Id: desemnează o proprietate care va identifica în mod unic entitatea din baza de date.
• @GeneratedValue și @GenerationType: Acestea lucrează împreună pentru a specifica o strategie de generare automată pentru câmpul cu care se asociază. Deci, câmpul id va genera automat o valoare unică de fiecare dată când creați un client nou.
• @Column: desemnează o proprietate care se mapează la o coloană din baza de date. Deci, proprietatea nume se va mapa la o coloană customername din baza de date.

Crearea depozitului

Acest depozit vă va permite să interacționați cu datele clienților din baza de date.

pachet com.onlineshopaholics.api.repository;
import org.springframework.data.repository. CrudRepository;
import com.onlineshopaholics.api.model. Client;
publicinterfataCustomerRepositoryse extindeCrudRepository<Client, Întreg>{}

Repositoryul clienților se extinde CrudRepositoy de primăvară interfață, trecându-i clasa de model Client împreună cu tipul de identificator unic pentru entitate, Integer.

Interfața CrudRepository oferă acces la peste 10 operațiuni, inclusiv metodele generice CRUD de care veți avea nevoie pentru API-ul REST. Deci, deoarece CrudRepository definește deja metodele de care veți avea nevoie, nu este nevoie să le declarați în mod explicit în interfața CustomerRepository.

Crearea Controllerului

Controlerul vă permite să actualizați datele din baza de date folosind modelul și depozitul.

pachet com.onlineshopaholics.api.controller;
import java.util. Opțional;
import org.springframework.fasole.fabrica.adnotare. Cablat automat;
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. Client;
import com.onlineshopaholics.api.repository. CustomerRepository;
@RestController
@RequestMapping("/Clienți")
publicclasăCustomerController{
@Cablat automat
privat CustomerRepository customerRepository;
// creează un client nou
@PostMapping("/adăuga")
public Client addNewCustomer(@RequestBody Customer newCustomer){
 Utilizator client = nou Client();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (utilizator);
întoarcere utilizator; 
 }
// vezi toți clienții
@GetMapping("a vedea tot")
public@ResponseBodyIterabilgetAllCustomers(){
întoarcere customerRepository.findAll();
 }
// vezi un anumit client
@GetMapping(„vizualizare/{id}”)
public OpționalgetCustomer(@PathVariable Integer id){
întoarcere customerRepository.findById (id);
 }
// actualizați un client existent
@PutMapping(„/edit/{id}”)
public Şir Actualizați( @RequestBody Customer updateCustomer, @PathVariable Integer id){
întoarcere customerRepository.findById (id)
 .map (client -> {
 customer.setName (updateCustomer.getName());
 customer.setEmail (updateCustomer.getEmail());
 customerRepository.save (client);
întoarcere„Detaliile clientului au fost actualizate cu succes!”;
 }).orElseGet(() -> {
întoarcere„Acest client nu există”;
 });
 }
// șterge clientul
@DeleteMapping(„șterge/{id}”)
public Şir șterge(@PathVariable("id")ID întreg) {
 customerRepository.deleteById (id); 
întoarcere„Clientul a fost șters cu succes!”;
 }
}

Controlerul de mai sus echipează API-ul REST cu operațiuni CRUD, folosind cinci din CrudRepository metode de interfață (fiecare atribuită unei metode specifice). Controlerul folosește, de asemenea, câteva adnotări Spring importante care îi permit să-și îndeplinească funcțiile.

• @RestController: Această adnotare are două scopuri. Acesta marchează o clasă pentru descoperire prin scanarea componentelor. De asemenea, îi spune lui Spring să scrie valoarea returnată pentru toate metodele, din această clasă, în corpul răspunsului.
• @RequestMapping: definește modelul de cerere de bază pe care îl va gestiona controlerul. Deci, acest controler va gestiona toate cererile către „/clienți”.
• @ResponseBody: Permite unei metode să returneze o întreagă entitate.
• @RequestBody: Vă permite să convertiți corpul solicitării într-un obiect.
• @RequestParam: Vă permite să izolați o proprietate dintr-un obiect.
• @PathVariable: Vă permite să mapați o valoare de solicitare la un substituent. Mapează ID-ul dat metodei de ștergere cu o valoare existentă în baza de date.
• @PostMapping: Vă permite să creați resurse.
• @GetMapping: Vă permite să citiți datele despre resurse.
• @PutMapping: Vă permite să actualizați resursele.
• @DeleteMapping: Vă permite să ștergeți resurse.

Conectarea bazei de date la aplicația dvs

Pentru a conecta o bază de date la orice aplicație Spring, va trebui să utilizați aplicație.proprietăți fișier în folderul resurse. Acest fișier este inițial gol, așa că îl puteți completa cu proprietățile adecvate pentru baza de date pe care intenționați să o utilizați. Această aplicație va folosi o bază de date MySQL, astfel încât fișierul application.properties va conține următoarele date:

spring.jpa.hibernate.ddl-auto=actualizare
spring.jpa.open-in-view=fals
spring.datasource.url=jdbc: mysql://${MYSQL_HOST: localhost}:3306/onlineshopaholics
spring.datasource.username=rădăcină
spring.datasource.password=securepw
spring.datasource.driver-class-name=com.mysql.cj.jdbc. Conducător auto

Datele de mai sus arată că această aplicație se va conecta la o bază de date MySQL numită onlineshopaholics, cu un nume de utilizator „root” și „securepw” ca parolă. Următorul pas este să creați baza de date și tabelul clienți în MySQL.

Crearea cererilor

Există multe instrumente pe care le puteți folosi pentru a vă testa API-ul REST. Postman este un instrument popular de testare REST API, și îl puteți folosi pentru a testa API-ul simplu pe care l-ați creat. După ce ați creat tabelul MySQL și rulați aplicația Spring, puteți lansa Postman și experimentați cu cele patru verbe de solicitare.

Solicitare POST

Această solicitare vă va permite să creați clienți noi folosind API-ul REST. Pentru a finaliza această solicitare, va trebui să accesați secțiunea antete a solicitării de postare și să creați un nou antet (Tip de conținut). Ar trebui să setați valoarea acestui antet la application/json, deoarece veți crea clienți noi folosind JSON.

În corpul solicitării, va trebui să schimbați tipul în brut și să introduceți JSON. Apoi va trebui să inserați adresa URL a postării:

Trimiterea cererii va returna următorul răspuns:

Puteți vedea că solicitarea a avut succes, iar noul client are și un id.

Cerere GET

Acum că aveți un client, îl puteți vizualiza cu cererea de obținere care returnează toți clienții:

Sau fiecare client după id:

Solicitare PUT

Puteți actualiza Janet cu un nou nume de familie și e-mail.

Solicitare DELETE

De asemenea, puteți șterge Janet din baza de date.

Testați-vă API-ul Spring REST folosind JUnit

Cu Spring Boot, puteți testa orice aplicație (inclusiv API-urile REST) ​​folosind fișierul de testare Spring. Testarea software-ului este importantă pentru Spring Boot. Fiecare aplicație Spring inițializată utilizează JUnit pentru testare și vă permite să trimiteți cereri către API-urile dvs. REST.