Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

De afkorting REST staat voor REpresentational State Transfer, terwijl API staat voor Application Programming Interface. Samen verwijzen ze naar een REST API. Een REST API is een service die verzoeken en antwoorden overbrengt tussen twee softwaresystemen, op een REST-architectuur.

De REST-architectuur bouwt webservices die toegankelijk zijn via URL's met behulp van een van de vier verzoekwerkwoorden: POST, GET, PUT en DELETE. Je zou dus kunnen zeggen dat een REST API software is waarmee je bronnen kunt maken, lezen, bijwerken en verwijderen via URL's.

U kunt leren hoe u een REST API maakt met behulp van Spring Boot.

De Spring Boot-toepassing initialiseren

Het eerste wat je moet doen is Maak kennis met de basisprincipes van de lente en stel een Spring Boot-toepassing in. U moet echter de afhankelijkheden wijzigen. Naast de webafhankelijkheid, moet u de afhankelijkheid van Spring Data Java Persistent API (JPA) en het stuurprogramma voor de database die u wilt gebruiken verkrijgen (deze toepassing gebruikt MySQL).

instagram viewer

Voor deze REST API heb je een controller, een model en een repository nodig. De REST API heeft dus de volgende bestandsstructuur:

Het maken van het model

De eerste klasse die u moet maken, is het klantmodel, waarin de gegevenslogica wordt opgeslagen.

pakket com.onlineshopaholics.api.model;
importeren jakarta.volharding. Kolom;
importeren jakarta.volharding. Entiteit;
importeren jakarta.volharding. Gegenereerde Waarde;
importeren jakarta.volharding. GeneratieType;
importeren jakarta.volharding. ID kaart;
importeren jakarta.volharding. Tafel;


@Tafel(naam="klant")
@Entiteit
openbaarklasKlant{
@ID kaart
@GegenereerdeWaarde(strategie = GenerationType. AUTO)
privaat Integer-ID;


@Kolom(naam="klantnaam")
privaat Tekenreeks naam;


privaat String e-mail;


openbaar Geheel getal getId(){
opbrengst ID kaart;
 }


openbaarleegtesetId(geheel getal){
dit.id = id;
 }


openbaar Snaar getNaam(){
opbrengst naam;
 }


openbaarleegtesetNaam(Tekenreeksnaam){
dit.naam = naam;
 }


openbaar Snaar e-mail ophalen(){
opbrengst e-mail;
 }
openbaarleegtesetEmail(Tekenreeks e-mailadres){
dit.email = e-mail;
 }
}

In de bovenstaande klantklasse ziet u dat elke klant een ID, naam en e-mailadres heeft. U zult ook verschillende annotaties opmerken die verschillende doelen dienen.

  • @Entity: verklaart de klantklasse als een JPA-entiteit. Dit betekent dat JPA de velden in de klasse zal gebruiken om kolommen in een relationele database te maken.
  • @Table: geeft de naam aan van de tabel die wordt toegewezen aan de klantmodelklasse.
  • @Id: geeft een eigenschap aan die de entiteit in de database op unieke wijze identificeert.
  • @GeneratedValue en @GenerationType: deze werken samen om een ​​automatisch gegenereerde strategie te specificeren voor het veld waarmee het wordt geassocieerd. Het id-veld genereert dus automatisch een unieke waarde telkens wanneer u een nieuwe klant aanmaakt.
  • @Column: geeft een eigenschap aan die wordt toegewezen aan een kolom in de database. De eigenschap name wordt dus toegewezen aan een kolom klantnaam in de database.

De opslagplaats maken

Met deze repository kunt u communiceren met de klantgegevens in de database.

pakket com.onlineshopaholics.api.repository;
importeren org.springframework.data.repository. CrudRepository;
importeren com.onlineshopaholics.api.model. Klant;


openbaarkoppelKlantRepositorystrekt zich uitCrudRepository<Klant, Geheel getal>{}

De klantenrepository wordt uitgebreid Spring's CrudRepositoy interface, waarbij de modelklasse Klant wordt doorgegeven samen met het type unieke identificatiecode voor de entiteit, Integer.

De CrudRepository-interface biedt toegang tot meer dan 10 bewerkingen, inclusief de generieke CRUD-methoden die u nodig heeft voor de REST API. Dus, omdat de CrudRepository al de methoden definieert die u nodig heeft, is het niet nodig om ze expliciet te declareren in de CustomerRepository-interface.

De controller maken

Met de controller kunt u de gegevens in uw database bijwerken met behulp van het model en de repository.

pakket com.onlineshopaholics.api.controller;
importeren java.util. Optioneel;


importeren org.springframework.beans.factory.annotation. Automatisch bedraad;
importeren org.springframework.web.bind.annotation. DeleteMapping;
importeren org.springframework.web.bind.annotation. GetMapping;
importeren org.springframework.web.bind.annotation. PadVariabele;
importeren org.springframework.web.bind.annotation. postmapping;
importeren org.springframework.web.bind.annotation. PutMapping;
importeren org.springframework.web.bind.annotation. RequestBody;
importeren org.springframework.web.bind.annotation. RequestMapping;
importeren org.springframework.web.bind.annotation. RequestParam;
importeren org.springframework.web.bind.annotation. ResponseBody;
importeren org.springframework.web.bind.annotation. RestController;


importeren com.onlineshopaholics.api.model. Klant;
importeren com.onlineshopaholics.api.repository. KlantRepository;


@RestController
@RequestMapping("/klanten")
openbaarklasKlantController{
@Autowired
privaat CustomerRepository customerRepository;


// nieuwe klant aanmaken
@PostMapping("/toevoegen")
openbaar Klant addNieuweKlant(@RequestBody Klant nieuweKlant){
 Klant gebruiker = nieuw Klant();
 gebruiker.setName (nieuweKlant.getName());
 gebruiker.setEmail (newCustomer.getEmail());
 customerRepository.save (gebruiker);
opbrengst gebruiker; 
 }


// bekijk alle klanten
@GetMapping("Bekijk alles")
openbaar@ResponseBodyItereerbaargetAllCustomers(){
opbrengst customerRepository.findAll();
 }


// bekijk specifieke klant
@GetMapping("bekijken/{id}")
openbaar OptioneelkrijgKlant(@PathVariable Integer-ID){
opbrengst customerRepository.findById (id);
 }


// update een bestaande klant
@PutMapping("/bewerken/{id}")
openbaar Snaar update( @RequestBody KlantupdateKlant, @PathVariable Integer id){
opbrengst customerRepository.findById (id)
 .map (klant -> {
 klant.setName (updateKlant.getName());
 klant.setEmail (updateKlant.getEmail());
 customerRepository.save (klant);
opbrengst"Klantgegevens zijn succesvol bijgewerkt!";
 }).ofElseGet(() -> {
opbrengst"Deze klant bestaat niet";
 });
 }


// klant verwijderen
@DeleteMapping("verwijderen/{id}")
openbaar Snaar verwijderen(@PathVariabele("ID kaart")Integer-ID) {
 customerRepository.deleteById (id); 
opbrengst"Klant is succesvol verwijderd!";
 }
}

De bovenstaande controller rust de REST API uit met CRUD-bewerkingen door vijf van de CrudRepository te gebruiken interfacemethoden (elk toegewezen aan een specifieke methode). De controller gebruikt ook verschillende belangrijke Spring-annotaties waarmee deze zijn functies kan uitvoeren.

  • @RestController: deze annotatie heeft twee doelen. Het markeert een klasse voor ontdekking door het scannen van componenten. Het vertelt Spring ook om de geretourneerde waarde voor alle methoden in deze klasse in de hoofdtekst van het antwoord te schrijven.
  • @RequestMapping: definieert het basisverzoekpatroon dat de controller zal afhandelen. Deze controller zal dus alle verzoeken aan "/klanten" afhandelen.
  • @ResponseBody: Hiermee kan een methode een volledige entiteit retourneren.
  • @RequestBody: Hiermee kunt u de aanvraagtekst naar een object converteren.
  • @RequestParam: Hiermee kunt u één eigenschap isoleren van een object.
  • @PathVariable: Hiermee kunt u een aanvraagwaarde toewijzen aan een tijdelijke aanduiding. Het koppelt de ID die aan de verwijdermethode is gegeven aan een bestaande waarde in de database.
  • @PostMapping: Hiermee kunt u bronnen maken.
  • @GetMapping: Hiermee kunt u brongegevens lezen.
  • @PutMapping: Hiermee kunt u bronnen bijwerken.
  • @DeleteMapping: Hiermee kunt u bronnen verwijderen.

De database verbinden met uw toepassing

Om een ​​database aan een Spring-toepassing te koppelen, moet u de applicatie.eigenschappen bestand onder de map resources. Dit bestand is aanvankelijk leeg, dus u kunt het vullen met de juiste eigenschappen voor de database die u wilt gebruiken. Deze applicatie gebruikt een MySQL-database, dus het bestand application.properties bevat de volgende gegevens:

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. Bestuurder

De bovenstaande gegevens laten zien dat deze applicatie verbinding zal maken met een MySQL-database genaamd onlineshopaholics, met een "root" gebruikersnaam en "securepw" als het wachtwoord. Uw volgende stap is het maken van de database en klantentabel in MySQL.

Aanvragen maken

Er zijn veel tools die u kunt gebruiken om uw REST API te testen. Postman is een populaire REST API-testtool, en je kunt het gebruiken om de eenvoudige API die je hebt gebouwd te testen. Nadat u de MySQL-tabel hebt gemaakt en de Spring-toepassing hebt uitgevoerd, kunt u Postman starten en experimenteren met de vier verzoekwerkwoorden.

POST-verzoek

Met dit verzoek kunt u nieuwe klanten maken met behulp van de REST API. Om dit verzoek te voltooien, moet je naar het headers-gedeelte van je berichtverzoek gaan en een nieuwe header maken (Content-Type). U moet de waarde van deze header instellen op application/json, aangezien u nieuwe klanten gaat maken met JSON.

In de hoofdtekst van het verzoek moet u het type wijzigen in onbewerkt en uw JSON invoegen. Vervolgens moet u de bericht-URL invoegen:

Als u het verzoek verzendt, wordt het volgende antwoord geretourneerd:

U kunt zien dat de aanvraag is gelukt en dat de nieuwe klant ook een id heeft.

KRIJG verzoek

Nu je een klant hebt, kun je deze bekijken met het get-verzoek dat alle klanten retourneert:

Of elke klant op id:

PUT-verzoek

Je kunt Janet updaten met een nieuwe achternaam en e-mail.

Verwijder verzoek

U kunt Janet ook uit de database verwijderen.

Test uw Spring REST API met behulp van JUnit

Met Spring Boot kunt u elke toepassing (inclusief REST API's) testen met behulp van het testbestand van Spring. Het testen van software is belangrijk voor Spring Boot. Elke geïnitialiseerde Spring-toepassing gebruikt JUnit voor testen en stelt u in staat verzoeken naar uw REST-API's te verzenden.