Anotaciones de Spring: @RequestMapping y sus variantes

A

Introducción

Si has leído algo sobre Spring, desarrolló un proyecto, o incluso estaba interesado remotamente en cómo funciona, se le presentó la @RequestMapping anotación.

Es una de las anotaciones básicas en Spring que asigna solicitudes HTTP (URL) con métodos:

@RequestMapping("/")
public void helloWorld() {
    return "Hello World!";
}

Nos permite ejecutar métodos y fragmentos de código cada vez que el usuario final llega a un punto final con una solicitud HTTP. En este caso, es una asignación de raíz simple que devuelve la cadena “¡Hola mundo!” cuando se alcanza el punto final raíz.

La anotación @RequestMapping

los @RequestMapping la anotación en sí ofrece más de lo que se muestra en el ejemplo anterior. Cubramos brevemente algunos de los casos de uso básicos de la anotación.

@RequestMapping alcances

El mapeo se puede asignar a nivel de clase o de método:

@RequestMapping("/admin")
public class AdminController() {
    @RequestMapping("/adminPanel")
    public String adminPanel() {
        return "adminPanel.html";
    }

    @RequestMapping("/statistics")
    public String statistics() {
        return "statistics.html";
    }
}

Aquí el /admin El mapeo se asigna a nivel de clase, mientras que el /adminPanel y /statistics las asignaciones se asignan a los métodos. El mapeo a nivel de clase se utilizará como prefijo para todos estos mapeos a nivel de método: /admin/adminPanel y /admin/statistics.

De esta manera, podemos segregar nuestra aplicación en partes lógicas. Por ejemplo, toda la lógica relacionada con el administrador estará detrás del /admin muro, al que solo pueden ingresar los usuarios administradores. Todos los usuarios que no sean administradores serán redirigidos al lado del cliente de la aplicación.

Varias asignaciones por método

Si es necesario, podemos asignar múltiples asignaciones a un solo método, como:

@RequestMapping("/", "/index", "/home")
public void helloWorld() {
    return "Hello World!";
}

Si llega a cualquiera de estos puntos finales, helloWorld() método de manejo de nuestra solicitud.

Métodos de solicitud

El atributo más común utilizado es el method atributo que nos permite especificar y acotar el método de solicitud que maneja nuestro método (GET, POST, DELETE, etc.):

@RequestMapping(value = "/addProduct", method = RequestMethod.POST)
public String addProductPost(@ModelAttribute("product") Product product) {
    // some code
}

Si no especificamos un método de solicitud, el método de solicitud predeterminado es GET.

Solicitar encabezados

Podemos especificar aún más el mapeo definiendo uno o más encabezados. En este caso, el helloWorld() El método manejará la solicitud si su content-type es text/plain o text/html:

@RequestMapping(value = "/header", headers = {"content-type=text/plain", "content-type=text/html"})
String helloWorld() {
    return "Hello World!";
}

Variables de ruta

Muchos sitios web se basan en variables de ruta para mostrar un producto, página, perfil, etc. específicos al usuario final, como example.com/viewProduct/324, dónde 324 es el ID del producto:

@RequestMapping("/viewProduct/{productId}")
public String viewProduct(@PathVariable int productId, Model model) {
    Product product = productService.getProductById(productId);
    model.addAttribute("product", product);

    return "viewProduct";
}

Aquí, después del mapeo, encerramos la variable de ruta con llaves ({}) y asignar ese valor a nuestro productId. los @PathVariable la anotación se encarga de esto por nosotros. Entonces, podemos encontrar el producto a través de nuestro ProductService y mostrarlo al usuario final.

Por supuesto, el mismo enfoque se puede utilizar para otras variables como:

@RequestMapping("/users/{username}")
public String viewUser(@PathVariable("username") String username) {
    Profile profile = profileService.getProfileByUsername(username);
    // rest of the code
}

Solicitar parámetros

Muy similar a las variables de ruta, muchas aplicaciones se basan en parámetros de solicitud para alterar el estado de la página. Podemos usar el @RequestParam anotación para vincular un parámetro de solicitud a una variable:

@RequestMapping("/login")
public String login(@RequestParam(value = "error", required = false) String error, @RequestParam(value = "logout", required = false) String logout, Model model) {

    if (error != null) {
        model.addAttribute("error", "Wrong username or password!");
    }
    if (logout != null) {
        model.addAttribute("msg", "You have successfully logged out!");
    }
    return "login";
}

Producible y consumible

Utilizando la @RequestMapping anotación, también podemos producir o consumir tipos de medios. Para producir un tipo de medio como “JSON”, puede utilizar el produces atributo junto al @ResponseBody anotación, mientras que para consumir un tipo de medio puede utilizar la consumes atributo:

@RequestMapping("/annotations")
public class SomeController {
    @RequestMapping(value = "/produce", produces = {"application/json"})
    @ResponseBody
    String produces() {
        return "Here's how you use the 'produces' attribute";
    }

    @RequestMapping(value = "/consume", consumes = {"application/JSON", "application/XML"})
    String consume() {
        return "Here's how you use a 'consume' attribute";
    }
}

Variantes de @RequestMapping compuestas

Una única asignación puede corresponder a diferentes métodos si nos aseguramos de que no haya ambigüedad en cuanto a qué método debe manejar qué versión de la asignación.

Podemos tener varios métodos con el mismo mapeo si su método de solicitud es diferente:

@RequestMapping("/hello")
public String hello() {
    return "hello";
}

@RequestMapping(value = "/hello", method = RequestMethod.POST)
public String helloPost() {
    return "hello post";
}

@RequestMapping(value = "/hello", method = RequestMethod.PUT)
public String helloGet() {
    return "hello put";
}

@RequestMapping(value = "/hello", method = RequestMethod.DELETE)
public String helloDelete() {
    return "hello delete";
}

Este mismo método tiene 4 variaciones diferentes:

  • Predeterminado (GET)
  • ENVIAR
  • PONER
  • ELIMINAR

Con más variaciones, la legibilidad del código se reduce y, honestamente, esto ya es detallado para un mapeo simple. Las asignaciones de solicitudes en aplicaciones más grandes pueden volverse muy complejas y complicadas, y queremos que sean más simples y legibles.

Para ello, se nos presentan varias anotaciones nuevas, las @RequestMapping variantes:

  • @GetMapping
  • @PostMapping
  • @DeleteMapping
  • @PutMapping
  • @PatchMapping

Hay literalmente versiones de acceso directo para las asignaciones anteriores donde @PostMapping("/hello") es igual a @RequestMapping(value="/hello", RequestMethod.POST).

Al observar más de cerca cómo se definen estas anotaciones, podemos tener una idea clara de lo que hacen:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {

    @AliasFor(annotation = RequestMapping.class)
    String name() default "";

    @AliasFor(annotation = RequestMapping.class)
    String[] value() default {};

    @AliasFor(annotation = RequestMapping.class)
    String[] path() default {};

    @AliasFor(annotation = RequestMapping.class)
    String[] params() default {};

    @AliasFor(annotation = RequestMapping.class)
    String[] headers() default {};

    @AliasFor(annotation = RequestMapping.class)
    String[] produces() default {};
}

Dicho esto, podemos reescribir los ejemplos anteriores:

@GetMapping
public String hello() {
    return "hello";
}

@PostMapping
public String helloPost() {
    return "hello post";
}

@PutMapping
public String helloGet() {
    return "hello put";
}

@DeleteMapping
public String helloDelete() {
    return "hello delete";
}

Como esta es una forma más simple, más legible y más nueva de escribir anotaciones, generalmente se prefiere escribirlas así. Si es necesario, puede definir cualquier otro atributo, como el value, params, pathetc.

Conclusión

@RequestMapping es una anotación por excelencia en el marco de Spring que nos permite mapear solicitudes HTTP con métodos que deseamos ejecutar.

A partir de Spring 4.3, se recomienda y se recomienda utilizar los accesos directos creados para esta anotación para obtener una base de código más legible y menos detallada.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad