Hur man skapar ett REST API med Spring Boot

Akronymen REST står för REpresentational State Transfer, medan API står för Application Programming Interface. Tillsammans hänvisar de till ett REST API. Ett REST API är en tjänst som överför förfrågningar och svar mellan två mjukvarusystem, på en REST-arkitektur.

REST-arkitekturen bygger webbtjänster som är tillgängliga via URL: er med hjälp av ett av fyra begärande verb: POST, GET, PUT och DELETE. Så man kan säga att ett REST API är programvara som låter dig skapa, läsa, uppdatera och ta bort resurser via URL: er.

Du kan lära dig hur du skapar ett REST API med Spring Boot.

Initierar Spring Boot-applikationen

Det första du bör göra är bekanta dig med vårens grunder och konfigurera en Spring Boot-applikation. Du måste dock ändra beroenden. Utöver webbberoendet måste du få Spring Data Java Persistent API (JPA) beroende och drivrutinen för databasen du tänker använda (denna applikation kommer att använda MySQL).

För detta REST API behöver du en kontroller, en modell och ett arkiv. Så REST API kommer att ha följande filstruktur:

Skapar modellen

Den första klassen du behöver skapa är kundmodellen, som lagrar datalogiken.

paket com.onlineshopaholics.api.model;
importera jakarta.persistence. Kolumn;
importera jakarta.persistence. Entitet;
importera jakarta.persistence. GeneratedValue;
importera jakarta.persistence. GenerationType;
importera jakarta.persistence. Id;
importera jakarta.persistence. Tabell;
@Tabell(namn="kund")
@Entitet
offentligklassKund{
@Id
@GeneratedValue(strategi = GenerationType. BIL)
privat Heltals-id;
@Kolumn(namn="Köparens namn")
privat Strängnamn;
privat Sträng e-post;
offentlig Heltal getId(){
lämna tillbaka id;
 }
offentligtomhetuppsättning id(heltals-id){
detta.id = id;
 }
offentlig Sträng hämta namn(){
lämna tillbaka namn;
 }
offentligtomhetAnge namn(Strängnamn){
detta.namn = namn;
 }
offentlig Sträng getEmail(){
lämna tillbaka e-post;
 }
offentligtomhetsetEmail(E-poststräng){
detta.email = e-post;
 }
}

Från kundklassen ovan ser du att varje kund kommer att ha ett ID, ett namn och en e-postadress. Du kommer också att märka flera kommentarer som tjänar olika syften.

• @Entity: Deklarerar kundklassen som en JPA-enhet. Detta innebär att JPA kommer att använda fälten i klassen för att skapa kolumner i en relationsdatabas.
• @Tabell: Anger namnet på tabellen som ska mappas till kundmodellklassen.
• @Id: Anger en egenskap som unikt identifierar enheten i databasen.
• @GeneratedValue och @GenerationType: Dessa samverkar för att specificera en automatisk genereringsstrategi för fältet som det associeras med. Så, id-fältet genererar automatiskt ett unikt värde varje gång du skapar en ny kund.
• @Column: Anger en egenskap som mappas till en kolumn i databasen. Så namnegenskapen kommer att mappas till en kundnamnskolumn i databasen.

Skapar arkivet

Detta arkiv låter dig interagera med kunddata i databasen.

paket com.onlineshopaholics.api.repository;
importera org.springframework.data.repository. CrudRepository;
importera com.onlineshopaholics.api.model. Kund;
offentliggränssnittCustomerRepositorysträcker sigCrudRepository<Kund, Heltal>{}

Kundförrådet utökas Vårens CrudRepositoy gränssnitt och skickar det till kundmodellklassen tillsammans med typen av unik identifierare för enheten, heltal.

Gränssnittet CrudRepository ger tillgång till över 10 operationer, inklusive de generiska CRUD-metoderna du behöver för REST API. Så eftersom CrudRepository redan definierar metoderna du behöver, finns det inget behov av att uttryckligen deklarera dem i CustomerRepository-gränssnittet.

Skapar styrenheten

Styrenheten låter dig uppdatera data i din databas med hjälp av modellen och arkivet.

paket com.onlineshopaholics.api.controller;
importera java.util. Frivillig;
importera org.springframework.beans.factory.annotation. Autowired;
importera org.springframework.web.bind.annotation. DeleteMapping;
importera org.springframework.web.bind.annotation. GetMapping;
importera org.springframework.web.bind.annotation. PathVariable;
importera org.springframework.web.bind.annotation. PostMapping;
importera org.springframework.web.bind.annotation. PutMapping;
importera org.springframework.web.bind.annotation. RequestBody;
importera org.springframework.web.bind.annotation. RequestMapping;
importera org.springframework.web.bind.annotation. RequestParam;
importera org.springframework.web.bind.annotation. ResponseBody;
importera org.springframework.web.bind.annotation. RestController;
importera com.onlineshopaholics.api.model. Kund;
importera com.onlineshopaholics.api.repository. CustomerRepository;
@RestController
@RequestMapping("/kunder")
offentligklassCustomerController{
@Autowired
privat CustomerRepository customerRepository;
// skapa ny kund
@PostMapping("/Lägg till")
offentlig Kund lägg till Ny kund(@RequestBody kund ny kund){
 Kundanvändare = ny Kund();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (användare);
lämna tillbaka användare; 
 }
// se alla kunder
@GetMapping("visa alla")
offentlig@ResponseBodyIterablegetAllCustomers(){
lämna tillbaka customerRepository.findAll();
 }
// se specifik kund
@GetMapping("view/{id}")
offentlig FrivilliggetCustomer(@PathVariable Integer-id){
lämna tillbaka customerRepository.findById (id);
 }
// uppdatera en befintlig kund
@PutMapping("/edit/{id}")
offentlig Sträng uppdatering( @RequestBody Customer updateCustomer, @PathVariable Integer id){
lämna tillbaka customerRepository.findById (id)
 .map (kund -> {
 kund.uppsättningsnamn (uppdateraKund.getNamn());
 customer.setEmail (updateCustomer.getEmail());
 customerRepository.save (kund);
lämna tillbaka"Kundinformation har uppdaterats!";
 }).orElseGet(() -> {
lämna tillbaka"Den här kunden finns inte";
 });
 }
// radera kund
@DeleteMapping("delete/{id}")
offentlig Sträng radera(@PathVariable("id")heltals-id) {
 customerRepository.deleteById (id); 
lämna tillbaka"Kunden har raderats!";
 }
}

Styrenheten ovan utrustar REST API med CRUD-operationer genom att använda fem av CrudRepository gränssnittsmetoder (var och en tilldelad en specifik metod). Styrenheten använder också flera viktiga fjäderannoteringar som gör att den kan utföra sina funktioner.

• @RestController: Den här anteckningen har två syften. Det markerar en klass för upptäckt genom komponentskanning. Den säger också till Spring att skriva returvärdet för alla metoder, i den här klassen, i svarskroppen.
• @RequestMapping: Definierar det baslinjeförfrågningsmönster som styrenheten kommer att hantera. Så den här styrenheten kommer att hantera alla förfrågningar till "/kunder".
• @ResponseBody: Tillåter en metod att returnera en hel enhet.
• @RequestBody: Låter dig konvertera förfrågningstexten till ett objekt.
• @RequestParam: Låter dig isolera en egenskap från ett objekt.
• @PathVariable: Låter dig mappa ett förfrågningsvärde till en platshållare. Den mappar det ID som ges till deletemetoden med ett befintligt värde i databasen.
• @PostMapping: Låter dig skapa resurser.
• @GetMapping: Låter dig läsa resursdata.
• @PutMapping: Låter dig uppdatera resurser.
• @DeleteMapping: Låter dig ta bort resurser.

Ansluta databasen till din applikation

För att ansluta en databas till valfri Spring-applikation måste du använda applikationsegenskaper filen under resursmappen. Den här filen är från början tom, så du kan fylla i den med lämpliga egenskaper för databasen som du tänker använda. Denna applikation kommer att använda en MySQL-databas så filen application.properties kommer att innehålla följande data:

spring.jpa.hibernate.ddl-auto=uppdatering
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. Förare

Data ovan visar att denna applikation kommer att ansluta till en MySQL-databas som kallas onlineshopaholics, med ett "root"-användarnamn och "securepw" som lösenord. Ditt nästa steg är att skapa databasen och kundtabellen i MySQL.

Skapa förfrågningar

Det finns många verktyg som du kan använda för att testa ditt REST API. Postman är ett populärt testverktyg för REST API, och du kan använda den för att testa det enkla API du har byggt. Efter att ha skapat MySQL-tabellen och kört Spring-applikationen kan du starta Postman och experimentera med de fyra begärandeverben.

POST-förfrågan

Denna begäran låter dig skapa nya kunder med hjälp av REST API. För att slutföra denna begäran måste du gå till rubrikavsnittet i din inläggsbegäran och skapa en ny rubrik (Content-Type). Du bör ställa in den här rubrikens värde till application/json, eftersom du kommer att skapa nya kunder med JSON.

I brödtexten i begäran måste du ändra typen till rå och infoga din JSON. Sedan måste du infoga inläggets URL:

Om du skickar begäran returneras följande svar:

Du kan se att begäran lyckades, och den nya kunden har också ett id.

GET-förfrågan

Nu när du har en kund kan du se den med get-begäran som returnerar alla kunder:

Eller varje kund efter id:

PUT-förfrågan

Du kan uppdatera Janet med ett nytt efternamn och e-postadress.

DELETE Begäran

Du kan också ta bort Janet från databasen.

Testa ditt Spring REST API med JUnit

Med Spring Boot kan du testa vilken applikation som helst (inklusive REST API: er) med Springs testfil. Programvarutestning är viktigt för Spring Boot. Varje initierad Spring-applikation använder JUnit för testning och låter dig skicka förfrågningar till dina REST-API: er.