Controladores Spring MVC

Fundamento teórico del patrón MVC

El patrón MVC (Model-View-Controller) es una arquitectura de software que separa una aplicación en tres componentes principales, cada uno con responsabilidades específicas y bien definidas. Esta separación permite crear aplicaciones más organizadas, mantenibles y escalables.

Los tres componentes del patrón MVC

El patrón MVC divide la aplicación en tres capas interconectadas:

• Model (Modelo): Representa los datos y la lógica de negocio de la aplicación. Se encarga de gestionar la información, las reglas de negocio y el estado de los datos.

• View (Vista): Es la interfaz de usuario que presenta la información al usuario final. Se encarga de mostrar los datos del modelo de forma comprensible y atractiva.

• Controller (Controlador): Actúa como intermediario entre el modelo y la vista. Recibe las peticiones del usuario, procesa la lógica de control y coordina las respuestas.

Flujo de comunicación en MVC

El flujo típico de una aplicación MVC sigue este patrón:

1. El usuario interactúa con la vista (por ejemplo, hace clic en un botón o envía un formulario)

2. La vista envía la petición al controlador correspondiente

3. El controlador procesa la petición y, si es necesario, interactúa con el modelo para obtener o modificar datos

4. El modelo devuelve la información solicitada al controlador

5. El controlador selecciona la vista apropiada y le pasa los datos necesarios

6. La vista renderiza la respuesta final que se presenta al usuario

Ventajas del patrón MVC

La implementación del patrón MVC aporta múltiples beneficios al desarrollo de aplicaciones:

• Separación de responsabilidades: Cada componente tiene una función específica, lo que facilita el mantenimiento y la comprensión del código.

• Reutilización de código: Los componentes pueden reutilizarse en diferentes partes de la aplicación o incluso en otros proyectos.

• Desarrollo en paralelo: Diferentes desarrolladores pueden trabajar simultáneamente en el modelo, la vista y el controlador sin interferir entre sí.

• Facilidad de testing: Al estar separadas las responsabilidades, es más sencillo crear pruebas unitarias para cada componente.

• Flexibilidad: Permite cambiar la implementación de un componente sin afectar a los demás, siempre que se mantenga la interfaz de comunicación.

MVC en aplicaciones web

En el contexto de las aplicaciones web, el patrón MVC se adapta de la siguiente manera:

• Modelo: Gestiona los datos de la aplicación, normalmente interactuando con bases de datos o servicios externos.

• Vista: Genera las páginas HTML, CSS y JavaScript que el navegador renderiza para el usuario.

• Controlador: Procesa las peticiones HTTP (GET, POST, etc.) y determina qué respuesta enviar al cliente.

Esta arquitectura resulta especialmente efectiva en aplicaciones web porque separa claramente la lógica de presentación de la lógica de negocio, permitiendo que los diseñadores trabajen en las vistas mientras los programadores se enfocan en los controladores y modelos.

El patrón MVC establece las bases para construir aplicaciones web robustas y bien estructuradas, proporcionando un marco de trabajo que facilita tanto el desarrollo inicial como el mantenimiento a largo plazo.

Anotaciones esenciales (@Controller, @RequestMapping) introducción básica

Spring Boot utiliza anotaciones para identificar y configurar los componentes de una aplicación MVC de forma sencilla y declarativa. Estas anotaciones eliminan la necesidad de configuraciones XML complejas y permiten que el framework reconozca automáticamente los controladores y sus métodos.

La anotación @Controller

La anotación @Controller marca una clase como controlador en el patrón MVC de Spring. Esta anotación indica al framework que la clase contiene métodos que manejarán peticiones web y devolverán respuestas apropiadas.

import org.springframework.stereotype.Controller;

@Controller
public class HomeController {
    // Métodos del controlador
}

Cuando Spring Boot escanea la aplicación durante el arranque, identifica automáticamente todas las clases marcadas con @Controller y las registra como beans en el contenedor de Spring. Esto significa que no necesitas configurar manualmente cada controlador.

La anotación @Controller es una especialización de @Component, lo que significa que también marca la clase como un componente gestionado por Spring, pero con funcionalidades específicas para el manejo de peticiones web.

La anotación @RequestMapping

La anotación @RequestMapping define qué peticiones HTTP debe manejar un método específico del controlador. Esta anotación puede aplicarse tanto a nivel de clase como a nivel de método, proporcionando flexibilidad en la definición de rutas.

Uso básico a nivel de método:

@Controller
public class HomeController {
    
    @RequestMapping("/inicio")
    public String mostrarInicio() {
        return "inicio"; // Nombre de la vista
    }
}

En este ejemplo, cuando un usuario accede a la URL /inicio, Spring ejecutará el método mostrarInicio() y devolverá la vista llamada "inicio".

Uso a nivel de clase:

@Controller
@RequestMapping("/productos")
public class ProductoController {
    
    @RequestMapping("/lista")
    public String mostrarLista() {
        return "productos/lista";
    }
    
    @RequestMapping("/detalle")
    public String mostrarDetalle() {
        return "productos/detalle";
    }
}

Cuando aplicas @RequestMapping a nivel de clase, todas las rutas de los métodos se combinan con la ruta base. En el ejemplo anterior:

• /productos/lista ejecutará mostrarLista()
• /productos/detalle ejecutará mostrarDetalle()

Especificación de métodos HTTP

Por defecto, @RequestMapping acepta todos los métodos HTTP (GET, POST, PUT, DELETE, etc.). Puedes especificar métodos concretos usando el atributo method:

@Controller
public class FormularioController {
    
    @RequestMapping(value = "/contacto", method = RequestMethod.GET)
    public String mostrarFormulario() {
        return "contacto";
    }
    
    @RequestMapping(value = "/contacto", method = RequestMethod.POST)
    public String procesarFormulario() {
        // Procesar datos del formulario
        return "confirmacion";
    }
}

Este enfoque permite que la misma URL maneje diferentes acciones según el método HTTP utilizado. El método GET muestra el formulario, mientras que el POST procesa los datos enviados.

Anotaciones específicas para métodos HTTP

Spring proporciona anotaciones más específicas que simplifican la definición de métodos HTTP:

@Controller
public class ArticuloController {
    
    @GetMapping("/articulos")
    public String listarArticulos() {
        return "articulos/lista";
    }
    
    @PostMapping("/articulos")
    public String crearArticulo() {
        return "articulos/confirmacion";
    }
}

Las anotaciones @GetMapping y @PostMapping son equivalentes a usar @RequestMapping con el método HTTP correspondiente, pero resultan más legibles y expresivas.

Parámetros en las rutas

Puedes capturar parámetros dinámicos de las URLs utilizando llaves en la ruta y la anotación @PathVariable:

@Controller
public class UsuarioController {
    
    @GetMapping("/usuario/{id}")
    public String mostrarUsuario(@PathVariable String id) {
        // El parámetro 'id' contiene el valor de la URL
        return "usuario/perfil";
    }
}

En este ejemplo, una petición a /usuario/123 pasará el valor "123" al parámetro id del método.

Estas anotaciones forman la base fundamental para crear controladores en Spring Boot, proporcionando una forma clara y concisa de mapear URLs a métodos específicos que manejarán las peticiones de los usuarios.

Estructura de un controlador básico

Un controlador en Spring Boot sigue una estructura predecible que facilita su comprensión y mantenimiento. Conocer esta estructura te permitirá crear controladores organizados y funcionales desde el primer momento.

Anatomía de un controlador

La estructura básica de un controlador incluye varios elementos fundamentales que trabajan en conjunto:

package com.ejemplo.controladores;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class TiendaController {
    
    @GetMapping("/tienda")
    public String mostrarTienda() {
        return "tienda/inicio";
    }
    
    @GetMapping("/productos")
    public String listarProductos(Model model) {
        // Lógica para obtener productos
        model.addAttribute("mensaje", "Bienvenido a nuestra tienda");
        return "productos/lista";
    }
    
    @PostMapping("/buscar")
    public String buscarProductos(@RequestParam String termino, Model model) {
        // Lógica de búsqueda
        model.addAttribute("termino", termino);
        return "productos/resultados";
    }
}

Organización del código

Un controlador bien estructurado organiza sus elementos siguiendo estas convenciones:

Importaciones: Se colocan al inicio del archivo, agrupando primero las de Java estándar, luego las de Spring, y finalmente las específicas del proyecto.

Declaración de clase: La clase lleva la anotación @Controller y utiliza un nombre descriptivo que termine en "Controller".

Métodos públicos: Cada método público representa un endpoint y está anotado con el mapeo correspondiente (@GetMapping, @PostMapping, etc.).

Métodos y sus responsabilidades

Los métodos de un controlador tienen responsabilidades específicas que deben mantenerse simples y enfocadas:

@Controller
public class BibliotecaController {
    
    // Método para mostrar una página simple
    @GetMapping("/biblioteca")
    public String mostrarBiblioteca() {
        return "biblioteca/inicio";
    }
    
    // Método que pasa datos a la vista
    @GetMapping("/libros")
    public String mostrarLibros(Model model) {
        String bibliotecario = "Ana García";
        int totalLibros = 1250;
        
        model.addAttribute("bibliotecario", bibliotecario);
        model.addAttribute("total", totalLibros);
        
        return "biblioteca/libros";
    }
    
    // Método que recibe parámetros del usuario
    @GetMapping("/buscar-libro")
    public String buscarLibro(@RequestParam String titulo, Model model) {
        model.addAttribute("tituloBuscado", titulo);
        model.addAttribute("encontrado", true);
        
        return "biblioteca/resultado";
    }
}

El objeto Model

El objeto Model es fundamental para pasar información desde el controlador hacia la vista. Spring lo inyecta automáticamente cuando lo incluyes como parámetro en tus métodos:

@GetMapping("/perfil")
public String mostrarPerfil(Model model) {
    // Agregar datos simples
    model.addAttribute("nombre", "Carlos Ruiz");
    model.addAttribute("edad", 28);
    model.addAttribute("activo", true);
    
    // La vista podrá acceder a estos datos
    return "usuario/perfil";
}

Cada llamada a addAttribute() añade un dato que estará disponible en la vista con el nombre especificado como primer parámetro.

Manejo de parámetros de entrada

Los controladores pueden recibir datos del usuario a través de parámetros de consulta usando @RequestParam:

@Controller
public class CalculadoraController {
    
    @GetMapping("/calcular")
    public String calcular(@RequestParam int numero1, 
                          @RequestParam int numero2, 
                          Model model) {
        
        int resultado = numero1 + numero2;
        
        model.addAttribute("num1", numero1);
        model.addAttribute("num2", numero2);
        model.addAttribute("suma", resultado);
        
        return "calculadora/resultado";
    }
}

En este ejemplo, una URL como /calcular?numero1=5&numero2=3 pasará los valores 5 y 3 a los parámetros correspondientes.

Valores por defecto y parámetros opcionales

Puedes hacer que los parámetros sean opcionales o tengan valores por defecto:

@GetMapping("/catalogo")
public String mostrarCatalogo(@RequestParam(defaultValue = "1") int pagina,
                             @RequestParam(required = false) String categoria,
                             Model model) {
    
    model.addAttribute("paginaActual", pagina);
    
    if (categoria != null) {
        model.addAttribute("categoriaSeleccionada", categoria);
    }
    
    return "catalogo/productos";
}

Convenciones de nomenclatura

Seguir convenciones consistentes mejora la legibilidad del código:

• Nombres de métodos: Utiliza verbos descriptivos como mostrar, listar, procesar, guardar
• Nombres de vistas: Organiza las vistas en carpetas que reflejen la estructura del controlador
• Atributos del modelo: Usa nombres claros y descriptivos para los datos que pasas a la vista

@Controller
public class EventosController {
    
    @GetMapping("/eventos")
    public String listarEventos(Model model) {
        return "eventos/lista";  // Vista: templates/eventos/lista.html
    }
    
    @GetMapping("/evento/detalle")
    public String mostrarDetalleEvento(@RequestParam int id, Model model) {
        model.addAttribute("eventoId", id);
        return "eventos/detalle";  // Vista: templates/eventos/detalle.html
    }
}

Esta estructura básica proporciona una base sólida para construir controladores más complejos a medida que tu aplicación crezca, manteniendo siempre la claridad y organización del código.