Tutorial SpringBoot: Métodos GET en controladores MVC

Métodos @GetMapping en MVC

Los métodos @GetMapping representan la forma más directa de manejar peticiones HTTP GET en Spring Boot MVC. Esta anotación simplifica significativamente la configuración de rutas y permite crear controladores web de manera intuitiva y eficiente.

En el contexto de aplicaciones web tradicionales, los métodos GET se utilizan principalmente para mostrar páginas, formularios y contenido que el usuario puede visualizar. A diferencia de los controladores REST que devuelven datos JSON, los controladores MVC con @GetMapping están diseñados para renderizar vistas y proporcionar una experiencia web completa.

Sintaxis básica de @GetMapping

La anotación @GetMapping se coloca directamente sobre los métodos del controlador para mapear rutas específicas. Su sintaxis es clara y expresiva:

@Controller
public class HomeController {
    
    @GetMapping("/")
    public String inicio() {
        return "index";
    }
    
    @GetMapping("/contacto")
    public String mostrarContacto() {
        return "contacto";
    }
}

Cada método anotado con @GetMapping debe devolver un String que representa el nombre de la vista a renderizar. Spring Boot buscará automáticamente el archivo correspondiente en el directorio de plantillas configurado.

Configuración de rutas múltiples

Un aspecto útil de @GetMapping es su capacidad para mapear múltiples rutas al mismo método. Esto resulta especialmente práctico cuando queremos que diferentes URLs muestren el mismo contenido:

@Controller
public class ProductoController {
    
    @GetMapping({"/productos", "/catalogo", "/tienda"})
    public String mostrarProductos() {
        return "productos/lista";
    }
    
    @GetMapping({"/producto/nuevo", "/producto/crear"})
    public String formularioNuevoProducto() {
        return "productos/formulario";
    }
}

Esta flexibilidad permite crear URLs amigables y mantener compatibilidad con diferentes convenciones de nomenclatura sin duplicar código.

Organización jerárquica con @RequestMapping

Para mantener una estructura organizada en aplicaciones más grandes, es común combinar @GetMapping con @RequestMapping a nivel de clase:

@Controller
@RequestMapping("/admin")
public class AdminController {
    
    @GetMapping("/dashboard")
    public String dashboard() {
        return "admin/dashboard";
    }
    
    @GetMapping("/usuarios")
    public String listarUsuarios() {
        return "admin/usuarios";
    }
    
    @GetMapping("/configuracion")
    public String configuracion() {
        return "admin/config";
    }
}

En este ejemplo, todas las rutas quedan prefijadas con "/admin", creando URLs como "/admin/dashboard" y "/admin/usuarios". Esta aproximación mejora la organización del código y facilita el mantenimiento.

Paso de datos a las vistas

Los métodos @GetMapping pueden enriquecer las vistas con datos utilizando el objeto Model. Este mecanismo permite que las plantillas accedan a información dinámica:

@Controller
public class BlogController {
    
    @GetMapping("/blog")
    public String mostrarBlog(Model model) {
        List<String> articulos = Arrays.asList(
            "Introducción a Spring Boot",
            "Creando tu primera aplicación web",
            "Mejores prácticas en MVC"
        );
        
        model.addAttribute("articulos", articulos);
        model.addAttribute("titulo", "Mi Blog Personal");
        
        return "blog/index";
    }
    
    @GetMapping("/acerca")
    public String acercaDe(Model model) {
        model.addAttribute("autor", "Juan Pérez");
        model.addAttribute("experiencia", "5 años");
        
        return "acerca";
    }
}

El objeto Model actúa como un contenedor de datos que se transfiere automáticamente a la vista. Las plantillas pueden entonces acceder a estos atributos para mostrar contenido dinámico.

Manejo de rutas con patrones

@GetMapping también soporta patrones de rutas que permiten crear URLs más flexibles y expresivas:

@Controller
public class CategoriaController {
    
    @GetMapping("/categoria/*")
    public String mostrarCategoria() {
        return "categoria/general";
    }
    
    @GetMapping("/archivo/**")
    public String mostrarArchivo() {
        return "archivo/navegador";
    }
}

El patrón con asterisco simple (*) coincide con un segmento de ruta, mientras que el doble asterisco (**) coincide con múltiples segmentos. Esta funcionalidad resulta útil para crear sistemas de navegación dinámicos.

Integración con el ciclo de vida de Spring

Los métodos @GetMapping se integran perfectamente con el ecosistema de Spring, permitiendo la inyección de dependencias y el uso de otros componentes del framework:

@Controller
public class TiendaController {
    
    private final ProductoService productoService;
    
    public TiendaController(ProductoService productoService) {
        this.productoService = productoService;
    }
    
    @GetMapping("/tienda")
    public String mostrarTienda(Model model) {
        List<String> productosDestacados = productoService.obtenerDestacados();
        model.addAttribute("productos", productosDestacados);
        
        return "tienda/principal";
    }
}

Esta integración permite que los controladores accedan a servicios de negocio, repositorios y otros beans de Spring, manteniendo una arquitectura limpia y bien estructurada.

PathVariables y RequestParams en MVC

Los controladores MVC necesitan frecuentemente acceder a información específica de las URLs y parámetros de consulta para personalizar las respuestas. Spring Boot proporciona dos mecanismos principales para capturar estos datos: @PathVariable para extraer valores directamente de la ruta URL y @RequestParam para obtener parámetros de consulta.

Estos mecanismos permiten crear aplicaciones web dinámicas donde el contenido se adapta según los valores proporcionados en la URL, facilitando la navegación y la experiencia del usuario.

Uso de @PathVariable

La anotación @PathVariable permite extraer valores directamente de segmentos específicos de la URL. Esto resulta especialmente útil para crear rutas que incluyen identificadores o categorías:

@Controller
public class PerfilController {
    
    @GetMapping("/usuario/{nombre}")
    public String mostrarPerfil(@PathVariable String nombre, Model model) {
        model.addAttribute("nombreUsuario", nombre);
        model.addAttribute("titulo", "Perfil de " + nombre);
        
        return "usuario/perfil";
    }
    
    @GetMapping("/categoria/{tipo}")
    public String mostrarCategoria(@PathVariable String tipo, Model model) {
        model.addAttribute("categoriaActual", tipo);
        
        return "categoria/detalle";
    }
}

En estos ejemplos, las llaves en la ruta ({nombre}, {tipo}) definen las variables que se capturarán. Spring Boot automáticamente extrae estos valores y los inyecta en los parámetros del método correspondiente.

PathVariables con tipos específicos

Spring Boot puede convertir automáticamente los valores de PathVariable a diferentes tipos de datos, no solo String:

@Controller
public class ProductoController {
    
    @GetMapping("/producto/{id}")
    public String mostrarProducto(@PathVariable Long id, Model model) {
        model.addAttribute("productoId", id);
        model.addAttribute("mensaje", "Mostrando producto número: " + id);
        
        return "producto/detalle";
    }
    
    @GetMapping("/descuento/{porcentaje}")
    public String aplicarDescuento(@PathVariable Integer porcentaje, Model model) {
        model.addAttribute("descuento", porcentaje);
        model.addAttribute("textoDescuento", porcentaje + "% de descuento aplicado");
        
        return "promocion/descuento";
    }
}

Esta conversión automática simplifica el manejo de datos numéricos y otros tipos, eliminando la necesidad de conversiones manuales en el código del controlador.

PathVariables múltiples

Los métodos pueden capturar múltiples PathVariables simultáneamente, permitiendo URLs más complejas y expresivas:

@Controller
public class TiendaController {
    
    @GetMapping("/tienda/{categoria}/{subcategoria}")
    public String mostrarSubcategoria(@PathVariable String categoria, 
                                    @PathVariable String subcategoria, 
                                    Model model) {
        model.addAttribute("categoria", categoria);
        model.addAttribute("subcategoria", subcategoria);
        model.addAttribute("ruta", categoria + " > " + subcategoria);
        
        return "tienda/subcategoria";
    }
    
    @GetMapping("/pedido/{clienteId}/producto/{productoId}")
    public String mostrarPedido(@PathVariable Long clienteId, 
                               @PathVariable Long productoId, 
                               Model model) {
        model.addAttribute("cliente", clienteId);
        model.addAttribute("producto", productoId);
        
        return "pedido/detalle";
    }
}

Esta aproximación permite crear jerarquías de navegación claras y URLs semánticamente significativas.

Uso de @RequestParam

La anotación @RequestParam captura parámetros de consulta que aparecen después del símbolo ? en la URL. Estos parámetros son opcionales por naturaleza y permiten filtrar o personalizar el contenido:

@Controller
public class BusquedaController {
    
    @GetMapping("/buscar")
    public String buscar(@RequestParam String termino, Model model) {
        model.addAttribute("terminoBusqueda", termino);
        model.addAttribute("mensaje", "Buscando: " + termino);
        
        return "busqueda/resultados";
    }
    
    @GetMapping("/filtrar")
    public String filtrarProductos(@RequestParam String precio, 
                                  @RequestParam String marca, 
                                  Model model) {
        model.addAttribute("filtros", "Precio: " + precio + ", Marca: " + marca);
        
        return "productos/filtrados";
    }
}

Los parámetros de consulta se acceden mediante URLs como /buscar?termino=laptop o /filtrar?precio=alto&marca=samsung.

RequestParams opcionales y valores por defecto

Spring Boot permite definir parámetros opcionales con valores por defecto, mejorando la flexibilidad de los controladores:

@Controller
public class ListadoController {
    
    @GetMapping("/productos")
    public String listarProductos(@RequestParam(defaultValue = "1") Integer pagina,
                                 @RequestParam(defaultValue = "10") Integer tamaño,
                                 Model model) {
        model.addAttribute("paginaActual", pagina);
        model.addAttribute("elementosPorPagina", tamaño);
        model.addAttribute("inicio", (pagina - 1) * tamaño + 1);
        
        return "productos/listado";
    }
    
    @GetMapping("/noticias")
    public String mostrarNoticias(@RequestParam(required = false) String categoria,
                                 Model model) {
        if (categoria != null) {
            model.addAttribute("filtroCategoria", categoria);
            model.addAttribute("titulo", "Noticias de " + categoria);
        } else {
            model.addAttribute("titulo", "Todas las noticias");
        }
        
        return "noticias/lista";
    }
}

El parámetro required = false hace que el parámetro sea opcional, mientras que defaultValue proporciona un valor cuando no se especifica en la URL.

Combinando PathVariables y RequestParams

Los controladores pueden combinar ambos mecanismos para crear funcionalidades más sofisticadas:

@Controller
public class CatalogoController {
    
    @GetMapping("/catalogo/{categoria}")
    public String mostrarCatalogo(@PathVariable String categoria,
                                 @RequestParam(defaultValue = "nombre") String ordenar,
                                 @RequestParam(defaultValue = "asc") String direccion,
                                 Model model) {
        model.addAttribute("categoria", categoria);
        model.addAttribute("ordenamiento", ordenar);
        model.addAttribute("direccionOrden", direccion);
        model.addAttribute("titulo", "Catálogo de " + categoria);
        
        return "catalogo/categoria";
    }
    
    @GetMapping("/usuario/{id}/configuracion")
    public String configuracionUsuario(@PathVariable Long id,
                                      @RequestParam(required = false) String seccion,
                                      Model model) {
        model.addAttribute("usuarioId", id);
        model.addAttribute("seccionActiva", seccion != null ? seccion : "general");
        
        return "usuario/configuracion";
    }
}

Esta combinación permite URLs como /catalogo/electronica?ordenar=precio&direccion=desc que son tanto semánticamente claras como funcionalmente flexibles.

Validación básica de parámetros

Spring Boot proporciona validación automática de tipos y puede manejar errores de conversión de manera elegante:

@Controller
public class ValidacionController {
    
    @GetMapping("/edad/{años}")
    public String verificarEdad(@PathVariable Integer años, Model model) {
        if (años < 18) {
            model.addAttribute("mensaje", "Acceso restringido para menores de edad");
            model.addAttribute("tipo", "restriccion");
        } else {
            model.addAttribute("mensaje", "Bienvenido, tienes " + años + " años");
            model.addAttribute("tipo", "bienvenida");
        }
        
        return "validacion/edad";
    }
    
    @GetMapping("/rango")
    public String mostrarRango(@RequestParam Integer min,
                              @RequestParam Integer max,
                              Model model) {
        if (min > max) {
            model.addAttribute("error", "El valor mínimo no puede ser mayor que el máximo");
            return "error/parametros";
        }
        
        model.addAttribute("rangoMin", min);
        model.addAttribute("rangoMax", max);
        
        return "datos/rango";
    }
}

Esta validación en el controlador permite manejar casos especiales y proporcionar retroalimentación apropiada al usuario cuando los parámetros no cumplen con los criterios esperados.