Annotazioni Web di primavera

Questo articolo fa parte di una serie: • Annotazioni Spring Core

• Annotazioni Web Spring (articolo corrente) • Annotazioni Spring Boot

• Annotazioni di pianificazione della primavera

• Annotazioni sui dati primaverili

• Annotazioni Spring Bean

1. Panoramica

In questo tutorial, esploreremo le annotazioni Spring Web dal pacchetto org.springframework.web.bind.annotation .

2. @RequestMapping

In poche parole, i segni @RequestMapping richiedono metodi di gestione all'interno delle classi @Controller ; può essere configurato utilizzando:

  • percorso o suoi alias, nome e valore: a quale URL è mappato il metodo
  • metodo: metodi HTTP compatibili
  • params: filtra le richieste in base alla presenza, all'assenza o al valore dei parametri HTTP
  • intestazioni: filtra le richieste in base alla presenza, all'assenza o al valore delle intestazioni HTTP
  • consumes: quali tipi di media il metodo può utilizzare nel corpo della richiesta HTTP
  • produce: quali tipi di media il metodo può produrre nel corpo della risposta HTTP

Ecco un rapido esempio di come appare:

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

Possiamo fornire impostazioni predefinite per tutti i metodi del gestore in una classe @Controller se applichiamo questa annotazione a livello di classe. L'unica eccezione è l'URL che Spring non sovrascriverà con le impostazioni a livello di metodo ma aggiungerà le due parti del percorso.

Ad esempio, la seguente configurazione ha lo stesso effetto di quella sopra:

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

Inoltre, @GetMapping , @PostMapping , @PutMapping , @DeleteMapping e @PatchMapping sono varianti diverse di @RequestMapping con il metodo HTTP già impostato rispettivamente su GET, POST, PUT, DELETE e PATCH.

Questi sono disponibili dalla versione Spring 4.3.

3. @RequestBody

Passiamo a @RequestBody , che mappa il corpo della richiesta HTTP su un oggetto :

@PostMapping("/save") void saveVehicle(@RequestBody Vehicle vehicle) { // ... }

La deserializzazione è automatica e dipende dal tipo di contenuto della richiesta.

4. @PathVariable

Successivamente, parliamo di @PathVariable .

Questa annotazione indica che un argomento del metodo è associato a una variabile del modello URI . Possiamo specificare il modello URI con l' annotazione @RequestMapping e associare un argomento del metodo a una delle parti del modello con @PathVariable .

Possiamo ottenere ciò con il nome o il suo alias, l' argomento valore :

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable("id") long id) { // ... }

Se il nome della parte nel modello corrisponde al nome dell'argomento del metodo, non è necessario specificarlo nell'annotazione:

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable long id) { // ... }

Inoltre, possiamo contrassegnare una variabile di percorso come opzionale impostando l'argomento richiesto su false:

@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable(required = false) long id) { // ... }

5. @RequestParam

Usiamo @RequestParam per accedere ai parametri di richiesta HTTP :

@RequestMapping Vehicle getVehicleByParam(@RequestParam("id") long id) { // ... }

Ha le stesse opzioni di configurazione dell'annotazione @PathVariable .

Oltre a queste impostazioni, con @RequestParam possiamo specificare un valore iniettato quando Spring trova un valore vuoto o assente nella richiesta. Per ottenere ciò, dobbiamo impostare l' argomento defaultValue .

Fornire un valore predefinito imposta implicitamente richiesto su false:

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

Oltre ai parametri, ci sono altre parti di richieste HTTP a cui possiamo accedere: cookie e intestazioni . Possiamo accedervi rispettivamente con le annotazioni @CookieValue e @RequestHeader .

Possiamo configurarli allo stesso modo di @RequestParam .

6. Annotazioni per la gestione delle risposte

Nelle prossime sezioni vedremo le annotazioni più comuni per manipolare le risposte HTTP in Spring MVC.

6.1. @ResponseBody

Se contrassegniamo un metodo del gestore delle richieste con @ResponseBody, Spring considera il risultato del metodo come la risposta stessa :

@ResponseBody @RequestMapping("/hello") String hello() { return "Hello World!"; }

Se annotiamo una classe @Controller con questa annotazione, tutti i metodi del gestore delle richieste la useranno.

6.2. @ExceptionHandler

Con questa annotazione, possiamo dichiarare un metodo di gestione degli errori personalizzato . Spring chiama questo metodo quando un metodo del gestore delle richieste genera una delle eccezioni specificate.

L'eccezione rilevata può essere passata al metodo come argomento:

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

6.3. @ResponseStatus

We can specify the desired HTTP status of the response if we annotate a request handler method with this annotation. We can declare the status code with the code argument, or its alias, the value argument.

Also, we can provide a reason using the reason argument.

We also can use it along with @ExceptionHandler:

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

For more information about HTTP response status, please visit this article.

7. Other Web Annotations

Some annotations don't manage HTTP requests or responses directly. In the next sections, we'll introduce the most common ones.

7.1. @Controller

We can define a Spring MVC controller with @Controller. For more information, please visit our article about Spring Bean Annotations.

7.2. @RestController

The @RestControllercombines @Controller and @ResponseBody.

Therefore, the following declarations are equivalent:

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

7.3. @ModelAttribute

With this annotation we can access elements that are already in the model of an MVC @Controller, by providing the model key:

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

Like with @PathVariable and @RequestParam, we don't have to specify the model key if the argument has the same name:

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

Besides, @ModelAttribute has another use: if we annotate a method with it, Spring will automatically add the method's return value to the model:

@ModelAttribute("vehicle") Vehicle getVehicle() { // ... }

Like before, we don't have to specify the model key, Spring uses the method's name by default:

@ModelAttribute Vehicle vehicle() { // ... }

Before Spring calls a request handler method, it invokes all @ModelAttribute annotated methods in the class.

More information about @ModelAttribute can be found in this article.

7.4. @CrossOrigin

@CrossOriginenables cross-domain communication for the annotated request handler methods:

@CrossOrigin @RequestMapping("/hello") String hello() { return "Hello World!"; }

If we mark a class with it, it applies to all request handler methods in it.

We can fine-tune CORS behavior with this annotation's arguments.

Per maggiori dettagli, visita questo articolo.

8. Conclusione

In questo articolo, abbiamo visto come gestire le richieste e le risposte HTTP con Spring MVC.

Come al solito, gli esempi sono disponibili su GitHub.

Avanti » Annotazioni Spring Boot « Annotazioni Spring Core precedenti