Hogyan hozzunk létre REST API-t a Spring Boot segítségével

A REST mozaikszó a REpresentational State Transfer, míg az API az Application Programming Interface rövidítése. Ezek együtt egy REST API-ra utalnak. A REST API egy olyan szolgáltatás, amely kéréseket és válaszokat továbbít két szoftverrendszer között, REST architektúrán.

A REST architektúra olyan webszolgáltatásokat hoz létre, amelyek URL-címeken keresztül érhetők el a következő négy kérési ige egyikével: POST, GET, PUT és DELETE. Tehát azt mondhatnánk, hogy a REST API olyan szoftver, amely lehetővé teszi az erőforrások létrehozását, olvasását, frissítését és törlését URL-eken keresztül.

Megtanulhatja, hogyan hozhat létre REST API-t a Spring Boot segítségével.

A Spring Boot alkalmazás inicializálása

Az első dolog, amit meg kell tennie ismerkedjen meg a tavasz alapjaival és állíts be egy Spring Boot alkalmazást. A függőségeken azonban módosítania kell. A webfüggőségen kívül be kell szereznie a Spring Data Java Persistent API (JPA) függőséget és a használni kívánt adatbázis illesztőprogramját (ez az alkalmazás a MySQL-t fogja használni).

Ehhez a REST API-hoz szüksége lesz egy vezérlőre, egy modellre és egy adattárra. Tehát a REST API a következő fájlszerkezettel rendelkezik:

A modell létrehozása

Az első osztály, amelyet létre kell hoznia, az ügyfélmodell, amely az adatlogikát tárolja.

csomag com.onlineshopaholics.api.model;
import jakarta.kitartás. Oszlop;
import jakarta.kitartás. entitás;
import jakarta.kitartás. GeneratedValue;
import jakarta.kitartás. GenerationType;
import jakarta.kitartás. Id;
import jakarta.kitartás. Asztal;
@Asztal(név ="vevő")
@Entity
nyilvánososztályVevő{
@Id
@GeneratedValue(stratégia = GenerationType. AUTO)
magán Egész azonosító;
@Oszlop(név ="Ügyfél neve")
magán Karakterlánc neve;
magán String email;
nyilvános Egész szám getId(){
Visszatérés id;
 }
nyilvánosüresállíts be egy ID-t(Egész azonosító){
ez.id = id;
 }
nyilvános Húr getName(){
Visszatérés név;
 }
nyilvánosüressetName(karakterlánc neve){
ez.name = név;
 }
nyilvános Húr getEmail(){
Visszatérés email;
 }
nyilvánosüressetEmail(E-mail karakterlánc){
ez.email = email;
 }
}

A fenti ügyfélosztályból látni fogja, hogy minden ügyfélnek lesz azonosítója, neve és e-mail címe. Számos olyan megjegyzést is észre fog venni, amelyek különböző célokat szolgálnak.

• @Entity: Az ügyfélosztályt JPA entitásként deklarálja. Ez azt jelenti, hogy a JPA az osztály mezőit használja oszlopok létrehozására egy relációs adatbázisban.
• @Table: Kijelöli annak a táblának a nevét, amely az ügyfélmodell osztályára lesz leképezve.
• @Id: Kijelöl egy tulajdonságot, amely egyedileg azonosítja az entitást az adatbázisban.
• @GeneratedValue és @GenerationType: Ezek együttesen határozzák meg az automatikusan generált stratégiát a hozzárendelt mezőhöz. Tehát az azonosító mező automatikusan egyedi értéket generál minden alkalommal, amikor új ügyfelet hoz létre.
• @Column: Kijelöl egy tulajdonságot, amely az adatbázis egy oszlopához van leképezve. Tehát a név tulajdonság egy ügyfélnév oszlophoz lesz leképezve az adatbázisban.

Az adattár létrehozása

Ez az adattár lehetővé teszi az adatbázisban lévő ügyféladatokkal való interakciót.

csomag com.onlineshopaholics.api.repository;
import org.springframework.data.repository. CrudRepository;
import com.onlineshopaholics.api.model. Vevő;
nyilvánosfelületCustomerRepositorykiterjedCrudRepository<Vevő, Egész szám>{}

Az ügyféltár bővül A tavaszi CrudRepositoy felületet, átadva neki a Customer modell osztályt az entitás egyedi azonosítójának típusával együtt, az Integer.

A CrudRepository felület több mint 10 művelethez biztosít hozzáférést, beleértve az általános CRUD metódusokat, amelyekre a REST API-hoz szüksége lesz. Tehát, mivel a CrudRepository már meghatározza a szükséges metódusokat, nem szükséges azokat kifejezetten deklarálni a CustomerRepository felületen.

A vezérlő létrehozása

A vezérlő lehetővé teszi az adatbázisban lévő adatok frissítését a modell és a repository segítségével.

csomag com.onlineshopaholics.api.controller;
import java.util. Választható;
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. Vevő;
import com.onlineshopaholics.api.repository. CustomerRepository;
@RestController
@RequestMapping("/ügyfelek")
nyilvánososztályCustomerController{
@Autowired
magán CustomerRepository customerRepository;
// új ügyfél létrehozása
@PostMapping("/add")
nyilvános Vevő Új Ügyfél hozzáadása(@RequestBody Customer newCustomer){
 Ügyfél felhasználó = új Vevő();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (felhasználó);
Visszatérés felhasználó; 
 }
// az összes ügyfél megtekintése
@GetMapping("összes megtekintése")
nyilvános@ResponseBodyIterálhatógetAllCustomers(){
Visszatérés customerRepository.findAll();
 }
// konkrét ügyfél megtekintése
@GetMapping("view/{id}")
nyilvános VálaszthatógetCustomer(@PathVariable Integer azonosító){
Visszatérés customerRepository.findById (id);
 }
// meglévő ügyfél frissítése
@PutMapping("/edit/{id}")
nyilvános Húr frissítés( @RequestBody Customer updateCustomer, @PathVariable Integer azonosító){
Visszatérés customerRepository.findById (id)
 .map (ügyfél -> {
 customer.setName (updateCustomer.getName());
 customer.setEmail (updateCustomer.getEmail());
 customerRepository.save (ügyfél);
Visszatérés"Az ügyfél adatait sikeresen frissítettük!";
 }).orElseGet(() -> {
Visszatérés"Ez az ügyfél nem létezik";
 });
 }
// ügyfél törlése
@DeleteMapping("delete/{id}")
nyilvános Húr töröl(@PathVariable("azonosító")Egész azonosító) {
 customerRepository.deleteById (id); 
Visszatérés"Az ügyfél sikeresen törölve!";
 }
}

A fenti vezérlő felszereli a REST API-t CRUD műveletekkel, öt CrudRepository használatával interfész metódusok (mindegyik egy adott metódushoz van hozzárendelve). A vezérlő számos fontos tavaszi megjegyzést is használ, amelyek lehetővé teszik funkcióinak ellátását.

• @RestController: Ez a megjegyzés két célt szolgál. Kijelöl egy osztályt a komponens-ellenőrzéssel történő felfedezéshez. Azt is utasítja a Spring-re, hogy írja be az ebben az osztályban szereplő összes metódus visszatérési értékét a válasz törzsébe.
• @RequestMapping: Meghatározza a vezérlő által kezelt alapkérési mintát. Tehát ez a vezérlő kezeli a „/customer”-hez intézett összes kérést.
• @ResponseBody: Lehetővé teszi egy metódus számára egy teljes entitás visszaadását.
• @RequestBody: Lehetővé teszi a kérés törzsének objektummá alakítását.
• @RequestParam: Lehetővé teszi egy tulajdonság elkülönítését egy objektumtól.
• @PathVariable: Lehetővé teszi egy kérésérték leképezését egy helyőrzőhöz. A delete metódusnak adott azonosítót leképezi az adatbázisban már meglévő értékkel.
• @PostMapping: Lehetővé teszi erőforrások létrehozását.
• @GetMapping: Lehetővé teszi az erőforrásadatok olvasását.
• @PutMapping: Lehetővé teszi az erőforrások frissítését.
• @DeleteMapping: Lehetővé teszi az erőforrások törlését.

Az adatbázis csatlakoztatása az alkalmazáshoz

Ha adatbázist szeretne csatlakoztatni bármely Spring alkalmazáshoz, akkor a alkalmazás.tulajdonságok fájlt az erőforrások mappában. Ez a fájl kezdetben üres, így feltöltheti a használni kívánt adatbázis megfelelő tulajdonságaival. Ez az alkalmazás MySQL adatbázist fog használni, így az application.properties fájl a következő adatokat tartalmazza:

spring.jpa.hibernate.ddl-auto=frissítés
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. Sofőr

A fenti adatok azt mutatják, hogy ez az alkalmazás az onlineshopaholics nevű MySQL adatbázishoz fog csatlakozni, „root” felhasználónévvel és „securepw” jelszóval. A következő lépés az adatbázis és az ügyféltábla létrehozása a MySQL-ben.

Kérelmek létrehozása

Számos eszköz használható a REST API tesztelésére. A Postman egy népszerű REST API tesztelőeszköz, és segítségével tesztelheti az általa felépített egyszerű API-t. A MySQL tábla létrehozása és a Spring alkalmazás futtatása után elindíthatja a Postmant, és kísérletezhet a négy kérés igével.

POST-kérés

Ez a kérelem lehetővé teszi új ügyfelek létrehozását a REST API használatával. A kérés teljesítéséhez lépjen a közzétételi kérelem fejléc részébe, és hozzon létre egy új fejlécet (Content-Type). Ennek a fejlécnek az alkalmazás/json értékét kell beállítania, mivel új ügyfeleket hoz létre a JSON használatával.

A kérelem törzsében módosítania kell a típust raw-ra, és be kell illesztenie a JSON-fájlt. Ezután be kell illesztenie a bejegyzés URL-jét:

A kérelem elküldése a következő választ kapja:

Látható, hogy a kérés sikeres volt, és az új ügyfélnek is van azonosítója.

GET Kérés

Most, hogy van egy ügyfele, megtekintheti azt a get kéréssel, amely minden ügyfelet visszaküld:

Vagy minden ügyfél azonosítója szerint:

PUT kérés

Frissítheti Janet új vezetéknévvel és e-mail-címmel.

TÖRLÉS kérés

Janet törölheti is az adatbázisból.

Tesztelje Spring REST API-ját a JUnit segítségével

A Spring Boot segítségével bármely alkalmazást (beleértve a REST API-kat is) tesztelhet a Spring tesztfájljával. A szoftvertesztelés fontos a Spring Boot számára. Minden inicializált Spring alkalmazás a JUnit-ot használja a teszteléshez, és lehetővé teszi kérések küldését a REST API-knak.