Controladores Spring mediante RequestMapping, GetMapping, PostMapping

En el desarrollo de APIs REST con Spring Boot, una de las tareas más frecuentes es crear controladores que gestionen las peticiones HTTP. Para ello, Spring nos proporciona una serie de anotaciones que nos permiten enlazar métodos Java con URLs específicas y sus tipos de petición (GET, POST, PUT, DELETE, etc.). Estas anotaciones son fundamentales para definir el comportamiento de nuestras rutas.

 

En el post de hoy vamos a repasar las principales anotaciones disponibles para manejar peticiones HTTP en Spring Boot: @RequestMapping, @GetMapping, @PostMapping, @PutMapping y @DeleteMapping. Explicaremos cuándo se usa cada una, qué ventajas ofrece, y veremos un ejemplo básico por cada caso. Al final, te mostraremos un ejemplo CRUD práctico utilizando las cinco tags.

¿Qué es la anotación @RequestMapping?

 

La anotación @RequestMapping es la más genérica y versátil. Permite mapear una ruta a uno o varios métodos HTTP (GET, POST, etc.), aunque no está limitada a un único tipo. Se puede usar tanto a nivel de clase como de método.

 

🔎 Ejemplo básico

 

@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {
    @RequestMapping(method = RequestMethod.GET)
    public String obtenerUsuarios() {
        return "Listado de usuarios";
    }
}
 

Ventajas

• Muy flexible: permite configurar múltiples métodos HTTP.

• Admite parámetros adicionales como "headers", "params", "produces", etc.
  

 Inconvenientes

• Código algo más complejo comparado con las anotaciones específicas.

• Menos legible que @GetMapping o @PostMapping, cuando únicamente se gestiona un tipo de método.

 

¿Qué es la anotación @GetMapping?

 

El tag @GetMapping es una especialización de @RequestMapping, en este caso diseñada exclusivamente para manejar peticiones HTTP GET. Es la anotación más común en APIs REST cuando queremos obtener datos. A continuación de la anotación, entre paréntesis debe indicarse la ruta HTTP de acceso al método mapeado mediante el atributo "path".

 

🔎 Ejemplo básico

 

@GetMapping(path="/usuarios")

public String listarUsuarios() {

    return "Lista de usuarios";

}

 

Ventajas

• Más clara y legible para operaciones de lectura.

• Reducción de código frente a @RequestMapping.

Inconvenientes

• Sólo sirve para peticiones GET (no es polivalente como @RequestMapping).

 

 

¿Qué es la anotación @PostMapping?

 

La anotación @PostMapping se utiliza para definir métodos que gestionen peticiones HTTP POST, comúnmente empleadas para crear nuevos recursos.

 

🔎 Ejemplo básico

 

@PostMapping(path="/usuarios")
public String crearUsuario(@RequestBody Usuario usuario) {
    return "Usuario creado: " + usuario.getNombre();
}
 
 

Ventajas

• Ideal para crear registros.

• Integración directa con @RequestBody para recibir JSON.

• Mediante los atributos "consumes" y "produces" se puede especificar el tipo de formato de entrada y de salida del PostMapping (si no se especifica nada, por defecto los formatos son JSON).:

@PostMapping(consumes= {MediaType.APPLICATION_JSON_VALUE,MediaType.APPLICATION_XML_VALUE},

            produces= {MediaType.APPLICATION_JSON_VALUE,MediaType.APPLICATION_XML_VALUE})

 Inconvenientes

• Al igual que @GetMapping, es específica y no admite otros tipos de métodos.

 

 

¿Qué es la anotación @PutMapping?

 

La anotación @PutMapping se usa para actualizar recursos existentes. Las peticiones PUT deben incluir, como parámetro de entrada, el recurso completo que se desea actualizar.

 

🔎 Ejemplo básico

 

@PutMapping(path="/usuarios/{id}")
public String actualizarUsuario(@PathVariable Long id, @RequestBody Usuario usuario) {
    return "Usuario actualizado con ID: " + id;
}
 

Ventajas

• Adecuada para operaciones de actualización de datos.

• Código claro y coherente con las convenciones REST.

Inconvenientes

• Requiere enviar toda la entidad, incluso si sólo se modifica una parte.

 

 

¿Qué es @DeleteMapping?

 

Como resulta evidente por su nomenclatura, esta anotación gestiona las peticiones HTTP DELETE, que se usan para eliminar recursos.

 

🔎 Ejemplo básico

 

@DeleteMapping(path="/usuarios/{id}")
public String eliminarUsuario(@PathVariable Long id) {
    return "Usuario eliminado con ID: " + id;
}
 

Ventajas

• Semánticamente clara: borra recursos.

• Integración sencilla con @PathVariable

Inconvenientes

• No permite enviar cuerpo de datos (no de forma estándar, aunque técnicamente es posible).

 

 

Ejemplo CRUD combinado usando todas las anotaciones

 

Una vez vistas las anotaciones anteriores, ahora vamos a construir un pequeño ejemplo de un controlador REST completo para la gestión de usuarios, aplicando los cinco tipos revisados.

 

➕ Clase entidad "Usuario"

 

public class Usuario {
    private Long id;
    private String nombre;
    private String email;
    // Getters y setters
}

 

➕ Controlador de la aplicación

A continuación, se implementaría el controlador haciendo uso de la entidad "Usuario" y de los diferentes tipos de anotaciones para peticiones HTTP que hemos visto en el post.

 

@RestController

@RequestMapping("/api/usuarios")

public class UsuarioController {

    // GET: Listar todos los usuarios

    @GetMapping

    public List<Usuario> listarUsuarios() {

        return List.of(new Usuario(1L, "Ana", "ana@example.com"));

    }

    // GET: Obtener usuario por ID

    @GetMapping("/{id}")

    public Usuario obtenerUsuario(@PathVariable Long id) {

        return new Usuario(id, "Luis", "luis@example.com");

    }

    // POST: Crear nuevo usuario

    @PostMapping

    public String crearUsuario(@RequestBody Usuario usuario) {

        return "Usuario creado: " + usuario.getNombre();

    }

    // PUT: Actualizar usuario existente

    @PutMapping("/{id}")

    public String actualizarUsuario(@PathVariable Long id, @RequestBody Usuario usuario) {

        return "Usuario actualizado con ID: " + id;

    }

    // DELETE: Eliminar usuario

    @DeleteMapping("/{id}")

    public String eliminarUsuario(@PathVariable Long id) {

        return "Usuario eliminado con ID: " + id;

    }

}

 

Este controlador implementa las operaciones básicas de un CRUD (Crear, Leer, Actualizar y Eliminar) de forma clara y sencilla, aprovechando la configuración que proporcionan las anotaciones específicas de Spring Web.

 

 

Conclusión

 

Las anotaciones @RequestMapping, @GetMapping, @PostMapping y el resto de ellas son fundamentales para definir rutas REST en Spring Boot. Mientras que @RequestMapping ofrece máxima flexibilidad, las anotaciones específicas aportan claridad y codificación directa.

 

Usar cada una de forma adecuada no sólo mejora la legibilidad del código, sino que también refuerza las buenas prácticas REST. En aplicaciones reales, estas anotaciones son la piedra angular para construir APIs limpias, escalables y bien organizadas. Dominar su uso te permite crear controladores robustos, mantener un código más limpio y ofrecer una API más clara a quien la consuma. 

 

¡Nos vemos en el siguiente post!

Saludos.