TOC

Spring Web Annotations

Annotations Web de printemps

1. Vue d'ensemble

Dans ce didacticiel, nous allons explorer les annotations Spring Web du packageorg.springframework.web.bind.annotation.

2. @RequestMapping

En termes simples,@RequestMappingmarks request handler methods à l'intérieur des classes@Controller; il peut être configuré en utilisant:

  • path, ou ses alias,name, etvalue: à quelle URL la méthode est mappée

  • Méthodes HTTP compatiblesmethod:

  • params: filtre les demandes en fonction de la présence, de l'absence ou de la valeur des paramètres HTTP

  • headers: filtre les demandes en fonction de la présence, de l'absence ou de la valeur des en-têtes HTTP

  • consumes: quels types de média la méthode peut consommer dans le corps de la requête HTTP

  • produces: 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 fournirdefault settings for all handler methods in a @Controller class si nous appliquons cette annotation au niveau de la classe. Le seulexception is the URL which Spring won’t override avec des paramètres de niveau 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 lesbody of the HTTP request to an object: 

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

La désérialisation est automatique et dépend du type de contenu de la demande.

4. @PathVariable

Ensuite, parlons de@PathVariable.

Cette annotation indique qu'unmethod argument is bound to a URI template variable. 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 lename ou son alias, l'argumentvalue: 

@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'argumentrequired sur false: 

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

5. @RequestParam

Nous utilisons@RequestParam pouraccessing HTTP request parameters: 

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

Fournir une valeur par défaut définit implicitementrequired surfalse: 

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

Outre les paramètres, il existe desother HTTP request parts we can access: cookies and headers. On peut y accéder avec les annotations@CookieValue and @RequestHeader respectivement.

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

6. Réponse aux annotations

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 treats the result of the method as the response itself: 

@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 uncustom error handler method. Spring appelle cette méthode lorsqu'une méthode de gestionnaire de demandes lève l'une des exceptions spécifiées.

L'exception interceptée peut être transmise à la méthode sous forme d'argument: 

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

6.3. @ResponseStatus

Nous pouvons spécifier lesdesired HTTP status of the response si nous annotons une méthode de gestionnaire de requêtes avec cette annotation. On peut déclarer le code d'état avec l'argumentcode, ou son alias, l'argumentvalue.

De plus, nous pouvons fournir une raison en utilisant l'argumentreason.

Nous pouvons également l'utiliser avec@ExceptionHandler: 

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

Pour plus d'informations sur l'état de la réponse HTTP, veuillez visiterthis article.

7. Autres annotations Web

Certaines annotations ne gèrent pas directement les requêtes ou réponses HTTP. Dans les sections suivantes, nous présenterons les plus courantes.

7.1. @Controller

Nous pouvons définir un contrôleur Spring MVC avec@Controller. Pour plus d'informations, veuillez visiterour article about Spring Bean Annotations.

7.2. @RestController

Les@RestControllercombines @Controller and @ResponseBody.

Par conséquent, les déclarations suivantes sont équivalentes: 

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

7.3. @ModelAttribute

Avec cette annotation, nous pouvonsaccess elements that are already in the model d'un MVC@Controller, en fournissant la clé de modèle: 

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

Comme pour@PathVariable et@RequestParam, nous n'avons pas à spécifier la clé de modèle si l'argument porte le même nom: 

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

De plus,@ModelAttribute a une autre utilité: si nous annotons une méthode avec elle, Spring feraautomatically add the method’s return value to the model: 

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

Comme avant, nous n'avons pas à spécifier la clé du modèle, Spring utilise le nom de la méthode par défaut: 

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

Avant que Spring n'appelle une méthode de gestionnaire de requêtes, il appelle toutes les méthodes annotées@ModelAttribute de la classe.

Plus d'informations sur@ModelAttribute peuvent être trouvées dansthis article.

7.4. @CrossOrigin

@CrossOriginenables cross-domain communication pour les méthodes de gestion de requêtes annotées: 

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

Si nous marquons une classe avec elle, elle s'applique à toutes les méthodes de gestionnaire de demandes qu'elle contient.

Nous pouvons affiner le comportement CORS avec les arguments de cette annotation.

Pour plus de détails, veuillez visiterthis article.

8. Conclusion

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

Comme d'habitude, les exemples sont disponiblesover on GitHub.

Related