Implementar Spring MVC

 La idea es dar una presentación sencilla de Spring MVC (usamos Spring MVC 2.5), y poder avanzar en ejemplos posteriores.

 Spring MVC es un framework open source que forma parte de Spring Framework. Provee una implementación del patrón Model View Controller (MVC - modelo vista controlador) en java.
 Al ser parte de Spring Framework, es posible utilizar fácilmente las ventajas que éste nos aporta, como ser la Inyección de Dependencia.
 La Inyección de Dependencia hace posible que el framework se encargue del trabajo de incluir las dependencias necesarias por la aplicación, eliminando de las clases la creación de objetos.

 Una explicación muy breve y generalizada del funcionamiento de spring mvc sería:
=> todas las peticiones de los usuarios/clientes pasan por un servlet (Front Controller - Dispatcher Servlet), cuyo comportamiento se configura en un archivo xml. Este servlet envía el request a ser procesado por un 'Controller', el cual encapsula los datos resultantes (Model), y por último se muestran los resultados en una 'vista' (View, la cual puede ser una página, un documento pdf, etc).

 En Spring MVC, la responsabilidad para el manejo de los request realizados por los usuarios, se delegan a controladores (Controllers).
 Se tiene que configurar (mapear) de alguna forma, a qué controlador se envía un request en particular. El encargado de manejar esta tarea es un servlet que funciona como Front Controller, al que se le da el nombre de 'Dispatcher Servlet'.
 Este mapeo entre request y controller se configura mediante el Handler Mapping.
 Spring nos provee de varios Handler Mapping entre los que podemos seleccionar, dependiendo como indicamos el controlador a usar (ej. SimpleUrlHandlerMapping, BeanNameUrlHandlerMapping). Es posible configurar varios de estos tipos de Handler Mapping en la misma aplicación, indicando el orden de preferencia (se usa la propiedad 'order', ej: <property name="order"> <value>1</value> </property> ).

 Las clases que se implementen para realizar la tarea de controlador, tienen que heredar de alguna de las clases Controller que dispone Spring. Estos Controller disponibles, nos facilitan la tarea para diferentes funcionalidades, como pueden ser, un controller orientado a mostrar datos (View Controller), un controller que nos facilita el trabajo con formularios (Form Controller), uno que nos permite el manejo de varias pantallas (Wizard Controller), etc.
 Esta clase no es responsable (directamente) de mostrar en algún medio el resultado. De esto se encarga un tipo de clase 'View'.

 Como parte de la lógica del controller, se puede tener como resultado un grupo de datos que representen la respuesta y que se tendrán que mostrar de alguna forma. Estos datos son conocidos como 'Model'.
 Una vez que el contoller implementado realiza la lógica requerida, se tiene que pasar estos datos a una 'vista' (View), que será lo siguiente a ver por el usuario, donde se mostrará los datos (Model) de la consulta.
 En el Controller se encapsula en una clase de tipo ModelAndView, la combinación del los objetos Model y el objeto View.
 Para mantener un bajo acoplamiento, el Model es un Map de objetos, y normalmente el View se indica por medio de un nombre lógico.

Comenzando con un ejemplo
----------------------------
 A continuación vamos a realizar un ejemplo práctico para ver la configuración de las diferentes partes de spring mvc. Para esto voy a usar el ide NetBeans (http://netbeans.org/), el cuál es sumamente sencillo de instalar, y trae todo lo necesario para las tareas a realizar aquí.
 Es posible usar el ide que cada uno prefiera, incluso es suficiente con tener ant, las bibliotecas necesarias ( http://www.springsource.org/download), y un editor de texto como 'vi', 'emacs', etc. Si tu elección es ant + vi ... vas a tener una tarde un poco más divertida :-)

A 'picar' código ;-)
1) Lo primero es tener un proyecto web.
 Si estamos comenzando con el proyecto, desde NetBeans seleccionamos "nuevo proyecto", en la ventana que se despliega, buscamos en la categoría de proyectos "java web", y en seleccionamos la opción "aplicación web".
 Se completa los pasos siguientes, como ser, dar un nombre y ubicación física al proyecto, seleccionar el server a usar (en mi caso Apache Tomcat 6.0.20), y la versión de java (en mi caso, Java EE 5).
 Por último podemos seleccionar el/los frameworks a incluir en el proyecto. Seleccionamos "Spring Web MVC 2.5", finalizando la creación del proyecto.
Se deja la configuración por defecto que ofrece NetBeans para el nombre del servlet dispatcher ('dispatcher'), y mapping ( *.htm).

1.2) En caso tener un proyecto web en el que queremos agregar el Spring MVC , seleccionamos "propiedades" en el proyecto. En la ventana de propiedades seleccionamos la opción de "Frameworks" -> "Agregar ...", y "Spring Web MVC 2.5" (tener en cuenta que se va a modificar el proyecto, y se agrega configuración el el archivo web.xml.

2) Una vista de la estructura del proyecto.
 Lo que obtenemos al terminar nuestra creación / configuración del proyecto web + spring con NetBeans es una estructura, con los archivos y configuración mínima que necesitamos
 -imagen estructura directorios-

Configuración de web.xml
-----------------------------------------------
 En el archivo WEB-INF/web.xml se declara el nombre del servlet que funciona como Dispatcher (o Front Controller), en este caso 'dispatcher', y se configura
el mapeo de las url's a este servlet.

web.xml (fragmento de la configuración usada para spring-mvc)
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class> 
       org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>
       org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>*.htm</url-pattern>
</servlet-mapping>

 Otra sección importante que podemos ver aquí es el 'contexto de la aplicación', configurado por medio del listener-class 'ContextLoaderListener', y el nombre del archivo a usar -applicationContext.xml-. Aquí se configura, por ejemplo, la inyección de dependencias.

Dispatcher Servlet
-------------------
 Se tiene que crear (en nuestro caso lo hizo NetBeans) el archivo WEB-INF/dispatcher-servlet.xml. El nombre de este archivo esta determinado por el dado en <servlet-name> en el archivo web.xml, seguido de '-servlet'.
 En este archivo configuramos lo necesario por 'dipatcher servlet'. Veamos lo que agrego netbeans en este archivo.

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

 <bean id="urlMapping"   class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 <property name="mappings">
    <props>
        <prop key="index.htm">indexController</prop>
    </props>
 </property>
</bean>

<bean id="viewResolver"     class="org.springframework.web.servlet.view.InternalResourceViewResolver"
     p:prefix="/WEB-INF/jsp/"
     p:suffix=".jsp" />
   <!-- The index controller. -->

<bean name="indexController"    class="org.springframework.web.servlet.mvc.ParameterizableViewController"
    p:viewName="index" />
 </beans>

 Primero se define el manejo del mapeo request con controller. Se usa SimpleUrlHandlerMapping, y se indica que el request a "index.html" se delega al controller con nombre 'indexController'.

 Luego se declara el 'viewResolver', esto es una forma de realizar un mapeo entre vistas (view) y el nombre lógico dado a estas vistas. En el ejemplo, se usa InternalResourceViewResolver. Indicamos el directorio donde se almacenan las vistas por medio de la propiedad 'prefix'. En nuestro proyecto, las vistas (las páginas) están en el directorio '/WEB-INF/jsp' ( p:prefix"/WEB-INF/jsp/" o <property name="prefix" value="/WEB-INF/jsp/" /> ).
 Se indica el tipo de vistas que se usan para mostrarcon la propiedad 'p:suffix', como ser paginas jsp's (p:suffix=".jsp").

 Por último se definió la implementación del controlador. En 'bean name' se indica el nombre del controlador, el cual es igual al usado en la propiedad 'mappings' en el HandlerMapping al comienzo del archivo. Luego se tiene que indicar la clase concreta que implementa el controller.
 Dado que solo vamos a mostrar un mensaje en una página, sin realizar ninguna lógica, se define un controller de spring usado cuando solo se quiere mostrar información: 'ParameterizableViewController'. La vista a la que se tiene que retornar el modelo (model) es 'index' (p:viewName="index").

=> "Traduciendo" esta simple configuración, lo que se dice es: Los request a index.htm, pasarlos al controlador indexController, cuya clase que implementa este controlador es ParameterizableViewController, y retornar el resultado a la pagina "index.jsp", que se encuentra en el directorio /WEB-INF/jsp/ .

Creación del View ( la página index.jsp)
----------------------------------------
 Se tiene que crear la página index.jsp, dentro del directorio /WEB-INF/jsp/ , la cual será mostrada al consultar por index.htm. Si bien netbeans nos ha ahorrado esta tarea, vamos a ingresar un texto mas breve, como ser: "Hola Spring!!"

WEB-INF/jsp/index.jsp
 <%@page contentType="text/html" pageEncoding="UTF-8"%>
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
      "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
     <title>Welcome to Spring Web MVC project</title>
  </head>
  <body>
      <p>Hola Spring!</p>
  </body>
</html>

 Con lo realizado hasta aquí, ya podemos ejecutar la aplicación web, y ver el resultado al teclear en el navegador 'index.htm', en mi caso: http://localhost:8080/TestSpring/index.htm.
 Si el proyecto se ha realizado desde netbeans, tenemos un archivo extra. En la raíz de la aplicación ('Web Pages' en el ide), se creó una página redirect.jsp, la cual solo redirecciona a la url: index.htm
   <%@page contentType="text/html" pageEncoding="UTF-8"%>
   <% response.sendRedirect("index.htm"); %>
y es configurada como página de inicio en web.xml
   <welcome-file-list>
      <welcome-file>redirect.jsp</welcome-file>
   </welcome-file-list>
De esta forma en el navegador solo hacemos: http://localhost:8080/TestSpring

 En el próximo articulo (Formulario con Spring MVC), vamos a modificar un poco el ejemplo, para armar un formulario con validación.
 En este otro artículo (Validar datos de formulario con Spring mvc ), el código con el ejemplo disponible para bajar.

 La documentación de spring es muy completa
http://static.springsource.org/spring/docs/2.5.x/reference
y la pagina de spring downloads : http://www.springsource.org/download