Spring Web-annotaties

Dit artikel maakt deel uit van een reeks: • Spring Core Annotations

• Spring Web-annotaties (huidig ​​artikel) • Spring Boot-annotaties

• Annotaties voor voorjaarsplanning

• Spring Data-annotaties

• Spring Bean-annotaties

1. Overzicht

In deze zelfstudie verkennen we Spring Web-annotaties van de org.springframework.web.bind.annotation pakket.

2. @RequestMapping

Simpel gezegd, @RequestMappingmarkeert de behandelmethoden voor verzoeken binnen @Controller klassen; het kan worden geconfigureerd met:

  • pad, of zijn aliassen, naam, en waarde: aan welke URL de methode is toegewezen
  • methode: compatibele HTTP-methoden
  • parameters: filtert verzoeken op basis van aanwezigheid, afwezigheid of waarde van HTTP-parameters
  • headers: filtert verzoeken op basis van aanwezigheid, afwezigheid of waarde van HTTP-headers
  • verbruikt: welke mediatypen de methode kan verbruiken in de hoofdtekst van het HTTP-verzoek
  • produceert: welke mediatypen de methode kan produceren in de HTTP-antwoordtekst

Hier is een snel voorbeeld van hoe dat eruit ziet:

@Controller klasse VehicleController {@RequestMapping (value = "/ vehicles / home", method = RequestMethod.GET) String home () {return "home"; }}

We kunnen zorgen standaardinstellingen voor alle handlermethoden in een @Controller klasse als we deze annotatie toepassen op klasniveau. De enige uitzondering is de URL die Spring niet overschrijft met methode niveau instellingen maar voegt de twee paddelen toe.

De volgende configuratie heeft bijvoorbeeld hetzelfde effect als de bovenstaande:

@Controller @RequestMapping (value = "/ vehicles", method = RequestMethod.GET) klasse VehicleController {@RequestMapping ("/ home") String home () {return "home"; }}

Bovendien, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, en @PatchMapping zijn verschillende varianten van @RequestMapping met de HTTP-methode al ingesteld op respectievelijk GET, POST, PUT, DELETE en PATCH.

Deze zijn beschikbaar sinds de release van Spring 4.3.

3. @RequestBody

Laten we verder gaan @RequestBody - die de body van het HTTP-verzoek aan een object:

@PostMapping ("/ save") void saveVehicle (@RequestBody Voertuig voertuig) {// ...}

De deserialisatie is automatisch en hangt af van het inhoudstype van het verzoek.

4. @PathVariable

Laten we het vervolgens hebben over @PathVariable.

Deze annotatie geeft aan dat a method-argument is gebonden aan een URI-sjabloonvariabele. We kunnen de URI-sjabloon specificeren met de @RequestMapping annotatie en bind een methode-argument aan een van de sjabloononderdelen met @PathVariable.

We kunnen dit bereiken met de naam of zijn alias, de waarde argument:

@RequestMapping ("/ {id}") Voertuig getVehicle (@PathVariable ("id") lange id) {// ...}

Als de naam van het onderdeel in de sjabloon overeenkomt met de naam van het methode-argument, hoeven we dit niet op te geven in de annotatie:

@RequestMapping ("/ {id}") Voertuig getVehicle (@PathVariable lange id) {// ...}

Bovendien kunnen we een padvariabele optioneel markeren door het argument in te stellen verplicht naar false:

@RequestMapping ("/ {id}") Voertuig getVehicle (@PathVariable (verplicht = false) lange id) {// ...}

5. @RequestParam

We gebruiken @RequestParam voor toegang krijgen tot HTTP-verzoekparameters:

@RequestMapping Voertuig getVehicleByParam (@RequestParam ("id") lange id) {// ...}

Het heeft dezelfde configuratie-opties als het @PathVariable annotatie.

Naast die instellingen, met @RequestParam we kunnen een geïnjecteerde waarde specificeren wanneer Spring geen of lege waarde vindt in het verzoek. Om dit te bereiken, moeten we de standaardwaarde argument.

Door een standaardwaarde op te geven, wordt impliciet ingesteld verplicht naar vals:

@RequestMapping ("/ buy") Car buyCar (@RequestParam (defaultValue = "5") int seatCount) {// ...}

Naast parameters zijn er andere delen van HTTP-verzoeken waartoe we toegang hebben: cookies en headers. We hebben er toegang toe met de annotaties @CookieValue en @RequestHeader respectievelijk.

We kunnen ze op dezelfde manier configureren als @RequestParam.

6. Annotaties bij het afhandelen van reacties

In de volgende secties zullen we de meest voorkomende annotaties zien om HTTP-reacties in Spring MVC te manipuleren.

6.1. @ResponseBody

Als we een verzoekbehandelingsmethode markeren met @ResponseBody,Spring behandelt het resultaat van de methode als het antwoord zelf:

@ResponseBody @RequestMapping ("/ hallo") String hallo () {retourneer "Hallo wereld!"; }

Als we een @Controller klasse met deze annotatie, zullen alle verzoekbehandelingsmethoden deze gebruiken.

6.2. @BuienRadarNL

Met deze annotatie kunnen we een aangepaste foutafhandelingsmethode. Spring roept deze methode aan wanneer een verzoekbehandelingsmethode een van de gespecificeerde uitzonderingen genereert.

De gevangen uitzondering kan als argument aan de methode worden doorgegeven:

@ExceptionHandler (IllegalArgumentException.class) void onIllegalArgumentException (IllegalArgumentException-uitzondering) {// ...}

6.3. @ResponseStatus

We kunnen de gewenste HTTP-status van het antwoord als we een verzoekbehandelingsmethode annoteren met deze annotatie. We kunnen de statuscode aangeven met de code argument, of zijn alias, de waarde argument.

We kunnen ook een reden opgeven met behulp van de reden argument.

We kunnen het ook samen met gebruiken @BuienRadarNL:

@ExceptionHandler (IllegalArgumentException.class) @ResponseStatus (HttpStatus.BAD_REQUEST) void onIllegalArgumentException (IllegalArgumentException-uitzondering) {// ...}

Bezoek dit artikel voor meer informatie over de HTTP-antwoordstatus.

7. Andere webannotaties

Sommige annotaties beheren HTTP-verzoeken of reacties niet rechtstreeks. In de volgende secties introduceren we de meest voorkomende.

7.1. @Controller

We kunnen een Spring MVC-controller definiëren met @Controller. Ga voor meer informatie naar ons artikel over Spring Bean-annotaties.

7.2. @RestController

De @RestControllercombineert @Controller en @ResponseBody.

Daarom zijn de volgende verklaringen gelijkwaardig:

@Controller @ResponseBody klasse VehicleRestController {// ...}
@RestController klasse VehicleRestController {// ...}

7.3. @ModelAttribute

Met deze annotatie kunnen we toegang tot elementen die al in het model aanwezig zijn van een MVC @Controller, door de modelsleutel op te geven:

@PostMapping ("/ assemble") void assembleVehicle (@ModelAttribute ("vehicle") Vehicle vehicleInModel) {// ...}

Zoals bij @PathVariable en @RequestParam, we hoeven de modelsleutel niet op te geven als het argument dezelfde naam heeft:

@PostMapping ("/ assemble") void assembleVehicle (@ModelAttribute Voertuig voertuig) {// ...}

Trouwens, @ModelAttribute heeft een ander nut: als we er een methode mee annoteren, zal Spring dat doen automatisch de retourwaarde van de methode aan het model toevoegen:

@ModelAttribute ("voertuig") Voertuig getVehicle () {// ...}

Zoals eerder hoeven we de modelsleutel niet op te geven, Spring gebruikt standaard de naam van de methode:

@ModelAttribute Voertuig voertuig () {// ...}

Voordat Spring een verzoekbehandelingsmethode aanroept, roept het alles aan @ModelAttribute geannoteerde methoden in de klas.

Meer informatie over @ModelAttribute vind je in dit artikel.

7.4. @CrossOrigin

@CrossOriginmaakt communicatie tussen domeinen mogelijk voor de geannoteerde methoden voor het afhandelen van verzoeken:

@CrossOrigin @RequestMapping ("/ hallo") String hallo () {retourneer "Hallo wereld!"; }

Als we er een klasse mee markeren, is deze van toepassing op alle verzoekbehandelingsmethoden erin.

We kunnen CORS-gedrag verfijnen met de argumenten van deze annotatie.

Bezoek dit artikel voor meer informatie.

8. Conclusie

In dit artikel hebben we gezien hoe we HTTP-verzoeken en -reacties kunnen afhandelen met Spring MVC.

Zoals gewoonlijk zijn de voorbeelden beschikbaar op GitHub.

De volgende » Annotaties Spring Boot « Eerdere Spring Core-annotaties