Este Articulo forma parte de la guia creada en este sitio sobre Spring MVC.
Por definición:
"Como definir acciones en grupo en un solo controlador"
El MultiActionController en Spring nos permite controlar varias peticiones realizadas al servidor en una misma clase controlador, podemos interpretar, como su propio nombre indica, que un MultiActionController no es mas que un conjunto de Spring Controllers en una misma clase.
Lo primero es crear nuestra clase que extendera de la clase MultiActionController, luego establecemos los métodos de la clase, igual que crearíamos el handleRequest en un Controller, pero implementando todos los que queramos dándoles el nombre que nos interese.
Para nuestro ejemplo vamos a crear una controladora que responsa a las operaciones CRUD por ejemplo
- AddCustomer
- deleteCustomer
- updateCustomer
- listCustomer
Como en todo los ejemplo solo utilizaremos una vista dado que no es el objeto de estudio, y por supuesto lo único que buscamos registrar es nuestro paso por los métodos del controlador y su interacción con una vista, motivo por lo que la logica de cada uno de estos métodos sera básico simplemente pasando un mensaje a la vista.
Buenisimo !!! ahora como hacemos esto. jajajaja
Pero como trabajamos con MVC
Inicia con un Request
Finaliza con Response
Cuando se envía una solicitud a la Spring Framework MVC la siguiente secuencia de los acontecimientos suceden.
El DispatcherServlet recibe por primera vez la solicitud.
La consulta a la DispatcherServlet Handler Mapping e invoca el controlador asociado a la solicitud.
El proceso regulador de la solicitud llamando a los métodos apropiados de servicio y devuelve un objeto ModeAndView a la DispatcherServlet.
El objeto ModeAndView contiene los datos del modelo y el nombre de vista.
El DispatcherServlet envía el nombre de la vista a un ViewResolver para encontrar la visión real de invocar.
Ahora, el DispatcherServlet pasará el modelo de objetos a la vista para hacer que el resultado.
La vista con la ayuda de los datos del modelo hará que el resultado de vuelta al usuario.
Paso 0: Definir nuestro proyecto y archivo POOM.
Definamos nuestro proyecto
El siguiente paso es definir nuestro archivo pom para la gestión de dependencias.
pom.xml: definiremos todas las librerías necesarias para trabajar con nuestro ejemplo.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.company</groupId>
<artifactId>mvc_MultiActionController</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>mvc_MultiActionController Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<spring.version>3.0.5.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
</dependencies>
<build>
<finalName>mvc_MultiActionController</finalName>
</build>
</project>
En esta ocacion no utilizaremos ninguna libreria rara, solo spring y las taglib para trabajar con JSP un poquito.
Paso 1: Definir el dispacher
web.xml: Primero debemos modificar nuestro archivo web.xml de base para definir el dispachservlet de spring y la locacion del spring bean configuration file.
<web-app id="WebApp_ID" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Spring Web MVC Application</display-name>
<servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>
En este archivo lo que realizamos es mendiante
Luego mediante
Mediante
lo que pusimos en servlet-name + "-servlet.xml", por consiguiente si tuviera una definición como <servlet-name>mvc-dispatcher</servlet-name> la busqueda del archivo se realizaria a mvc-dispatcher-servlet.xml.
Por ultimo tendremos la definición de nuestro ContextLoaderListener es el encargado de inicializar todo el contexto del framework para el funcionamiento de la mecanica MVC.
Paso 2: Definir nuestro controlador
Para nuestro ejemplo vamos a definir 1 controlador muy simples con el cual vamos a trabajar para que pueda reconocer diferentes metodos desde spring bean configuration.
Como lo unico que intentamos es demostrar nuestros paso por los metodos definidos en el controlador, vamos a crear los diferentes metodos crud en la clase y la logica simplemente sera pasar un mensaje a la vista que indique que paso por el metodo.
Los métodos crud son estos y la definición del nombre te garantizo que lo vas a entender mucho mas adelante.
- testaddCustomer
- testdeleteCustomer
- testupdateCustomer
- testlistCustomer
Nota: ModelAndView es un objeto que vale la pena mirarlo mas a fondo por que tiene muchos metodos y formas de crearlo de acuerdo a nuestra necesidad.
En nuestro ejemplo en el contructor le mandamos el nombre de la vista JSP "PaginaRetorno" y luego con el metodo addObjetc le agregamos un valor a key de nombre msg. Esto no es magia de seguro nuestra vista PaginaRetorno debe contener la clave a la que hacemos referencia por que de caso contrario no va tirar en Tucumano "un loco que haces esto a lo que haces referencia no existe en la vista".
Nota son controladores muy simple solo pasamos a la vista en cada metodo una leyenda que corresponde a la operacion a la que atendimos.
com.company.controlador.CustomerController.java: definimos nuestro controlador.
package com.company.controlador;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
public class CustomerController extends MultiActionController{
public ModelAndView testaddCustomer(HttpServletRequest request,
HttpServletResponse response) throws Exception {
return new ModelAndView("PaginaRetorno", "msg","add() method");
}
public ModelAndView testdeleteCustomer(HttpServletRequest request,
HttpServletResponse response) throws Exception {
return new ModelAndView("PaginaRetorno", "msg","delete() method");
}
public ModelAndView testupdateCustomer(HttpServletRequest request,
HttpServletResponse response) throws Exception {
return new ModelAndView("PaginaRetorno", "msg","update() method");
}
public ModelAndView testlistCustomer(HttpServletRequest request,
HttpServletResponse response) throws Exception {
return new ModelAndView("PaginaRetorno", "msg","list() method");
}
}
Paso 3: Definir nuestro Vista
src/main/webapp/WEB-INF/pages/PaginaRetorno.jsp: Es simplemente la vista que utilizamos para el ejemplo.
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<body>
<h1>Spring MVC Ejemplo</h1>
<h2>${msg}</h2>
</body>
</html>
Primero que nada Vamos a usar la Librería Estandar JSP (JSP Standard Tag Library - JSTL) por lo que primero tenemos que comenzar incluyéndolas en nuestro pom.XML de caso contrario nuestro jsp se va romper por todos lados, las librerías usadas son:
Ojo ya que estamos hablemos de una buena practica en construir archivos JSP como la utilizacion de las taglibs va ser de moneda corriente en todo los jsp con los que vamos a trabajar, una buena practica es definir un archivo include.jsp como cabecera que tendra lo que sea necesario en todos los jsp que vamos a crear.
ejemplo de un include.jsp
<%@ page session="false"%>
una pagina ejemplo jsp que utilice esta buena practica seria
<%@ include file="/WEB-INF/views/include.jsp" %>
Pero de verdad nos fuimos por las ramas, de vuelta con nuestro ejemplo encontramos la clave ${msg} que es a la cual hicimos referencia desde nuestros controladores. Te das cuenta que esto no es magia!! para todo una linea de código.
Paso 4: Definir nuestro Spring Bean Configuration File
src/main/webapp/WEB-INF/mvc-dispacher-servlet.xml: me voy a contradecir un poco en mis comentarios, aqui es donde comienza la magia, por que definiendo los aspectos necesarios la maquina spring comienza a funcionar.
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping" />
<bean class="com.company.controlador.CustomerController">
<property name="methodNameResolver">
<bean class="org.springframework.web.servlet.mvc.multiaction.InternalPathMethodNameResolver">
<property name="prefix" value="test" />
<property name="suffix" value="Customer" />
</bean>
</property>
</bean>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
<property name="prefix">
<value>/WEB-INF/pages/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
como primera instancia vamos a definir el handler que vamos a utilizar se llama ControllerClassNameHandlerMapping, ojo por que este es el que permite que dispatchservlet pueda interpretar que mediante un bean mapeamos una URL a una controladora.
Ahora el siguiente paso es por supuesto definir el bean para el controlador que en nuestro caso hace referencia al que definimos CustomerController, los siguiente es configurar la propiedad methodNameResolver que sera la que se encarga de establecer el método a ejecutar mediante la opción del parámetro que establezcamos.
Ahora InternalPathMethodNameResolver es el que se encarga de resolver los metodos de acuerdo a patrones de URL y en nuestro caso utilizamos 2 propiedades
- prefix = test (por esto todo los metodos que definimos en el controlador comienzan con test)
- suffix = Customer (por esto todo los metodos que definimos en el controlador terminan con customer)
Recordemos
- testaddCustomer
- testdeleteCustomer
- testupdateCustomer
- testlistCustomer
- add.htm
- delete.htm
- update.htm
- list.htm
Como ultima opción y no menos importante es la definicion del ViewResolver que es utilizado por el controlador para realizar el redireccionamiento adecuado, en nuestra definicion le decimos que dentreo del directorio /pages vamos a encontrar nuestras vistas y van a ser de extencion jsp.
Paso 5: Entendiendo la ejecución
Para facilitar la prueba definimos un index que haga referencia a URL que posibiliten entender el mapeo que realizamos en el contenedor bean.
Primero ejecutemos en tomcat.
Tendremos una index que nos proporciona los link para visualizar los diferentes posibilidades que definimos en nuestro archivo de configuración.
Las siguientes imágenes en su URL podran mostrarnos la ejecución de cada uno de los metodos que definimos en la clase controladora.
El código del proyecto lo puedes descargar desde aquí.
codigofuente.zip
