Annotations Web de printemps

Cet article fait partie d'une série: • Annotations Spring Core

• Annotations Spring Web (article actuel) • Annotations Spring Boot

• Annotations de planification du printemps

• Annotations de données Spring

• Annotations Spring Bean

1. Vue d'ensemble

Dans ce didacticiel, nous explorerons les annotations Spring Web à partir du package org.springframework.web.bind.annotation .

2. @RequestMapping

En termes simples, @RequestMapping marques demandent des méthodes gestionnaire à l' intérieur @Controller classes; il peut être configuré en utilisant:

  • chemin, ou ses alias, nom et valeur: à quelle URL la méthode est mappée
  • méthode: méthodes HTTP compatibles
  • params: filtre les demandes en fonction de la présence, de l'absence ou de la valeur des paramètres HTTP
  • headers: filtre les requêtes en fonction de la présence, de l'absence ou de la valeur des en-têtes HTTP
  • consomme: quels types de média la méthode peut consommer dans le corps de la requête HTTP
  • produit: quels types de média la méthode peut produire dans le corps de la réponse HTTP

Voici un exemple rapide de ce à quoi cela ressemble:

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

Nous pouvons fournir des paramètres par défaut pour toutes les méthodes de gestionnaire dans une classe @Controller si nous appliquons cette annotation au niveau de la classe. La seule exception est l'URL que Spring ne remplacera pas par les paramètres au niveau de la méthode, mais ajoute les deux parties du chemin.

Par exemple, la configuration suivante a le même effet que celle ci-dessus:

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

De plus, @GetMapping , @PostMapping , @PutMapping , @DeleteMapping et @PatchMapping sont des variantes différentes de @RequestMapping avec la méthode HTTP déjà définie sur GET, POST, PUT, DELETE et PATCH respectivement.

Ceux-ci sont disponibles depuis la version Spring 4.3.

3. @RequestBody

Passons à @RequestBody - qui mappe le corps de la requête HTTP à un objet :

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

La désérialisation est automatique et dépend du type de contenu de la requête.

4. @PathVariable

Ensuite, parlons de @PathVariable .

Cette annotation indique qu'un argument de méthode est lié à une variable de modèle d'URI . Nous pouvons spécifier le modèle d'URI avec l' annotation @RequestMapping et lier un argument de méthode à l'une des parties du modèle avec @PathVariable .

On peut y parvenir avec le nom ou son alias, l' argument value :

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

Si le nom de la pièce dans le modèle correspond au nom de l'argument de la méthode, nous n'avons pas à le spécifier dans l'annotation:

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

De plus, nous pouvons marquer une variable de chemin facultative en définissant l'argument requis sur false:

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

5. @RequestParam

Nous utilisons @RequestParam pour accéder aux paramètres de requête HTTP :

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

Il a les mêmes options de configuration que l' annotation @PathVariable .

En plus de ces paramètres, avec @RequestParam, nous pouvons spécifier une valeur injectée lorsque Spring trouve aucune valeur ou une valeur vide dans la requête. Pour y parvenir, nous devons définir l' argument defaultValue .

Fournir une valeur par défaut définit implicitement requis sur false:

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

Outre les paramètres, il existe d' autres parties de requête HTTP auxquelles nous pouvons accéder: les cookies et les en-têtes . Nous pouvons y accéder avec les annotations @CookieValue et @RequestHeader respectivement.

Nous pouvons les configurer de la même manière que @RequestParam .

6. Annotations de gestion des réponses

Dans les sections suivantes, nous verrons les annotations les plus courantes pour manipuler les réponses HTTP dans Spring MVC.

6.1. @ResponseBody

Si nous marquons une méthode de gestionnaire de requêtes avec @ResponseBody, Spring traite le résultat de la méthode comme la réponse elle - même :

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

Si nous annotons une classe @Controller avec cette annotation, toutes les méthodes de gestion de requêtes l'utiliseront.

6.2. @ExceptionHandler

Avec cette annotation, nous pouvons déclarer une méthode de gestion d'erreur personnalisée . Spring appelle cette méthode lorsqu'une méthode de gestionnaire de requêtes lève l'une des exceptions spécifiées.

L'exception interceptée peut être passée à la méthode en tant qu'argument:

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

Pour plus de détails, veuillez consulter cet article.

8. Conclusion

Dans cet article, nous avons vu comment nous pouvons gérer les requêtes et réponses HTTP avec Spring MVC.

Comme d'habitude, les exemples sont disponibles à l'adresse over sur GitHub.

Suivant » Annotations Spring Boot « Précédent Annotations Spring Core