Anotación @RequestMapping: La anotación @RequestMapping es fundamental en aplicaciones web Spring, ya que asigna peticiones HTTP a métodos de controladores en MVC y REST.

Uso básico de Request Mapping En Spring MVC, el RequestDispatcher (bajo el Front Controller) enruta las peticiones HTTP entrantes hacia los métodos del controlador. Durante la configuración, es necesario definir estas asignaciones mediante la anotación @RequestMapping. Esta anotación puede aplicarse a nivel de clase y/o a nivel de método. A nivel de clase, establece un patrón base para las rutas, y a nivel de método, se especifican los endpoints detallados. Ejemplo con ambos niveles:

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping("/")
    String obtener() {
        return "Respuesta desde obtener";
    }
    @RequestMapping("/detalle")
    String detalle() {
        return "Respuesta desde detalle";
    }
}

En este caso, las peticiones a /servicio/ se manejan por obtener(), y las de /servicio/detalle por detalle().

Manejo de múltiples URIs Es posible asignar varias rutas a un solo método usando una lista de valores en @RequestMapping.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(value = {
        "",
        "/seccion",
        "seccion*",
        "vista/*,**/mensaje"
    })
    String multiplesRutas() {
        return "Respuesta desde multiples rutas.";
    }
}

Las siguientes URLs serán procesadas por multiplesRutas():

localhost:8080/servicio
localhost:8080/servicio/
localhost:8080/servicio/seccion
localhost:8080/servicio/seccionabc
localhost:8080/servicio/vista/
localhost:8080/servicio/vista/vista

@RequestParam junto con @RequestMapping @RequestParam vincula parámetros de la petición con los del método. Puede tener o no un valor explícito.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(value = "/buscar")
    String buscarPorId(@RequestParam("id") String idUsuario) {
        System.out.println("El ID es " + idUsuario);
        return "Parámetro con valor explícito";
    }
    @RequestMapping(value = "/consultar")
    String consultar(@RequestParam String idUsuario) {
        System.out.println("El ID es " + idUsuario);
        return "Parámetro sin valor explícito";
    }
}

El atributo defaultValue proporciona un valor predeterminado cuando el parámetro está vacío.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(value = "/nombre")
    String obtenerNombre(@RequestParam(value = "persona", defaultValue = "Ana") String nombrePersona) {
        return "Nombre del parámetro: " + nombrePersona;
    }
}

Si "persona" está vacío, se usará "Ana".

Atributos de @RequestMapping:

method: Este atributo define el método HTTP (GET, POST, PUT, DELETE, PATCH). Por defecto, las peticiones son GET.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(method = RequestMethod.GET)
    String obtener() {
        return "Respuesta GET";
    }
    @RequestMapping(method = RequestMethod.POST)
    String enviar() {
        return "Respuesta POST";
    }
    @RequestMapping(method = RequestMethod.PUT)
    String actualizar() {
        return "Respuesta PUT";
    }
    @RequestMapping(method = RequestMethod.DELETE)
    String eliminar() {
        return "Respuesta DELETE";
    }
    @RequestMapping(method = RequestMethod.PATCH)
    String parchear() {
        return "Respuesta PATCH";
    }
}

produces: Especifica el tipo de medio y la codificación de caracteres de la respuesta.

@Controller
@RequestMapping(value = "/mascotas/{idMascota}", produces = "application/json;charset=UTF-8")
@ResponseBody
public Mascota obtenerMascota(@PathVariable String idMascota) {
    // Implementación omitida
}

consumes: Indica el Content-Type que acepta el método para la petición.

@Controller
@RequestMapping(value = "/mascotas", method = RequestMethod.POST, consumes = "application/json")
public void agregarMascota(@RequestBody Mascota mascota) {
    // Implementación omitida
}

headers: Restringe el mapeo basado en cabeceras de la petición.

@Controller
@RequestMapping("/propietarios/{idPropietario}")
public class ControladorMascota {
    @RequestMapping(value = "/mascotas", method = RequestMethod.GET, headers = "Referer=http://www.ejemplo.com/")
    public void buscarMascota(@PathVariable String idPropietario) {
        // Implementación omitida
    }
}

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(value = "/cabecera", headers = "content-type=text/plain")
    String conCabecera() {
        return "Mapeo con cabecera específica";
    }
}

params: Este atributo refina el mapeo según los parámetros de la petición. Permite que múltiples métodos manejen la misma URL con diferentes parámetros.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @RequestMapping(value = "/obtener", params = {"idUsuario=10"})
    String obtenerPorId(@RequestParam("idUsuario") String id) {
        return "Obtenido con parámetro idUsuario=10: " + id;
    }
    @RequestMapping(value = "/obtener", params = {"idUsuario=20"})
    String obtenerPorIdDiferente(@RequestParam("idUsuario") String id) {
        return "Obtenido con parámetro idUsuario=20: " + id;
    }
}

Anotaciones compuestas: Desde Spring 4.3, existen anotaciones compuestas como @GetMapping, @PostMapping, etc., que simplifican el uso de @RequestMapping con method específico. Mejoran la legibilidad y reducen configuración.

@RestController
@RequestMapping("/servicio")
public class ControladorDemo {
    @GetMapping("/recurso")
    public @ResponseBody ResponseEntity<String> obtenerRecurso() {
        return new ResponseEntity<>("Respuesta GET", HttpStatus.OK);
    }
    @PostMapping("/recurso")
    public @ResponseBody ResponseEntity<String> crearRecurso() {
        return new ResponseEntity<>("Respuesta POST", HttpStatus.OK);
    }
    @PutMapping("/recurso")
    public @ResponseBody ResponseEntity<String> actualizarRecurso() {
        return new ResponseEntity<>("Respuesta PUT", HttpStatus.OK);
    }
    @DeleteMapping("/recurso")
    public @ResponseBody ResponseEntity<String> eliminarRecurso() {
        return new ResponseEntity<>("Respuesta DELETE", HttpStatus.OK);
    }
    @PatchMapping("/recurso")
    public @ResponseBody ResponseEntity<String> parchearRecurso() {
        return new ResponseEntity<>("Respuesta PATCH", HttpStatus.OK);
    }
}

Estas anotaciones compuestas son la práctica recomendada por su claridad y simplicidad.