Métodos GET en controladores MVC

Intermedio
SpringBoot
SpringBoot
Actualizado: 12/06/2025

¡Desbloquea el curso de SpringBoot completo!

IA
Ejercicios
Certificado
Entrar

Mira la lección en vídeo

Accede al vídeo completo de esta lección y a más contenido exclusivo con el Plan Plus.

Desbloquear Plan Plus

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

Guarda tu progreso

Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.

Progreso guardado
Asistente IA
Ejercicios
Iniciar sesión gratis

Más de 25.000 desarrolladores ya confían en CertiDevs

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.

Aprendizajes de esta lección de SpringBoot

  • Comprender la función y sintaxis básica de la anotación @GetMapping en controladores MVC.
  • Aprender a mapear múltiples rutas y organizar controladores con @RequestMapping.
  • Saber cómo pasar datos dinámicos a las vistas mediante el objeto Model.
  • Utilizar @PathVariable y @RequestParam para capturar datos de la URL y parámetros de consulta.
  • Implementar validaciones básicas y combinar PathVariables con RequestParams para crear URLs dinámicas y funcionales.

Completa este curso de SpringBoot y certifícate

Únete a nuestra plataforma de cursos de programación y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.

Asistente IA

Resuelve dudas al instante

Ejercicios

Practica con proyectos reales

Certificados

Valida tus conocimientos

Más de 25.000 desarrolladores ya se han certificado con CertiDevs

⭐⭐⭐⭐⭐
4.9/5 valoración