Lo que haremos es incluir las librerías básicas de Spring y configurarlo para tener una prueba de concepto del patrón MVC.
El objetivo es tener una página de entrada desde la que mediante enlaces accedamos a dos operativas diferentes. Cada operativa funciona mediante un controlador que recibe la petición del navegador, realiza las operaciones necesarias y responde con una pantalla de resultado.
Los pasos que seguiremos son los siguientes:
- Incluir librerías en el proyecto
- Configurar el entorno
- Crear controladores
- Crear pantallas de resultados (la vista)
- Trazas de la aplicación
- Resumen gráfico
- Arranque de la aplicación
1. Incluir librerías en el proyecto
Necesitamos descargar Spring desde la página oficial (http://www.springsource.com/download/). Lo más recomendable es la descarga de Spring con dependencias que además del framework nos proporciona cantidad de librerías típicas que utilizamos en desarrollos Java y que en adelante nos serán de gran utilidad.
Yo estoy trabajando con la versión 2.5.5, así que conviene que sea la versión descargada a fin de no encontrarnos con algún problema inesperado, aunque poco probable para hacer una configuración inicial, ya sabemos que en informática nunca se sabe…
Una vez descargado el zip correspondiente, necesitaremos únicamente estos jar del contenido:
- spring.jar (carpeta dist)
- spring-webmvc.jar (carpeta dist/modules)
- commons-logging-1.1.1.jar (carpeta lib/Jakarta-commons)
- log4j-1.2.15.jar (carpeta log4j)
- jstl.jar (carpeta lib/j2ee)
Creamos en el proyecto una carpeta donde guardar las librerías que llamaremos lib, y arrastramos hasta allí los jar mencionados anteriormente:
Lo siguiente es incluirlos como dependencias del proyecto. Abrimos Project -> Properties, y en el diálogo vamos a Java EE Module Dependencies, y pulsamos en Add JARS… para incluir nuestras librerías:
2. Configurar el entorno
Nuestra primera aplicación Spring necesita que creemos estos ficheros:
web.xml (carpeta Web Content\WEB-INF)
Este fichero es el descriptor de la aplicación web, aquí se configura el entorno.
Configuramos el servlet que controlará la aplicación, el dispatcher del MVC de Spring. Este servlet será el encargado de recoger todas las peticiones y delegar el control entre los actions que más adelante configuraremos.
Además de definir nuestro servlet, tendremos que decir el patrón de rutas que éste gestionará.
Por último configuramos qué página será nuestra página de inicio por defecto en la aplicación.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>Prueba dynamic spring</display-name>
<servlet>
<servlet-name>miSpring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>miSpring</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>inicio.jsp</welcome-file>
</welcome-file-list>
</web-app>Como podemos ver, todas las páginas que terminen en “.do” serán dirigidas hacia nuestro dispatcher servlet de Spring para que las gestione.
Nuestra página de entrada en la aplicación será la jsp: inicio.jsp
miSpring.xml (carpeta Web Content\WEB-INF)
Hasta aquí hemos dicho que las peticiones de url que terminen en “.do” sean enviadas al servlet de Spring, y ahora necesitamos configurar este dispatcher para que cada ruta tenga asociado su propio action.
Por tanto nuestro objetivo ahora será que si tenemos una operativa que muestra un listado de productos, su ruta sería productos.do, que recogería Spring y éste ahora delegará en un action que recupere el listado de productos (de base de datos, de servicio, etc.) y finalmente muestre la pantalla al usuario con el listado.
Nuestro fichero de pruebas se nombrará igual que el name del servlet, y el contenido puede ser este:
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<import resource="resources/controllers.xml" />
<bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="productos.do">productosController</prop>
<prop key="noticias.do">noticiasController</prop>
</props>
</property>
</bean>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>Hemos configurado en este fichero lo siguiente:
- Donde se encuentran configurados los actions (resources/controllers.xml).
- El mapeo de rutas concretas (urlMapping) a sus actions asociados (que veremos cuáles son en controllers.xml).
- La parte de vista (viewResolver): qué tipo de fichero son, dónde están alojados y también hemos indicado que habrá preproceso con JSTL (tag-libs estándar).
controllers.xml (carpeta Web Content\WEB-INF\resources)
En este fichero ya asociamos a los controladores definidos en miSpring.xml, las clases que los implementan.
El contenido del fichero sería tal que así:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="productosController"
class="es.arcoe.ejemplos.spring.controladores.prueba.Productos">
<property name="cacheSeconds" value="120"/>
</bean>
<bean id="noticiasController"
class="es.arcoe.ejemplos.spring.controladores.prueba.Noticias">
<property name="cacheSeconds" value="120"/>
</bean>
</beans>inicio.jsp (carpeta Web Content)
Vamos creando nuestra pantalla de entrada, en la que simplemente podremos un enlace a cada operativa para probarlas:
<!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=ISO-8859-1">
<title>Entrada de pruebas spring</title>
</head>
<body>
<h1>Pruebas Spring</h1>
<ul>
<li>prueba de productos:
<a href="productos.do">productos.do</a></li>
<li>prueba de noticias:
<a href="noticias.do">noticias.do</a></li>
</ul>
</body>
</html>3. Crear controladores
Es el momento de implementar las clases que actuarán como controladores. Son las clases que recibirán la petición, son lo que llamamos Actions.
Recapitulando: el usuario de la web escribe una url, la petición la recibe Spring y éste delega al action correspondiente (de acuerdo al mapeo de miSpring.xml y controllers.xml), y finalmente este responde devolviendo el control a una jsp.
Nuestra aplicación cuenta con dos rutas que controla Spring, creamos sus actions correspondientes (ojo al paquete declarado en controllers.xml):
Productos.java
package es.arcoe.ejemplos.spring.controladores.prueba;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
public class Productos extends AbstractController {
private static final long serialVersionUID = -8627592552860108965L;
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
ModelAndView mav = new ModelAndView("productos");
return mav;
}
}Noticias.java
package es.arcoe.ejemplos.spring.controladores.prueba;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
public class Noticias extends AbstractController {
private static final long serialVersionUID = 3440288926797377376L;
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
ModelAndView mav = new ModelAndView("noticias");
return mav;
}
}Notar que dentro del método handleRequestInternal podemos realizar todas las acciones que necesitemos, para finalmente devolver el control a la JSP de resultados, que asociamos al instanciar el objeto ModelAndView pasándole el nombre de la página sin su extensión.
Esta última asociación era la que nos faltaba para terminar el flujo de ejecución hasta la vista.
4. Crear pantallas de resultados (la vista)
Las pantallas que muestran los resultados las implementamos con JSP. En ellas podremos recoger resultados del action que nos delegó el control para mostrarlas al usuario de la página.
productos.jsp (carpeta Web Content\WEB-INF\jsp)
Es la pantalla a la que llegaremos al solicitar la url productos.do
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!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=ISO-8859-1">
<title>Productos</title>
</head>
<body>
<h1>PRODUCTOS</h1>
<p>Prueba de que poniendo productos.do llego
a la JSP /WEB-INF/jsp/productos.jsp
</p>
</body>
</html>noticias.jsp
Es la pantalla a la que llegaremos al solicitar la url noticias.do
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!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=ISO-8859-1">
<title>Noticias</title>
</head>
<body>
<h1>NOTICIAS</h1>
<p>Prueba de que poniendo noticias.do llego
a la JSP /WEB-INF/jsp/noticias.jsp
</p>
</body>
</html>Bueno, pues ya lo tenemos todo.
5. Trazas de la aplicación
Entre las librerías que hemos incluido en el proyecto tenemos Log4j, un sistema de log muy utilizado y que nos servirá para ver qué está ocurriendo en nuestra aplicación.
Una configuración que podemos utilizar ahora para comprobar qué va haciendo Spring es:
log4j.properties (carpeta src)
log4j.rootLogger=DEBUG, consola
log4j.appender.consola=org.apache.log4j.ConsoleAppender
log4j.appender.consola.layout=org.apache.log4j.PatternLayout
log4j.appender.consola.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n[Ver post de log4j para más referencias]
6. Resumen gráfico
7. Arranque de la aplicación
Desde la pestaña Servers arrancamos el servidor pulsando el botón verde Run (
).El servidor quedará arrancado en el puerto 8080 por defecto.
Abrimos el navegador y escribimos en la barra de direcciones:
http://localhost:8080/mi_proyecto/ (*)Veremos la siguiente pantalla:
Ahora haremos clic en productos y en noticias para ver que efectivamente funciona y cada uno redirige a su sitio.
(*) el nombre del proyecto exacto para poner en la barra de direcciones, se encuentra configurado en eclipse, en la parte de ficheros del servidor que aparece en la izquierda.
Debemos mirar el fichero server.xml al final del mismo. Esta línea define el nombre de la ruta para ver el resultado del proyecto en el explorador:
<Context docBase="Prueba "
path="/Prueba_dynamic_spring" reloadable="true"
source="org.eclipse.jst.jee.server:Prueba dynamic spring"/>Referencias
Spring MVC framework
http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html
Title...
ResponderEliminar[...]one of our visitors not long ago recommended the following website[...]...