Anotaciones @Controller, @RequestMapping, @GetMapping, @PostMapping

Hoy vamos a desglosar las anotaciones más importantes de Spring MVC: @Controller, @RequestMapping, @GetMapping, y @PostMapping. Vas a aprender cómo funcionan, para qué sirven y qué problemas te ayudan a resolver. Y claro, escribiremos ejemplos de código simples pero útiles que podrás usar en tu proyecto.

¿Qué es @Controller?

El controlador (Controller) en Spring MVC es el elemento que recibe peticiones HTTP, las procesa y devuelve datos (JSON, XML, texto) o vistas (páginas HTML). Para entenderlo mejor, imagina que el controlador es el camarero de un restaurante. Recoge el pedido (petición HTTP), lo pasa a la cocina (servicios) y te trae el plato listo (respuesta).

La anotación @Controller le dice a Spring: «Oye, esta clase es un controlador. ¡Pásale aquí las peticiones que correspondan!»

Ejemplo de uso de @Controller:

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String sayHello() {
        return "hello"; // El valor devuelto es el nombre de la vista (por ejemplo, hello.html)
    }
}

Cuando el usuario abra http://localhost:8080/hello, Spring llamará al método sayHello y devolverá la vista hello.html.

¿Qué es @RequestMapping?

@RequestMapping es una anotación que se usa para el enrutamiento (routing). Asocia una URL con un método de tu controlador. Ejemplo sencillo: si entras en la URL /products, Spring te llevará al método anotado con @RequestMapping("/products").

Ejemplo:

@Controller
@RequestMapping("/api/v1")
public class ProductController {

    @RequestMapping("/products")
    public String getAllProducts() {
        return "products"; // Este es el nombre de la plantilla HTML que se debe renderizar
    }
}

Ahora el acceso a este método será a través de la ruta http://localhost:8080/api/v1/products.

¿Cómo funciona @RequestMapping?

La lógica funciona así:

1. Spring comprueba todos los métodos de los controladores que están anotados con @RequestMapping.
2. Si la URL de la petición coincide con la especificada en la anotación, se invoca el método correspondiente.

@RequestMapping soporta:

• Métodos HTTP: GET, POST, PUT, DELETE y otros.
• Parámetros: puedes configurar rutas más complejas.

Anotaciones específicas: @GetMapping y @PostMapping

Hasta la primavera de 2016 (Spring 4.3), @RequestMapping era la anotación universal que podía manejar cualquier método HTTP. Pero con Spring 4.3 aparecieron anotaciones más cómodas: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, etc.

Las usamos para indicar explícitamente qué método HTTP gestiona cada handler.

@GetMapping

Esta anotación maneja peticiones HTTP de tipo GET. Las peticiones GET se usan normalmente para obtener información del servidor.

Ejemplo:

@GetMapping("/products")
public String getAllProducts() {
    return "product_list"; // Devuelve la plantilla "product_list.html"
}

Ahora puedes obtener la lista de productos entrando en http://localhost:8080/products.

@PostMapping

Anotación para manejar POST. Los POST se usan para enviar datos al servidor (por ejemplo, envío de formularios).

Ejemplo:

@PostMapping("/products")
@ResponseBody
public String createProduct(@RequestParam String name, @RequestParam Double price) {
    // Lógica para crear un nuevo producto
    return "Producto " + name + " creado con precio " + price;
}

Ahora puedes enviar datos usando un POST con una herramienta como Postman.

Diferencias entre @RequestMapping, @GetMapping y @PostMapping

Es mejor usar @GetMapping y @PostMapping para indicar explícitamente qué tipo de peticiones HTTP soporta un método.

Práctica: crear un controlador con enrutamiento

Vamos a escribir un ejemplo breve que devuelva datos dinámicos.

Controlador:

@Controller
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    @ResponseBody
    public String getUserById(@PathVariable("id") Long userId) {
        // En una app real los datos se podrían sacar de la base de datos
        return "Usuario con ID = " + userId;
    }

    @PostMapping
    @ResponseBody
    public String createUser(@RequestParam String name, @RequestParam Integer age) {
        // En una app real aquí iría la lógica para guardar el usuario
        return "Usuario " + name + " creado. Edad: " + age;
    }
}

¿Qué pasa aquí?

1. El método getUserById maneja GET. La URL puede ser, por ejemplo: /users/5. Usamos @PathVariable para extraer el id de la URL.
2. El método createUser maneja POST. Los datos se envían mediante los parámetros name y age.

¿Cómo probarlo?

• Para GET: abre el navegador e introduce http://localhost:8080/users/5.
• Para POST: usa Postman o cURL:

  
  curl -X POST "http://localhost:8080/users" -d "name=John&age=30"
  

Resultado:

• GET: Usuario con ID = 5
• POST: Usuario John creado. Edad: 30

Errores típicos y cómo solucionarlos

1. Error: "HTTP 404 Not Found"

Causa: Indicaste una URL o método incorrecto en el navegador/Postman. Asegúrate de usar la ruta correcta.

2. Error: "Ambiguous Mapping"

Causa: Has creado dos métodos con la misma ruta y el mismo método HTTP. Por ejemplo:

@GetMapping("/duplicate")
public String method1() {
    return "method1";
}

@GetMapping("/duplicate")
public String method2() {
    return "method2";
}

Solución: asegúrate de que las rutas sean únicas.

3. Error: "Missing Request Parameters"

Si un método espera parámetros @RequestParam y no los envías, obtendrás ese error. Asegúrate de enviar todos los parámetros.

Aplicación práctica

Estas anotaciones se usan por todas partes en apps web. Ya sea que desarrolles un sitio e-commerce o un REST API para una app móvil, conocer @Controller, @RequestMapping, @GetMapping y @PostMapping hará tu trabajo más fácil y efectivo.

Ahora sabes cómo configurar rutas, manejar peticiones y devolver respuestas en tus aplicaciones Spring. Y lo que viene es trabajar con parámetros de petición y más práctica!