• Spring Web Annotations (artículo actual) • Spring Boot Annotations
• Anotaciones de programación de primavera
• Anotaciones de datos de primavera
• Anotaciones de Spring Bean
1. Información general
En este tutorial, exploraremos las anotaciones de Spring Web del paquete org.springframework.web.bind.annotation .
2. @RequestMapping
En pocas palabras, @RequestMapping marca los métodos del controlador de solicitudes dentro de las clases @Controller ; se puede configurar usando:
- ruta, o sus alias, nombre y valor: a qué URL está asignado el método
- método: métodos HTTP compatibles
- params: filtra las solicitudes según la presencia, ausencia o valor de los parámetros HTTP
- encabezados: filtra las solicitudes en función de la presencia, ausencia o valor de los encabezados HTTP
- consume: qué tipos de medios puede consumir el método en el cuerpo de la solicitud HTTP
- produce: qué tipos de medios puede producir el método en el cuerpo de respuesta HTTP
Aquí hay un ejemplo rápido de cómo se ve:
@Controller class VehicleController { @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET) String home() { return "home"; } }Podemos proporcionar configuraciones predeterminadas para todos los métodos de controlador en una clase @Controller si aplicamos esta anotación en el nivel de clase. La única excepción es la URL que Spring no anulará con la configuración de nivel de método, pero agrega las dos partes de la ruta.
Por ejemplo, la siguiente configuración tiene el mismo efecto que la anterior:
@Controller @RequestMapping(value = "/vehicles", method = RequestMethod.GET) class VehicleController { @RequestMapping("/home") String home() { return "home"; } }Además, @GetMapping , @PostMapping , @PutMapping , @DeleteMapping y @PatchMapping son variantes diferentes de @RequestMapping con el método HTTP ya configurado en GET, POST, PUT, DELETE y PATCH respectivamente.
Están disponibles desde la versión Spring 4.3.
3. @RequestBody
Pasemos a @RequestBody , que asigna el cuerpo de la solicitud HTTP a un objeto :
@PostMapping("/save") void saveVehicle(@RequestBody Vehicle vehicle) { // ... }La deserialización es automática y depende del tipo de contenido de la solicitud.
4. @PathVariable
A continuación, hablemos de @PathVariable .
Esta anotación indica que un argumento de método está vinculado a una variable de plantilla de URI . Podemos especificar la plantilla URI con la anotación @RequestMapping y vincular un argumento de método a una de las partes de la plantilla con @PathVariable .
Podemos lograr esto con el nombre o su alias, el argumento de valor :
@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable("id") long id) { // ... }Si el nombre de la parte en la plantilla coincide con el nombre del argumento del método, no tenemos que especificarlo en la anotación:
@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable long id) { // ... }Además, podemos marcar una variable de ruta como opcional estableciendo el argumento requerido en falso:
@RequestMapping("/{id}") Vehicle getVehicle(@PathVariable(required = false) long id) { // ... }5. @RequestParam
Usamos @RequestParam para acceder a los parámetros de solicitud HTTP :
@RequestMapping Vehicle getVehicleByParam(@RequestParam("id") long id) { // ... }Tiene las mismas opciones de configuración que la anotación @PathVariable .
Además de esas configuraciones, con @RequestParam podemos especificar un valor inyectado cuando Spring encuentra ningún valor o un valor vacío en la solicitud. Para lograr esto, tenemos que establecer el argumento defaultValue .
Proporcionar un valor predeterminado establece implícitamente required en false:
@RequestMapping("/buy") Car buyCar(@RequestParam(defaultValue = "5") int seatCount) { // ... }Además de los parámetros, hay otras partes de la solicitud HTTP a las que podemos acceder: cookies y encabezados . Podemos acceder a ellos con las anotaciones @CookieValue y @RequestHeader respectivamente.
Podemos configurarlos de la misma forma que @RequestParam .
6. Anotaciones de manejo de respuestas
En las siguientes secciones, veremos las anotaciones más comunes para manipular las respuestas HTTP en Spring MVC.
6.1. @ResponseCuerpo
Si marcamos un método de manejo de solicitudes con @ResponseBody, Spring trata el resultado del método como la respuesta en sí :
@ResponseBody @RequestMapping("/hello") String hello() { return "Hello World!"; }Si anotamos una clase @Controller con esta anotación, todos los métodos de manejo de solicitudes la usarán.
6.2. @ExceptionHandler
Con esta anotación, podemos declarar un método de manejo de errores personalizado . Spring llama a este método cuando un método de manejo de solicitudes arroja alguna de las excepciones especificadas.
La excepción detectada se puede pasar al método como argumento:
@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.
Para obtener más detalles, visite este artículo.
8. Conclusión
En este artículo, vimos cómo podemos manejar solicitudes y respuestas HTTP con Spring MVC.
Como de costumbre, los ejemplos están disponibles en GitHub.
Siguiente » Anotaciones de Spring Boot « Anotaciones de Spring Core anteriores