Hola de nuevo a todos foto de Eloy Mier Pérez

Esta vez traigo un articulo distinto a los que tengo acostumbrado al personal, y muy posiblemente no será el ultimo de este tipo.

Hoy voy a presentar un par de tecnologías muy vinculadas al mundo del desarrollo Java/J2EE.  Concretamente vamos a ver por encima dos frameworks muy interesantes Spring MVC y tiles. Como es de suponer, ambos los estoy usando actualmente en la empresa para un proyecto Java, y me he decidido a escribir el presente articulo en gran parte por la cantidad de información antigua y desfasada que se puede encontrar en Internet.

Como comentario inicial Spring 3.0 funciona con tiles 2.1.4 confirmado. Puedo asegurar que actualmente he desarrollado un pequeño piloto funcional con estas tecnologías.

Bien, Apache tiles es un framework para construir plantillas que permiten simplificar el desarrollo la capa de presentación en aplicaciones Web. Tiles permite a los desarrolladores definir pequeños fragmentos de las páginas que pueden ser ensamblados para la construcción de las páginas Web definitivas en tiempo de ejecución. Estos fragmentos o tiles se pueden usar como si se una simple inclusión se tratase o bien embebidos en otros fragmentos con el objetivo de definir una serie de plantillas reutilizables. Estas plantillas logran normalizar la capa de vista a lo largo de toda la aplicación.

Por otro lado Spring MVC es un framework que nos permite organizar el desarrollo de la aplicación Web conforme al modelo MVC (Model-View-Controller). Este framework esta diseñado entorno a un Servlet Despachador (DispatcherServlet) que simplemente redirige las peticiones a los manejadores correspondientes. Las características principales son mapeos a los manejadores configurables, resolución de locales, y soporte de subida de ficheros. El framework ademas permite usar cualquier tipo de objeto java en la capa de la vista sin necesidad de desarrollar interfaces o clases base.

Actualmente estoy desarrollando una aplicación J2EE para la administración. La aplicación es de gestión eminentemente, mucha entrada de datos en los procesos que define. Es por ello que pensé que Spring MVC podría ser una buena opción.

Por otra parte, la aplicación, debe desarrollarse en torno a un menú principal y una barra de botones en la parte superior, variando los contenidos de la página, pero manteniendo constantes los elementos comentados. Esto se puede hacer de la forma tradicional, con los includes al menú y la botonera en todas las páginas, pero presenta un par de inconvenientes a los que quería dar solución. Los inconvenientes son:

  1. En el caso de querer modificar la apariencia del Site, nos veríamos obligados a modificar todas las páginas del mismo.
  2. El control del contenido hay que programarlo manualmente, lo que implica mas lógica en la capa del servidor y que nada tiene que ver con la problemática del negocio.
  3. El control manual de los includes, normalmente lleva a problemas importantes en cuanto a que en ciertos momentos no sabemos exactamente que es lo que se está o no incluyendo.
  4. Normalmente se pierde la homogeneidad en la apariencia en mayor o menor medida.

Por todo ello en el proyecto he decidido incluir ambos frameworks. Spring va a llevar el control del site y tiles va a organizarme las páginas.

Bueno, pues hecha la introducción al proyecto vamos a pasar a ver un poco un pequeño ejemplo de cómo integrar las tecnologías comentadas. El ejemplo que vamos a realizar es muy simple. Con Spring MVC vamos a desarrollar un pequeño controlador principal encargado de recibir las peticiones de cliente y enrutarlas a los controladores especializados. Concretamente y como base, vamos a desarrollar un controlador que filtra una petición a index.htm y la enruta a un controlador para la página de inicio del sitio web.

Por otro lado, y enlazando con la página de inicio del site, no vamos a enrutar a una página simple, sino a una construida en tiempo de ejecución usando tiles.

Comenzamos con un boceto del controlador y luego pasamos al código fuente:

Spring en acción

Mostrada la idea, pasemos al código necesario para la capa de controladores:

fichero de configuración para el controlador frontal (frontController-servlet.xml):

<?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="frontController"/>
  <import resource="indexController-servlet.xml"/>

  <bean id="urlMapping">
  <property name="urlMap">
  <map>
  <!-- Aquí se define la entrada que redirige al controlador de Index >
  <entry key="**/index*"><ref bean="indexController"/></entry>
  </map>
  </property>
  </bean>
</beans>

Implementación del controlador (Sip ya se que no hace nada….la redirección se indica en el fichero xml del controlador):

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FrontController {
 private final Log logger = LogFactory.getLog(getClass());
}

fichero de configuración del controlador index (indexController-servlet.xml)

<?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="indexController"/>

 <bean id="jstlViewResolver">
 <property name="viewClass">
    <value>org.springframework.web.servlet.view.JstlView</value></property>
 <property name="prefix"><value>/WEB-INF/jsp/</value></property>
 <property name="suffix"><value>.jsp</value></property>
 </bean>
</beans>

Implementación controlador Index(IndexController.java)

import java.lang.annotation.Annotation;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class IndexController implements Controller {
 private final Log logger = LogFactory.getLog(getClass());

 public ModelAndView handleRequest(HttpServletRequest arg0,
 HttpServletResponse arg1) throws Exception {
 // TODO Auto-generated method stub
 return new ModelAndView("index");
 }
}

Fichero de contexto de la aplicación web (aquí he especificado el fichero de configuración de tiles)

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName"
 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">

 <!-- Include the configuration files of the other components -->
 <bean id="tilesConfigurer"
 class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
 <property name="definitions">
   <list><value>/WEB-INF/tiles-defs/myTilesConfigFile.xml</value></list>
 </property>
 </bean>
</beans>

Fichero web xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
 <display-name>xxxxyyyy Web</display-name>

 <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>frontController</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
   <servlet-name>frontController</servlet-name>
   <url-pattern>*.htm</url-pattern>
 </servlet-mapping>

 <servlet-mapping>
 <servlet-name>frontController</servlet-name>
 <url-pattern>*.view</url-pattern>
 </servlet-mapping>
</web-app>

Tiles en acción

fichero de plantilla usado por la aplicacion (template01.jsp)

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
   pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="tiles" uri="http://tiles.apache.org/tags-tiles" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">

<html>
 <head>
   <title><tiles:getAsString name="title"/></title>
 </head>
 <body>
 <table border="1">
   <tr><td colspan="2"><tiles:insertAttribute name="header"/></td></tr>
 <tr>
   <td><tiles:insertAttribute name="menu"/></td>
   <td><tiles:insertAttribute name="content"/></td>
 </tr>
 <tr>
   <td colspan="2"><tiles:insertAttribute name="footer"/></td>
 </tr>
 </table>
 </body>
</html>

El fichero de configuración de tiles es:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
 "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
 "http://tiles.apache.org/dtds/tiles-config_2_1.dtd">

<tiles-definitions>
 <!-- Default Main Template -->
 <definition name="mainTemplate" template="/WEB-INF/templates/template01.jsp">
   <put-attribute name="title" value="Simple Tiles 2 Example" type="string" />
   <put-attribute name="header" value="/WEB-INF/jsp/header.jsp" />
   <put-attribute name="footer" value="/WEB-INF/jsp/footer.jsp" />
   <put-attribute name="menu" value="/WEB-INF/jsp/leftMenu.jsp" />
 </definition>

 <definition name="main" extends="mainTemplate">
   <put-attribute name="content" value="/WEB-INF/jsp/blank.jsp" />
 </definition>
</tiles-definitions>

Por último el fichero index.jsp contiene una referencia a la deficicion:

<%@ include file="/WEB-INF/jsp/include.jsp" %>

<tiles:insertDefinition name="main"/>

Resultado de la petición

Referencias

  1. http://www.springsource.org/
  2. http://tiles.apache.org/

Un saludo a todos….y hasta la próxima

Comments (2)

rebufo

Ago 27, 2010 at 10:39 AM

Me parece un gran artículo para iniciarse en las tecnologías que indicas. Me imagino que JBoss 5.x es desde hace tiempo una opción estable y fácil de utilizar frente a la ya clásica versión 4.x

Respecto al uso de Tiles, mi duda es si te resuelve de forma transparente la posible necesidad de mostrar contenido siempre visible en pantalla, como pueden ser la barra de menú superior y el panel lateral de enlaces / tareas. En mi HTML seguramente desfasado esto se hacía mediante la página «base» con el elemento FRAMESET.

Un saludo

Marvell

Ago 28, 2010 at 12:23 AM

Me alegro que el articulo te guste. La verdad es que me he animado a escribirlo por que hay mucha información contradictoria en inet sobre el asunto.

Con respecto a la pregunta que planteas, efectivamente, esa arquitectura me resuelve por completo los frames clásicos a los que todos estamos acostumbrados. De hecho, en este caso, mi decisión a la hora de implementar usando tiles fue unicamente esa y no me equivoque.

Saludete.

You must be logged in to post a comment.