I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione. Per saperne di più.

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 che dovresti fare è familiarizzare con le basi della primavera 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).

instagram viewer

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.

pacchetto com.onlineshopaholics.api.model;
importare jakarta.persistenza. Colonna;
importare jakarta.persistenza. Entità;
importare jakarta.persistenza. Valore generato;
importare jakarta.persistenza. Tipo di generazione;
importare jakarta.persistenza. Id;
importare jakarta.persistenza. Tavolo;


@Tavolo(nome="cliente")
@Entità
pubblicoclasseCliente{
@Id
@GeneratedValue(strategia = GenerationType. AUTO)
privato ID intero;


@Colonna(nome="Nome del cliente")
privato Nome della stringa;


privato E-mail di stringa;


pubblico Numero intero getId(){
ritorno id;
 }


pubblicovuotoimposta l'ID(ID intero){
Questo.id = id;
 }


pubblico Corda getNome(){
ritorno nome;
 }


pubblicovuotoimposta nome(Nome stringa){
Questo.nome = nome;
 }


pubblico Corda getEmail(){
ritorno e-mail;
 }
pubblicovuotosetEmail(Stringa email){
Questo.email = e-mail;
 }
}

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.

pacchetto com.onlineshopaholics.api.repository;
importare org.springframework.data.repository. CrudRepository;
importare com.onlineshopaholics.api.model. Cliente;


pubblicointerfacciaCustomerRepositoryestendeCrudRepository<Cliente, Numero intero>{}

Il repository del cliente si estende CrudRepository di primavera interfaccia, 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 di cui avrai bisogno, 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.

pacchetto com.onlineshopaholics.api.controller;
importare java.util. Opzionale;


importare org.springframework.beans.factory.annotation. Autocablato;
importare org.springframework.web.bind.annotation. Eliminamappatura;
importare org.springframework.web.bind.annotation. GetMapping;
importare org.springframework.web.bind.annotation. Variabile di percorso;
importare org.springframework.web.bind.annotation. PostMapping;
importare org.springframework.web.bind.annotation. PutMapping;
importare org.springframework.web.bind.annotation. RequestBody;
importare org.springframework.web.bind.annotation. RichiestaMappatura;
importare org.springframework.web.bind.annotation. RequestParam;
importare org.springframework.web.bind.annotation. ResponseBody;
importare org.springframework.web.bind.annotation. RestController;


importare com.onlineshopaholics.api.model. Cliente;
importare com.onlineshopaholics.api.repository. Repository clienti;


@RestController
@RequestMapping("/clienti")
pubblicoclasseClienteController{
@Autowired
privato CustomerRepository customerRepository;


// crea un nuovo cliente
@PostMapping("/aggiungere")
pubblico Cliente addNuovoCliente(@RequestBody Cliente nuovoCliente){
 Utente cliente = nuovo Cliente();
 utente.setName (nuovoCliente.getName());
 utente.setEmail (nuovoCliente.getEmail());
 customerRepository.save (utente);
ritorno utente; 
 }


// visualizza tutti i clienti
@GetMapping("mostra tutto")
pubblico@ResponseBodyIterabilegetAllCustomers(){
ritorno customerRepository.findAll();
 }


// visualizza un cliente specifico
@GetMapping("visualizza/{id}")
pubblico OpzionalegetCustomer(@PathVariable Numero intero id){
ritorno customerRepository.findById (id);
 }


// aggiorna un cliente esistente
@PutMapping("/modifica/{id}")
pubblico Corda aggiornamento( @RequestBody Customer updateCustomer, @PathVariable Integer id){
ritorno customerRepository.findById (id)
 .map (cliente -> {
 customer.setName (updateCustomer.getName());
 cliente.setEmail (aggiornamentoCliente.getEmail());
 customerRepository.save (cliente);
ritorno"I dettagli del cliente sono stati aggiornati con successo!";
 }).orElseGet(() -> {
ritorno"Questo cliente non esiste";
 });
 }


// elimina il cliente
@DeleteMapping("cancella/{id}")
pubblico Corda eliminare(@PercorsoVariabile("id")ID intero) {
 customerRepository.deleteById (id); 
ritorno"Il cliente è stato eliminato con successo!";
 }
}

Il controller sopra equipaggia l'API REST con operazioni CRUD, utilizzando cinque CrudRepository metodi di interfaccia (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 file 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=aggiornamento
spring.jpa.open-in-view=false
spring.datasource.url=jdbc: mysql://${MYSQL_HOST: localhost}:3306/onlineshopaholics
spring.datasource.username=radice
spring.datasource.password=securepw
spring.datasource.driver-class-name=com.mysql.cj.jdbc. Autista

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 RESTe puoi usarlo 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.