TOC

Anotações do Spring Web

Anotações do Spring Web

1. Visão geral

Neste tutorial, exploraremos as anotações do Spring Web do pacoteorg.springframework.web.bind.annotation.

2. @RequestMapping

Simplificando,@RequestMappingmarks request handler methods dentro das classes@Controller; ele pode ser configurado usando:

  • path, ou seus aliases,name, evalue: para qual URL o método está mapeado

  • Métodos HTTP compatíveis commethod:

  • params: filtra solicitações com base na presença, ausência ou valor dos parâmetros HTTP

  • headers: filtra as solicitações com base na presença, ausência ou valor dos cabeçalhos HTTP

  • consumes: quais tipos de mídia o método pode consumir no corpo da solicitação HTTP

  • produces: quais tipos de mídia o método pode produzir no corpo da resposta HTTP

Aqui está um exemplo rápido de como é: 

@Controller
class VehicleController {

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

Podemos fornecerdefault settings for all handler methods in a @Controller class se aplicarmos essa anotação no nível da classe. O únicoexception is the URL which Spring won’t override com configurações de nível de método, mas anexa as duas partes do caminho.

Por exemplo, a seguinte configuração tem o mesmo efeito que a acima: 

@Controller
@RequestMapping(value = "/vehicles", method = RequestMethod.GET)
class VehicleController {

    @RequestMapping("/home")
    String home() {
        return "home";
    }
}

Além disso,@GetMapping,@PostMapping,@PutMapping,@DeleteMapping e@PatchMapping são variantes diferentes de@RequestMapping com o método HTTP já definido para GET, POST, PUT, DELETE e PATCH respectivamente.

Estes estão disponíveis desde o lançamento do Spring 4.3.

3. @RequestBody

Vamos passar para@RequestBody - que mapeiabody of the HTTP request to an object: 

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

A desserialização é automática e depende do tipo de conteúdo da solicitação.

4. @PathVariable

A seguir, vamos falar sobre@PathVariable.

Esta anotação indica que amethod argument is bound to a URI template variable. Podemos especificar o modelo de URI com a anotação@RequestMapping e vincular um argumento de método a uma das partes do modelo com@PathVariable.

Podemos conseguir isso comname ou seu alias, o argumentovalue: 

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

Se o nome da parte no modelo corresponder ao nome do argumento do método, não precisamos especificá-lo na anotação: 

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

Além disso, podemos marcar uma variável de caminho opcional definindo o argumentorequired como falso: 

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

5. @RequestParam

Usamos@RequestParam paraaccessing HTTP request parameters: 

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

Possui as mesmas opções de configuração da anotação@PathVariable.

Além dessas configurações, com@RequestParam, podemos especificar um valor injetado quando o Spring encontra nenhum valor ou um valor vazio na solicitação. Para conseguir isso, temos que definir o argumentodefaultValue.

Fornecer um valor padrão define implicitamenterequired parafalse: 

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

Além dos parâmetros, existemother HTTP request parts we can access: cookies and headers. Podemos acessá-los com as anotações@CookieValue and @RequestHeader respectivamente.

Podemos configurá-los da mesma forma que@RequestParam.

6. Anotações de manipulação de resposta

Nas próximas seções, veremos as anotações mais comuns para manipular respostas HTTP no Spring MVC.

6.1. @ResponseBody

Se marcarmos um método de manipulador de solicitação com@ResponseBody,Spring treats the result of the method as the response itself: 

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

Se anotarmos uma classe@Controller com essa anotação, todos os métodos do manipulador de solicitação a usarão.

6.2. @ExceptionHandler

Com esta anotação, podemos declarar acustom error handler method. O Spring chama esse método quando um método manipulador de solicitação lança qualquer uma das exceções especificadas.

A exceção capturada pode ser transmitida ao método como um argumento: 

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

6.3. @ResponseStatus

Podemos especificardesired HTTP status of the response se anotarmos um método de tratamento de solicitação com esta anotação. Podemos declarar o código de status com o argumentocode, ou seu alias, o argumentovalue.

Além disso, podemos fornecer uma razão usando o argumentoreason.

Também podemos usá-lo junto com@ExceptionHandler: 

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

Para obter mais informações sobre o status da resposta HTTP, visitethis article.

7. Outras anotações da Web

Algumas anotações não gerenciam solicitações ou respostas HTTP diretamente. Nas próximas seções, apresentaremos os mais comuns.

7.1. @Controller

Podemos definir um controlador Spring MVC com@Controller. Para obter mais informações, visiteour article about Spring Bean Annotations.

7.2. @RestController

O@RestControllercombines @Controller and @ResponseBody.

Portanto, as seguintes declarações são equivalentes: 

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

7.3. @ModelAttribute

Com esta anotação, podemosaccess elements that are already in the model de um MVC@Controller,, fornecendo a chave do modelo: 

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

Como com@PathVariablee@RequestParam, não temos que especificar a chave do modelo se o argumento tiver o mesmo nome: 

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

Além disso,@ModelAttribute tem outro uso: se anotarmos um método com ele, Spring iráautomatically add the method’s return value to the model: 

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

Como antes, não temos que especificar a chave do modelo, Spring usa o nome do método por padrão: 

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

Antes de Spring chamar um método manipulador de solicitação, ele invoca todos os métodos anotados@ModelAttribute na classe.

Mais informações sobre@ModelAttribute podem ser encontradas emthis article.

7.4. @CrossOrigin

@CrossOriginenables cross-domain communication para os métodos de manipulador de solicitação anotados: 

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

Se marcarmos uma classe com ela, ela se aplicará a todos os métodos manipuladores de solicitação nela.

Podemos ajustar o comportamento do CORS com os argumentos desta anotação.

Para obter mais detalhes, visitethis article.

8. Conclusão

Neste artigo, vimos como podemos lidar com solicitações e respostas HTTP com o Spring MVC.

Como de costume, os exemplos estão disponíveisover on GitHub.

Related