Spring @RequestMapping Novas anotações de atalho

1. Visão geral

Primavera 4.3. introduced algumas anotações compostas de nível de método muito interessantes para suavizar o tratamento@RequestMapping em projetos Spring MVC típicos.

Neste artigo, aprenderemos como usá-los de maneira eficiente.

2. Novas Anotações

Normalmente, se quisermos implementar o manipulador de URL usando a anotação@RequestMapping tradicional, seria algo assim:

@RequestMapping(value = "/get/{id}", method = RequestMethod.GET)

A nova abordagem permite encurtar isso simplesmente para:

@GetMapping("/get/{id}")

O Spring atualmente suporta cinco tipos de anotações embutidas para lidar com diferentes tipos de métodos de solicitação HTTP de entrada que sãoGET, POST, PUT, DELETEePATCH. Essas anotações são:

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

A partir da convenção de nomenclatura, podemos ver que cada anotação deve lidar com o respectivo tipo de método de solicitação de entrada, ou seja, @GetMapping é usado para lidar com o tipo de método de solicitaçãoGET,@PostMapping é usado para lidar com o tipo de método de solicitaçãoPOST, etc.

3. Como funciona

Todas as anotações acima já estão anotadas internamente com@RequestMappinge o respectivo valor no elementomethod.

Por exemplo, se olharmos o código-fonte da anotação@GetMapping, podemos ver que já está anotado comRequestMethod.GET da seguinte maneira:

@Target({ java.lang.annotation.ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = { RequestMethod.GET })
public @interface GetMapping {
    // abstract codes
}

Todas as outras anotações são criadas da mesma maneira, ou seja, @PostMapping é anotado comRequestMethod.POST,@PutMapping é anotado comRequestMethod.PUT, etc.

O código-fonte completo das anotações está disponívelhere.

4. Implementação

Vamos tentar usar essas anotações para construir um aplicativo REST rápido.

Observe que, uma vez que usaríamos Maven para construir o projeto e Spring MVC para criar nosso aplicativo, precisamos adicionar as dependências necessárias nopom.xml:


    org.springframework
    spring-webmvc
    4.3.6.RELEASE

A versão mais recente despring-webmvc está disponível emCentral Maven Repository.

Agora, precisamos criar o controlador para mapear a URL de solicitação recebida. Dentro deste controlador, usaríamos todas essas anotações uma por uma.

4.1. @GetMapping

@GetMapping("/get")
public @ResponseBody ResponseEntity get() {
    return new ResponseEntity("GET Response", HttpStatus.OK);
}

@GetMapping("/get/{id}")
public @ResponseBody ResponseEntity
  getById(@PathVariable String id) {
    return new ResponseEntity("GET Response : "
      + id, HttpStatus.OK);
}

4.2. @PostMapping

@PostMapping("/post")
public @ResponseBody ResponseEntity post() {
    return new ResponseEntity("POST Response", HttpStatus.OK);
}

4.3. @PutMapping

@PutMapping("/put")
public @ResponseBody ResponseEntity put() {
    return new ResponseEntity("PUT Response", HttpStatus.OK);
}

4.4. @DeleteMapping

@DeleteMapping("/delete")
public @ResponseBody ResponseEntity delete() {
    return new ResponseEntity("DELETE Response", HttpStatus.OK);
}

4.5. @PatchMapping

@PatchMapping("/patch")
public @ResponseBody ResponseEntity patch() {
    return new ResponseEntity("PATCH Response", HttpStatus.OK);
}

Pontos a serem observados:

Usamos as anotações necessárias para lidar com os métodos HTTP de entrada apropriados com URI. Por exemplo,@GetMapping para lidar com URI “/ get”,@PostMapping para lidar com URI “/ post” e assim por diante __
Como estamos criando um aplicativo baseado em REST, retornamos uma sequência constante (exclusiva para cada tipo de solicitação) com 200 códigos de resposta para simplificar o aplicativo. Nós usamos a anotação@ResponseBody do Spring neste caso.
Se tivéssemos que lidar com qualquer variável de caminho de URL, poderíamos simplesmente fazer isso de uma maneira muito menor que costumávamos fazer no caso de usar@RequestMapping.

5. Testando o aplicativo

Para testar o aplicativo, precisamos criar alguns casos de teste usando o JUnit. UsaríamosSpringJUnit4ClassRunner para iniciar a aula de teste. Criaríamos cinco casos de teste diferentes para testar cada anotação e cada manipulador que declaramos no controlador.

Vamos simplificar o caso de teste de exemplo de@GetMapping:

@Test
public void giventUrl_whenGetRequest_thenFindGetResponse()
  throws Exception {

    MockHttpServletRequestBuilder builder = MockMvcRequestBuilders
      .get("/get");

    ResultMatcher contentMatcher = MockMvcResultMatchers.content()
      .string("GET Response");

    this.mockMvc.perform(builder).andExpect(contentMatcher)
      .andExpect(MockMvcResultMatchers.status().isOk());

}

Como podemos ver, estamos esperando uma string constante “GET Response“, assim que atingirmos a URLGET “/ get”.

Agora, vamos criar o caso de teste para testar@PostMapping:

@Test
public void givenUrl_whenPostRequest_thenFindPostResponse()
  throws Exception {

    MockHttpServletRequestBuilder builder = MockMvcRequestBuilders
      .post("/post");

    ResultMatcher contentMatcher = MockMvcResultMatchers.content()
      .string("POST Response");

    this.mockMvc.perform(builder).andExpect(contentMatcher)
      .andExpect(MockMvcResultMatchers.status().isOk());

}

Da mesma forma, criamos o restante dos casos de teste para testar todos os métodos HTTP.

Como alternativa, sempre podemos usar qualquer cliente REST comum, por exemplo, PostMan, RESTClient etc, para testar nosso aplicativo. Nesse caso, precisamos ter um pouco de cuidado ao escolher o tipo de método HTTP correto ao usar o cliente restante. Caso contrário, geraria um status de erro 405.

6. Conclusão

Neste artigo, tivemos uma introdução rápida aos diferentes tipos de atalhos@RequestMapping para desenvolvimento rápido da web usando a estrutura Spring MVC tradicional. We can utilize these quick shortcuts to create a clean code base.

Como sempre, você pode encontrar o código-fonte deste tutorial emGithub project.

TOC

Spring @RequestMapping Novas anotações de atalho