Tādi lasītāji kā jūs palīdz atbalstīt MUO. Veicot pirkumu, izmantojot saites mūsu vietnē, mēs varam nopelnīt filiāles komisiju. Lasīt vairāk.

Akronīms REST apzīmē REpresentational State Transfer, savukārt API apzīmē lietojumprogrammu interfeisu. Kopā tie attiecas uz REST API. REST API ir pakalpojums, kas pārsūta pieprasījumus un atbildes starp divām programmatūras sistēmām, izmantojot REST arhitektūru.

REST arhitektūra veido tīmekļa pakalpojumus, kuriem var piekļūt, izmantojot vietrāžus URL, izmantojot vienu no četriem pieprasījuma darbības vārdiem: POST, GET, PUT un DELETE. Tātad, varētu teikt, REST API ir programmatūra, kas ļauj izveidot, lasīt, atjaunināt un dzēst resursus, izmantojot vietrāžus URL.

Varat uzzināt, kā izveidot REST API, izmantojot Spring Boot.

Pavasara sāknēšanas lietojumprogrammas inicializācija

Pirmā lieta, kas jums jādara, ir iepazīsties ar pavasara pamatiem un iestatiet lietojumprogrammu Spring Boot. Tomēr jums būs jāmaina atkarības. Papildus atkarībai no tīmekļa, jums būs jāiegūst Spring Data Java Persistent API (JPA) atkarība un datu bāzes draiveris, kuru plānojat izmantot (šī lietojumprogramma izmantos MySQL).

instagram viewer

Lai izmantotu šo REST API, jums būs nepieciešams kontrolleris, modelis un repozitorijs. Tātad REST API būs šāda failu struktūra:

Modeļa izveide

Pirmā klase, kas jums būs jāizveido, ir klienta modelis, kurā tiek saglabāta datu loģika.

iepakojums com.onlineshopaholics.api.model;
imports jakarta.noturība. Kolonna;
imports jakarta.noturība. vienība;
imports jakarta.noturība. GeneratedValue;
imports jakarta.noturība. GenerationType;
imports jakarta.noturība. Id;
imports jakarta.noturība. Tabula;


@Tabula(vārds ="klients")
@Entity
publiskiklasēKlients{
@Id
@GeneratedValue(stratēģija = GenerationType. AUTOMĀTISKI)
Privāts Vesels skaitlis id;


@Kolonna(vārds ="Klienta vārds")
Privāts Virknes nosaukums;


Privāts Virknes e-pasts;


publiski Vesels skaitlis getId(){
atgriezties id;
 }


publiskinederīgssetId(Vesels skaitlis){
šis.id = id;
 }


publiski Stīga getName(){
atgriezties vārds;
 }


publiskinederīgssetName(virknes nosaukums){
šis.name = vārds;
 }


publiski Stīga getEmail(){
atgriezties e-pasts;
 }
publiskinederīgssetEmail(virknes e-pasts){
šis.email = e-pasts;
 }
}

Iepriekš redzamajā klientu klasē redzēsit, ka katram klientam būs ID, vārds un e-pasta adrese. Jūs pamanīsit arī vairākas anotācijas, kas kalpo dažādiem mērķiem.

  • @Entity: deklarē klientu klasi kā JPA entītiju. Tas nozīmē, ka JPA izmantos klases laukus, lai izveidotu kolonnas relāciju datu bāzē.
  • @Table: apzīmē tās tabulas nosaukumu, kas tiks kartēta uz klienta modeļa klasi.
  • @Id: apzīmē rekvizītu, kas unikāli identificēs entītiju datu bāzē.
  • @GeneratedValue un @GenerationType: tie darbojas kopā, lai norādītu automātiskās ģenerēšanas stratēģiju laukam, ar kuru tas ir saistīts. Tādējādi ID lauks automātiski ģenerēs unikālu vērtību katru reizi, kad izveidosit jaunu klientu.
  • @Column: apzīmē rekvizītu, kas tiek kartēts uz kolonnu datubāzē. Tātad vārda rekvizīts tiks kartēts ar klienta nosaukuma kolonnu datubāzē.

Repozitorija izveide

Šis repozitorijs ļaus jums mijiedarboties ar klientu datiem datu bāzē.

iepakojums com.onlineshopaholics.api.repository;
imports org.springframework.data.repository. CrudRepository;
imports com.onlineshopaholics.api.model. Klients;


publiskisaskarneKlientu krātuvepagarinaCrudRepository<Klients, Vesels skaitlis>{}

Klientu krātuve paplašinās Pavasara CrudRepositoy saskarni, nododot tai Klienta modeļa klasi kopā ar entītijas unikālā identifikatora veidu Vesels skaitlis.

CrudRepository saskarne nodrošina piekļuvi vairāk nekā 10 operācijām, tostarp vispārīgajām CRUD metodēm, kas jums būs nepieciešamas REST API. Tā kā CrudRepository jau definē jums nepieciešamās metodes, nav nepieciešams tās skaidri deklarēt CustomerRepository saskarnē.

Kontrollera izveide

Kontrolieris ļauj atjaunināt datus savā datubāzē, izmantojot modeli un repozitoriju.

iepakojums com.onlineshopaholics.api.controller;
imports java.util. Neobligāti;


imports org.springframework.beans.factory.annotation. Autowired;
imports org.springframework.web.bind.annotation. DeleteMapping;
imports org.springframework.web.bind.annotation. GetMapping;
imports org.springframework.web.bind.annotation. PathVariable;
imports org.springframework.web.bind.annotation. PostMapping;
imports org.springframework.web.bind.annotation. PutMapping;
imports org.springframework.web.bind.annotation. RequestBody;
imports org.springframework.web.bind.annotation. RequestMapping;
imports org.springframework.web.bind.annotation. RequestParam;
imports org.springframework.web.bind.annotation. ResponseBody;
imports org.springframework.web.bind.annotation. RestController;


imports com.onlineshopaholics.api.model. Klients;
imports com.onlineshopaholics.api.repository. Klientu krātuve;


@RestController
@RequestMapping("/klienti")
publiskiklasēCustomerController{
@Autowired
Privāts CustomerRepository customerRepository;


// izveidot jaunu klientu
@PostMapping("/pievienot")
publiski Klients pievienot jaunu klientu(@RequestBody Customer newCustomer){
 Klientu lietotājs = jauns Klients();
 user.setName (newCustomer.getName());
 user.setEmail (newCustomer.getEmail());
 customerRepository.save (lietotājs);
atgriezties lietotājs; 
 }


// apskatīt visus klientus
@GetMapping("Skatīt visu")
publiski@ResponseBodyAtkārtojamsgetAllCustomers(){
atgriezties customerRepository.findAll();
 }


// skatīt konkrētu klientu
@GetMapping("view/{id}")
publiski NeobligātigetCustomer(@PathVariable Integer id){
atgriezties customerRepository.findById (id);
 }


// atjaunināt esošo klientu
@PutMapping("/rediģēt/{id}")
publiski Stīga Atjaunināt( @RequestBody Customer updateCustomer, @PathVariable Integer id){
atgriezties customerRepository.findById (id)
 .map (klients -> {
 customer.setName (updateCustomer.getName());
 customer.setEmail (updateCustomer.getEmail());
 customerRepository.save (klients);
atgriezties"Klienta informācija ir veiksmīgi atjaunināta!";
 }).orElseGet(() -> {
atgriezties"Šis klients neeksistē";
 });
 }


// dzēst klientu
@DeleteMapping("dzēst/{id}")
publiski Stīga dzēst(@PathVariable("id")Vesela skaitļa ID) {
 customerRepository.deleteById (id); 
atgriezties"Klients ir veiksmīgi izdzēsts!";
 }
}

Iepriekš minētais kontrolieris aprīko REST API ar CRUD operācijām, izmantojot piecas no CrudRepository saskarnes metodes (katra piešķirta noteiktai metodei). Kontrolieris izmanto arī vairākas svarīgas Pavasara anotācijas, kas ļauj tai veikt savas funkcijas.

  • @RestController: šai anotācijai ir divi mērķi. Tas iezīmē klasi atklāšanai, veicot komponentu skenēšanu. Tas arī liek Springam atbildes pamattekstā ierakstīt atgriešanās vērtību visām šīs klases metodēm.
  • @RequestMapping: definē bāzes pieprasījuma modeli, ko apstrādās kontrolieris. Tātad šis kontrolieris apstrādās visus pieprasījumus “/customers”.
  • @ResponseBody: ļauj metodei atgriezt visu entītiju.
  • @RequestBody: ļauj pārveidot pieprasījuma pamattekstu par objektu.
  • @RequestParam: ļauj izolēt vienu īpašumu no objekta.
  • @PathVariable: ļauj kartēt pieprasījuma vērtību ar vietturi. Tas kartē dzēšanas metodei piešķirto ID ar datu bāzē esošu vērtību.
  • @PostMapping: ļauj izveidot resursus.
  • @GetMapping: ļauj lasīt resursu datus.
  • @PutMapping: ļauj atjaunināt resursus.
  • @DeleteMapping: ļauj dzēst resursus.

Datu bāzes savienošana ar jūsu lietojumprogrammu

Lai savienotu datubāzi ar jebkuru Spring lietojumprogrammu, jums būs jāizmanto pielietojums.īpašības failu zem resursu mapes. Šis fails sākotnēji ir tukšs, tāpēc varat to aizpildīt ar atbilstošiem rekvizītiem datu bāzei, kuru plānojat izmantot. Šī lietojumprogramma izmantos MySQL datu bāzi, tāpēc failā application.properties būs šādi 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. Šoferis

Iepriekš minētie dati parāda, ka šī lietojumprogramma izveidos savienojumu ar MySQL datu bāzi, ko sauc par onlineshopaholics, ar “root” lietotājvārdu un “securepw” kā paroli. Nākamais solis ir izveidot datu bāzi un klientu tabulu MySQL.

Pieprasījumu veidošana

Ir daudz rīku, ko varat izmantot, lai pārbaudītu savu REST API. Postman ir populārs REST API testēšanas rīks, un varat to izmantot, lai pārbaudītu vienkāršo izveidoto API. Pēc MySQL tabulas izveides un lietojumprogrammas Spring palaišanas varat palaist Postman un eksperimentēt ar četriem pieprasījuma darbības vārdiem.

POST pieprasījums

Šis pieprasījums ļaus jums izveidot jaunus klientus, izmantojot REST API. Lai pabeigtu šo pieprasījumu, jums ir jāatver ziņas pieprasījuma galveņu sadaļa un jāizveido jauna galvene (satura veids). Šīs galvenes vērtība ir jāiestata uz lietojumprogramma/json, jo jūs veidosit jaunus klientus, izmantojot JSON.

Pieprasījuma pamattekstā jums būs jāmaina veids uz neapstrādātu un jāievieto JSON. Pēc tam jums būs jāievada ziņas URL:

Nosūtot pieprasījumu, tiks saņemta šāda atbilde:

Var redzēt, ka pieprasījums bija veiksmīgs, un jaunajam klientam ir arī ID.

SAŅEMT Pieprasījumu

Tagad, kad jums ir klients, varat to skatīt ar saņemšanas pieprasījumu, kas atgriež visus klientus:

Vai katrs klients pēc ID:

PUT pieprasījums

Varat atjaunināt Dženetu ar jaunu uzvārdu un e-pasta adresi.

DZĒST pieprasījums

Varat arī izdzēst Dženetu no datu bāzes.

Pārbaudiet savu Spring REST API, izmantojot JUnit

Izmantojot Spring Boot, varat pārbaudīt jebkuru lietojumprogrammu (tostarp REST API), izmantojot Spring testa failu. Programmatūras testēšana ir svarīga Spring Boot. Katra inicializēta Spring lietojumprogramma testēšanai izmanto JUnit un ļauj nosūtīt pieprasījumus uz jūsu REST API.