Come creare un’API REST con Spring Boot
L’acronimo REST sta per REpresentational State Transfer, mentre API sta per Application Programming Interface. Insieme, fanno riferimento a un’API REST. Un’API REST è un servizio che trasferisce richieste e risposte tra due sistemi software, su un’architettura REST.
L’architettura REST crea servizi Web accessibili tramite URL utilizzando uno dei quattro verbi di richiesta: POST, GET, PUT e DELETE. Quindi, potresti dire che un’API REST è un software che ti consente di creare, leggere, aggiornare ed eliminare risorse tramite URL.
Puoi imparare come creare un’API REST usando Spring Boot.
Inizializzazione dell’applicazione Spring Boot
La prima cosa da fare è familiarizzare con le basi di Spring e configurare un’applicazione Spring Boot. Tuttavia, dovrai modificare le dipendenze. Oltre alla dipendenza Web, dovrai ottenere la dipendenza JPA (Java Persistent API) di Spring Data e il driver per il database che intendi utilizzare (questa applicazione utilizzerà MySQL).
Per questa API REST, avrai bisogno di un controller, un modello e un repository. Quindi, l’API REST avrà la seguente struttura di file:
Creazione del modello
La prima classe che dovrai creare è il modello del cliente, che memorizza la logica dei dati.
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;
}
}
Dalla classe cliente sopra, vedrai che ogni cliente avrà un ID, un nome e un indirizzo email. Noterai anche diverse annotazioni che servono a scopi diversi.
- @Entity: dichiara la classe cliente come entità JPA. Ciò significa che JPA utilizzerà i campi nella classe per creare colonne in un database relazionale.
- @Table: designa il nome della tabella che verrà mappata alla classe del modello del cliente.
- @Id: designa una proprietà che identificherà in modo univoco l’entità nel database.
- @GeneratedValue e @GenerationType: funzionano insieme per specificare una strategia di generazione automatica per il campo a cui è associato. Quindi, il campo id genererà automaticamente un valore univoco ogni volta che crei un nuovo cliente.
- @Column: designa una proprietà che esegue il mapping a una colonna nel database. Pertanto, la proprietà name verrà mappata a una colonna customername nel database.
Creazione del deposito
Questo repository ti consentirà di interagire con i dati dei clienti nel database.
package com.onlineshopaholics.api.repository;
import org.springframework.data.repository.CrudRepository;
import com.onlineshopaholics.api.model.Customer;
public interface CustomerRepository extends CrudRepository<Customer, Integer>{}
Il repository del cliente estende l’interfaccia CrudRepositoy<T,ID> di Spring , passandogli la classe del modello Customer insieme al tipo di identificatore univoco per l’entità, Integer.
L’interfaccia CrudRepository fornisce l’accesso a oltre 10 operazioni, inclusi i metodi CRUD generici necessari per l’API REST. Quindi, poiché CrudRepository definisce già i metodi necessari, non è necessario dichiararli esplicitamente nell’interfaccia CustomerRepository.
Creazione del controllore
Il controller consente di aggiornare i dati nel database utilizzando il modello e il repository.
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!";
}
}
Il controller sopra equipaggia l’API REST con operazioni CRUD, utilizzando cinque dei metodi di interfaccia CrudRepository<T,ID> (ciascuno assegnato a un metodo specifico). Il controller utilizza anche diverse importanti annotazioni Spring che gli consentono di svolgere le sue funzioni.
- @RestController: questa annotazione ha due scopi. Contrassegna una classe per il rilevamento mediante scansione dei componenti. Indica inoltre a Spring di scrivere il valore restituito per tutti i metodi, in questa classe, nel corpo della risposta.
- @RequestMapping: definisce il modello di richiesta di base che il controller gestirà. Quindi, questo controller gestirà tutte le richieste a “/clienti”.
- @ResponseBody: consente a un metodo di restituire un’intera entità.
- @RequestBody: consente di convertire il corpo della richiesta in un oggetto.
- @RequestParam: consente di isolare una proprietà da un oggetto.
- @PathVariable: consente di mappare un valore di richiesta a un segnaposto. Mappa l’ID assegnato al metodo delete con un valore esistente nel database.
- @PostMapping: consente di creare risorse.
- @GetMapping: consente di leggere i dati delle risorse.
- @PutMapping: consente di aggiornare le risorse.
- @DeleteMapping: consente di eliminare le risorse.
Connessione del database all’applicazione
Per connettere un database a qualsiasi applicazione Spring, dovrai utilizzare il file application.properties nella cartella delle risorse. Questo file è inizialmente vuoto, quindi è possibile popolarlo con le proprietà appropriate per il database che si intende utilizzare. Questa applicazione utilizzerà un database MySQL, quindi il file application.properties conterrà i seguenti dati:
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
I dati sopra mostrano che questa applicazione si collegherà a un database MySQL chiamato onlineshopaholics, con un nome utente “root” e “securepw” come password. Il tuo prossimo passo è creare il database e la tabella dei clienti in MySQL.
Creazione di richieste
Esistono molti strumenti che puoi utilizzare per testare la tua API REST. Postman è un popolare strumento di test dell’API REST e puoi utilizzarlo per testare la semplice API che hai creato. Dopo aver creato la tabella MySQL ed eseguito l’applicazione Spring, puoi avviare Postman e sperimentare i quattro verbi di richiesta.
POST Richiesta
Questa richiesta ti consentirà di creare nuovi clienti utilizzando l’API REST. Per completare questa richiesta, dovrai andare alla sezione delle intestazioni della tua richiesta di post e creare una nuova intestazione (Content-Type). Dovresti impostare il valore di questa intestazione su application/json, poiché creerai nuovi clienti utilizzando JSON.
Nel corpo della richiesta, dovrai modificare il tipo in raw e inserire il tuo JSON. Quindi dovrai inserire l’URL del post:
L’invio della richiesta restituirà la seguente risposta:
Puoi vedere che la richiesta è andata a buon fine e anche il nuovo cliente ha un ID.
OTTIENI Richiesta
Ora che hai un cliente, puoi visualizzarlo con la richiesta get che restituisce tutti i clienti:
O ogni cliente per id:
Richiesta PUT
Puoi aggiornare Janet con un nuovo cognome ed e-mail.
ELIMINA Richiesta
Puoi anche eliminare Janet dal database.
Metti alla prova la tua API REST di primavera utilizzando JUnit
Con Spring Boot, puoi testare qualsiasi applicazione (incluse le API REST) utilizzando il file di test di Spring. Il test del software è importante per Spring Boot. Ogni applicazione Spring inizializzata utilizza JUnit per i test e consente di inviare richieste alle API REST.
Lascia un commento