Spring MVC es un framework del ecosistema Spring que permite construir aplicaciones web utilizando el patrón MVC (Modelo-Vista-Controlador). Su principal ventaja radica en el uso extensivo de anotaciones, lo que reduce significativamente la cantidad de configuración XML necesaria y facilita la integración con MyBatis u otros frameworks de acceso a datos.

Dependencias Maven necesarias

Para comenzar a trabajar con Spring MVC, es fundamental agregar las dependencias correspondientes en el archivo pom.xml del proyecto. A continuación se presentan las dependencias esenciales que debe incluir cualquier proyecto Spring MVC moderno.

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.30</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.13</version>
</dependency>

La dependencia servlet-api se marca como provided porque el contenedor de servlets (como Tomcat) ya proporciona esta biblioteca en tiempo de ejecución. La dependencia spring-webmvc contiene todo lo necesario para implementar el patrón MVC, mientras que mybatis permite la integración con la capa de persistencia de datos.

Configuración del Framework

El siguiente fragmento muestra la clase de configuración principal de Spring MVC. Esta clase utiliza la anotación @Configuraton para indicar que cnotiene definiciones de beans, y @ComponentScan para especificar el paquete donde se encuentran los controladores que deben ser escaneados automáticamente.

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.ejemplo.controladores")
public class ConfiguracionWeb {
}

La anotación @ComponentScan sin argumentos adicionales escanea todas las clases anotadas con @Component, @Controller, @Service y @Repository dentro del paquete especificado y sus subpaquetes. Esto elimina la necesidad de definir beans manualmente en archivos XML.

Inicialización del DispatcherServlet

El DispatcherServlet es el componente central de Spring MVC que actúa comoFront Controller: recibe todas las solicitudes HTTP y las distribuye a los controladores correspondientes. La siguiente clase de inicialización configura este servlet de manera programática.

package com.ejemplo.configuracion;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class InicializadorAplicacion extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected WebApplicationContext crearContextoServlet() {
        AnnotationConfigWebApplicationContext contexto = new AnnotationConfigWebApplicationContext();
        contexto.register(ConfiguracionWeb.class);
        return contexto;
    }

    @Override
    protected String[] obtenerMappingsServlet() {
        return new String[]{"/"};
    }

    @Override
    protected WebApplicationContext crearContextoRaiz() {
        AnnotationConfigWebApplicationContext contexto = new AnnotationConfigWebApplicationContext();
        contexto.register(ConfiguracionNegocio.class);
        return contexto;
    }
}

El proceso de inicialización sigue una secuencia bien definida: primero se ejecuta el constructor de la clase de inicialización cuando el servidor de aplicaciones inicia, luego se crea el WebApplicationContext del servlet y finalmente se cargan los controladores. Cada solicitud entrante es analizada para extraer la ruta, buscar el método del controlador correspondiente y ejecutar la lógica de negocio asociada.

Implementación de Controladores

Los controladores son clases que manejan las solicitudes HTTP y generan respuestas. La anotación @Controller marca una clase como componente gestionado por Spring, mientras que @RequestMapping mapea rutas URL a métodos específicos. La anotación @ResponseBody indica que el valor de retorno del método debe enviarse directamente como respuesta HTTP.

package com.ejemplo.controladores;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class ClienteControlador {

    @GetMapping("/consultar")
    @ResponseBody
    public String consultarClientes() {
        System.out.println("Ejecutando consulta de clientes...");
        return "{\"estado\":\"exito\",\"datos\":[]}";
    }

    @PostMapping("/registrar")
    @ResponseBody
    public String registrarCliente() {
        System.out.println("Procesando registro de cliente...");
        return "{\"mensaje\":\"Cliente registrado correctamente\"}";
    }

    @GetMapping("/eliminar")
    @ResponseBody
    public String eliminarCliente() {
        System.out.println("Eliminando cliente...");
        return "{\"resultado\":\"eliminacion_completada\"}";
    }
}

Este ejemplo demuestra las operaciones CRUD básicas que todo controlador Spring MVC debe implementar. El uso de @GetMapping y @PostMapping en lugar de @RequestMapping con el atributo method mejora la legibilidad del código y sigue las convenciones RESTful. Los métodos devuelven cadenas JSON que son interpretadas directamente por el navegador o cliente HTTP que realizó la solicitud.