El funcionamiento interno de Spring MVC se basa en una secuencia coordinada de componentes que gestionan cada etapa de la solicitud HTTP. Este proceso centralizado asegura la separación de responsabilidades entre el control, la lógica de negocio y la presentación.

Solicitud Cliente 
↓
DispatcherServlet (Controlador Frontal)
↓
Consulta HandlerMapping → Encuentra el Handler correcto
↓
Genera HandlerExecutionChain (incluye Interceptors)
↓
DispatcherServlet delega a HandlerAdapter
↓
HandlerAdapter invoca al Controlador específico
↓
Controlador ejecuta lógica y devuelve ModelAndView
↓
HandlerAdapter transmite los datos a DispatcherServlet
↓
DispatcherServlet pasa los datos a ViewResolver
↓
ViewResolver resuelve la vista final (por ejemplo, JSP, Thymeleaf)
↓
Renderer renderiza la respuesta HTTP para el usuario.

1. El cliente envía una petición al DispatcherServlet.
2. Este solicita a un HandlerMapping determinar qué controlador manejará la ruta.
3. Se obtiene la cadena de ejecución (objetos y posibles interceptores).
4. La implementación seleccionada delega la operación a un HandlerAdapter.
5. El adaptador ajusta la llamada según el tipo de objeto Controlador.
6. El Controlador procesa la solicitud y construye el modelo.
7. Se retorna el ModelAndView con los datos y nombre de la vista.
8. El ViewResolver transforma el nombre lógico en una vista real.
9. Finalmente, se escribe la respuesta HTTP.

Declaración de Anotaciones Principales

Las anotaciones permiten registrar los componentes sin depender exclusivamente de configuraciones XML pesadas. La combinación de @Controller y @RequestMapping establece el vínculo entre la URL y la lógica.

• @Contorller: Marca la clase como candidata para inyección en el contexto de Spring.
• @RequestMapping: Asocia URLs específicas a métodos o clases.

Es fundamental entender la jerarquía de rutas. El nivel superior se define en la clase, mientras que el método define la acción específica.

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod;

@Controller @RequestMapping("/gestion") public class GestionUsuarioController {

/**
 * Ruta: GET /gestion/inicio
 */
@RequestMapping(value = "/inicio", method = RequestMethod.GET)
public String mostrarInicio() {
    System.out.println("Ejecutando flujo inicial...");
    return "/vistas/home"; 
}

/**
 * Requiere parámetro opcional 'status'
 */
@RequestMapping(value = "/estado", params = "status")
public String verificarEstado(String status) {
    return "/vistas/resumen";
}

}

</div>En esta configuración, `value` define la ruta relativa, `method` limita el protocolo HTTP y `params` añade condiciones a los parámetros de consulta.

Gestión de Configuración XML y Namespace
========================================

Para habilitar las funcionalidades de Spring Web, es necesario definir los namespaces correspondientes en el archivo de configuración principal. Esto permite usar etiquetas como `<context:...>` y `<mvc:...>`.

Aunque las URIs de los schemas parecen direcciones web, el framework utiliza un mecanismo interno para resolverlas localmente si no hay conexión externa. Esto se logra mediante:

1. Archivos XSD empaquetados dentro de las dependencias JAR de Spring.
2. Un mapa de resolución local llamado `spring.schemas` que dirige peticiones de schema a recursos del Classpath.

Ejemplo de cabecera estándar para integración completa:

<div>```
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/mvc 
           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

Una vez definido el namespace del contexto, es necesario especificar el paquete base donde Spring buscará automáticamente las clases anotadas.

Por cnovención, el módulo spring-mvc debe escanear solo los controladores, mientras que el contexto principal gestiona modelos y servicios para evitar ciclos de dependencia.

<context:property-placeholder location="classpath:config-db.properties"/>

<context:component-scan base-package="com.dev.proyecto.service"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>

</div>Se pueden utilizar filtros específicos (`include-filter` o `exclude-filter`) para refinar la búsqueda y mantener arquitecturas limpias.

Resolución de Vistas
====================

Los controladores devuelven cadenas de texto lógicas que deben traducirse a recursos físicos. El componente encargado de esto es el `ViewResolver`. Por defecto, Spring usa un `InternalResourceViewResolver` en su configuración estándar.

Configurando prefijos y sufijos globales, se evita repetir la ruta completa de los archivos en cada método del controlador.

<div>```
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/vistas/" />
    <property name="suffix" value=".jsp" />
</bean>

También es posible redirigir internamente o externamente usando prefijos especiales:
forward: (recurso servidor)
redirect: (nueva URL cliente)

Estrategias de Respuesta HTTP

El framework permite diferentes formas de devolver información dependiendo si el destino es una página web o una API. Estas se categorizan principalmente en navegación por vistas y retorno de datos.

1. Navegación por Vistas

La forma más común es retornar un String. Este valor se combina con el resolutor de vistas para dibujar la interfaz.

Cuando se desarrollan interfaces asíncronas o APIs REST, no es deseable una vista JSP. Se utilizan objetos nativos de Servlet o respuestas condicionadas por anotaciones.

Para escribir directamente en el cuerpo de la respuesta:

Si el controlador retorna un objeto personalizado con @ResponseBody, se requiere un gestor para convertir dicho objeto a formato JSON. Spring facilita esto integrando librerías como Jackson.

Existen dos opciones principales:

1. Manual: Inyectar el parser y convertir explícitamente en el código.
2. Automático: Activar la configuración de mensajes convertibles.

La solución moderna y robusta implica habilitar el soporte de anotaciones en el XML. Esto carga automáticamente el mapeador de solicitudes y configura los conversores de mensajes necesarios.

Componentes Esenciales del Ciclo