Licencia

Copyright (c) 2004 Hernán Darío Fernández. Se permite la copia, distribución y/o
modificación de este documento bajo los términos de la GNU Free Documentation
License, Versión 1.1 o cualquier otra versión publicada por la Free Software Foundation
Control de Cambios
Fecha Versión Autor Descripción del Cambio
21-08-2004 0.1 H Fernández Versión Inicial
22-09-2004 1.0 H Fernández Terminada
Índice
1 Introducción ............................................................................................................ 4
2 ¿Que es Struts?........................................................................................................ 4
3 El patrón Modelo – Vista – Controlador................................................................. 5
4 Struts, una implementacion del patron MVC ......................................................... 6
4.1 Introducción .................................................................................................... 6
4.2 Funcionamiento en aplicaciones WEB ........................................................... 6
5 Vista ........................................................................................................................ 8
5.1 Introducción .................................................................................................... 8
5.2 Tags................................................................................................................. 8
5.3 Internacionalización...................................................................................... 10
6 Controlador ........................................................................................................... 12
6.1 Introducción .................................................................................................. 12
6.2 La clase Action ............................................................................................. 12
6.3 El archivo struts-config.xml.......................................................................... 12
7 Modelo .................................................................................................................. 14
7.1 Introducción .................................................................................................. 14
7.2 Action Forms ................................................................................................ 14
8 Aplicación de Ejemplo en WSAD 5.1 .................................................................. 16
9 Conclusión ............................................................................................................ 37
10 Bibliografía ....................................................................................................... 37
 1 Introducción

Cuando se inventaron los Servlets Java, muchos programadores se dieron cuenta

de que eran más rápidos y más potentes que el CGI estándar, portables, y
extensibles infinitamente.

Pero escribir infinitas sentencias println() para enviar HTML al navegador era
problemático. La respuesta fueron las JavaServer Pages, que nos dejaron escribir
servlets dentro de ellas. Ahora los desarrolladores podían mezclar fácilmente
HTML con código Java, y tener todas las ventajas de los servlets.

Las aplicaciones web Java se convirtieron rápidamente en "centradas-en-JSP".

Esto, por sí sólo no era malo, pero no hacia nada por resolver problemas de
control de flujo y otros problemas propios de las aplicaciones Web.

Claramente se necesitaba otro modelo...

Algunos desarrolladores se dieron cuenta que las JavaServer Pages y los servlets
se podrían usar juntos para desplegar aplicaciones web. Los servlets podrían
ayudar con el control de flujo, y las JPSs podrían enfocarse en escribir HTML.
Usar JSP y servlets juntos se ha dado ha conocer como el Modelo 2 (cuando usar
sólo JSPs era el Modelo 1).

El proyecto Struts lo lanzó en Mayo del 2000, Craig R. McClanahan para

proporcionar un marco de trabajo MVC estándard a la comunidad Java.

2 ¿Que es Struts?

“Es un framework1 de la capa de presentación que implementa el patrón

de patrón MVC en Java”

Evidentemente, como todo framework intenta simplificar notablemente la

implementación de una arquitectura según el patrón MVC. El mismo separa muy
bien lo que es la gestión del workflow de la aplicación, del modelo de objetos de
negocio y de la generación de interfaz.

1
Un framework es la extensión de un lenguaje mediante una o más jerarquías de clases que implementan
una funcionalidad y que (opcionalmente) pueden ser extendidas.
3 El patrón Modelo – Vista – Controlador

MVC (Modelo-Vista -Controlador) es un patrón de diseño aportado

originariamente por el lenguaje SmallTalk a la Ingeniería del Software. Consiste
principalmente en dividir las aplicaciones en tres partes:

• Controlador
• Modelo
• Vistas.

El controlador es el encargado de redirigir o asignar una aplicación a cada

petición; el controlador debe poseer de algún modo, un "mapa" de
correspondencias entre peticiones y respuestas que se les asignan.
El modelo seria la lógica de negocio a fin de cuentas.
Una vez realizadas las operaciones necesarias el flujo vuelve al controlador y
este devuelve los resultados a una vista asignada.

El siguiente gráfico nos muestra la interacción entre el Modelo la Vista y el

Controlador.

Invocación de métodos
Eventos
4 Struts, una implementacion del patron MVC

4.1 Introducción

Anteriormente dijimos que Struts implementa el patrón MVC por ende nos debe
proveer o dar accesibilidad a un Controlador, al Modelo y la Vista.
El controlador ya se encuentra implementado por Struts, aunque si fuera necesario
se puede heredar y ampliar o modificar, y el workflow de la aplicación se puede
programar desde un archivo XML
Las acciones que se ejecutarán sobre el modelo de objetos de negocio se
implementan basándose en clases predefinidas por el framework .
La generación de interfaz se soporta mediante un conjunto de Tags predefinidos
por Struts cuyo objetivo es evitar el uso de Scriplets (los trozos de código Java
entre "<%" y "%>"), lo cual genera ventajas de mantenibilidad.
Logísticamente, separa claramente el desarrollo de interfaz del workflow y lógica
de negocio permitiendo desarrollar ambas en paralelo o con personal
especializado.
También es evidente que potencia la reutilización, soporte de múltiples interfaces
de usuario (Html, sHtml, Wml, Desktop applications, etc.) y de múltiples idiomas,
localismos, etc.

4.2 Funcionamiento en aplicaciones WEB

El siguiente gráfico muestra la funcionalidad de Struts.

El navegador genera una solicitud que es atendida por el Controlador (un Servlet
especializado). El mismo se encarga de analizar la solicitud, seguir la
configuración que se le ha programado en su XML y llamar al Action
correspondiente pasándole los parámetros enviados. El Action instanciará y/o
utilizará los objetos de negocio para concretar la tarea. Según el resultado que
retorne el Action, el Controlador derivará la generación de interfaz a una o más
JSPs, las cuales podrán consultar los objetos del Modelo para mostrar información
de los mismos.

Este gráfico nos provee una visión más detallada del funcionamiento de Struts
5 Vista

5.1 Introducción

La Vista se encuentra formada por un conjunto de paginas JSP. Struts provee

soporte para construir aplicaciones multi-idioma, interacción con formularios y
otras utilidades mediante la utilización de Tags especiales (TagLibraries).

5.2 Tags
A continuación veamos un detalle de los tags mas utilizados al construir paginas
JSP usadas en Strus

Genera el tag <base>. Este tag debe ser usado dentro del tag
<html:base>
<head>.
Boton

<html:button>
Genera el tag <input type="button">. Este tag debe ser usado
dentro de un <form>.
Cancelar

<html:cancel> Genera el tag <input type="submit"> y provoca que el servlet

no invoque al metodo validate(). Este tag debe ser usado dentro
de un <form>.

Wheat Wood Clay

<html:checkbox>
Stone Sheep

<html:checkbox> Genera el tag <input type="checkbox">.

Genera el codigo html para mostrar los errors que pueden
<html:errors>
ocurrir durante la invocacion del metodo validate().
<html:form> Genera <form>.
Es un elemento invisible
<html:hidden>
Genera el tag <input type="hidden">.
<html:html> Genera el tag <html>.
<html:img>

Un link a otro sitio

<html:link>
Genera un link html.
******
<html:password>
Genera <input type="password"> para ingresar .

Credit Debit
<html:radio>
Genera un radio button (<input type="radio">).
Reset
<html:reset>
Genera <input type="reset">.

alpha
<html:select> beta
gamma
<html:options> delta
epsilon

<html:option>
<html:select> Genera <select>.

<html:options> Genera el codigo html para una lista de tags <option>.

Submit

<html:submit>
Genera <input type="submit"> para enviar los datos
ingresados.
Nombre
<html:text> Email
Genera el tag <input type="text">.
 Esto es un texto cualquiera

<html:textarea>

Genera el tag <textarea>.

5.3 Internacionalización

Struts provee la facilidad de crear aplicaciones multilenguaje.

Para crear una aplicación multilenguaje debemos seguir los siguientes pasos:

1. Crear un archivo de texto (ej: ApplicationResources.properties) en el

directorio donde se encuentren las clases de la aplicación (ej:
com\empresa\aplicacion) donde se contengan las claves y valores con el formato
clave.subclave=texto de los textos que pertenezcan al idioma principal.
Ejemplo:

..
login.titulo=Laboratorio I+D - IBM WebSphere
login.labelusuario=Usuario :
login.labelpassword=Password :
...

2. Para cada idioma alternativo se creará un archivo nuevo que se llame igual
pero que termine en "_xx.properties" siendo xx el código ISO de idioma (ej:
ApplicationResources_en.properties).

3. En struts-config.xml se debe configurar el Tag /servlet/init-param/param-

name application y ponerle como param-value la localización del archivo con el
idioma principal. Ejemplo:

<servlet>
<servlet-name>action</servlet-name>
...
<init-param>
<param-name>application</param-name>
<param-value>com.empresa.aplicacion.ApplicationResources</param-value>
</init-param>
...
4. Por ultimo utilizaremos el Tag <bean:message key="clave.subclave"/>
donde clave y subclave corresponden al texto por el que se reemplazará según el
idioma del usuario. Ejemplo:

...
<H1><bean:message key="login.titulo"/></H1>
...
6 Controlador
6.1 Introducción

El Controlador comprende la funcionalidad involucrada desde que un usuario

genera un pedido HTTP (click en un link, envío de un formulario, etc.) hasta que
se genera la interfaz de respuesta. Entre medio, llamará a los objetos de negocio
del Modelo para que resuelvan funcionalidad propia de la lógica de negocio y
según el resultado de la misma ejecutará la JSP que deba generar la interfaz
resultante.
Struts incluye un servlet que a partir de la configuración de struts-config.xml
recibe las solicitudes del usuario, llama al Action Bean que corresponda y, según
lo que éste retorne, ejecuta una JSP.

6.2 La clase Action

El objetivo de una clase Action es procesar una solicitud, mediante su método
perform(), y devolver un objeto ActionForward que identifica dónde se debería
reenviar el control (por ejemplo a una JSP) para proporcionar la respuesta
apropiada.

6.3 El archivo struts-config.xml

Dentro del archivo <struts-config>, hay dos elementos importantes que son
usados para describir nuestras acciones:

<form-beans>
Esta sección contiene nuestras definiciones de beans.
Usamos un elemento <form-bean> por cada bean de formulario, que tiene
los siguientes atributos importantes:
o name: Un identificador único para este bean, que será usado para
referenciarlo en los correspondientes mapeos de acciones.
Normalmente, es también el nombre del atributo de solicitud o
sesión bajo el que se almacena este bean de formulario.

o type: El nombre totalmente cualificado de la clase Java de nuestro

bean de formulario.

<action-mappings>
Esta sección contiene nuestras definiciones de acciones. Usamos un
elemento <action> por cada una de nuestras acciones que queramos
definir. Cada elemento action requiere que se definan los siguientes
atributos:
path: El path a la clase action en relación al contexto de la
aplicación.

type: El nombre totalmente cualificado de la clase Java de nuestra

clase Action.

name: El nombre de nuestro elemento <form-bean> para usar con

esta action.
7 Modelo

7.1 Introducción

El Modelo comprende todos los Objetos de Negocio donde se implementa la

lógica de negocio y donde se debe soportar todos los requisitos funcionales del
Sistema sin mezclarlo con partes correspondientes al workflow que corresponden
al Controlador.

7.2 Action Forms

Una de las tareas que durante el desarrollo de una aplicación insume mucho
trabajo (aunque en realidad no lo merezcan) es la interacción con formularios, ya
sea para editar u obtener nueva información. Las comprobaciones, la gestión de
errores, el volver a presentarle el mismo form al usuario con los valores que puso
y los mensajes de error y un largo etcétera están soportadas por Struts a fines de
hacernos la vida un poco más fácil.
La idea es la siguiente: todo el trabajo de comprobaciones y generación de
mensajes de error se implementa en los ActionForm y todo el trabajo de
generación de interfaz en la/s JSP.

7.2.1 Validación automática en formularios

Struts ofrece una facilidad adicional para validar los campos de entrada que ha
recibido. Para utilizar esta característica, sobreesribimos el siguiente método en
nuestra clase ActionForm:

public ActionErrors
validate(ActionMapping mapping,
HttpServletRequest request);

El método validate() es llamado por el servlet controlador después de que se

hayan rellando las propiedades del bean, pero antes de se llame al método
perform() correspondiente de la clase Action. El método validate() tiene las
siguientes opciones:

Realiza las validaciones apropiadas y no encuentra problemas -- Devuelve

null o ejemplares de ActionErrors de longitud cero, y el servlet
controlador procederá a llamar al método perform() de la clase Action
apropiada.

Realiza las validaciones apropiadas y encuentra problemas .

Devuelve un ejemplar de ActionErrors conteniendo ActionError's, que son
clases que contienen las claves del mensaje de error que se deberían
mostrar. El servlet controlador almacena este array como un atributo de la
solicitud disponible para usarse por la etiqueta <html:errors>, y devolverá
el control al formulario de entrada.

Como se mencionó anteriormente, esta característica es totalmente

opcional. La implementación por defecto de validate() devuelve null, y el
servlet controlador asumirá que no se requiere que se haga ninguna
validación por parte de la clase Action.

Una aproximación común es realizar validaciones iniciales usando el

método validate(), y luego manejar la validación de la "lógica de negocio"
desde el objeto Action.
 8 Aplicación de Ejemplo en WSAD 5.1

Veamos como construir un simple login de una aplicación WEB utilizando Struts
con el IDE WebSphere Studio Application Development .
Primero seleccionemos un Nuevo Proyecto WEB Dinamico y presionamos
Siguiente

La siguiente pantalla nos pregunta el nombre del proyecto, le pondremos Login y

presionamos siguiente
Luego nos pide el nombre del proyecto EAR, aquí le pondremos LoginEAR y siguiente.
En esta pantalla seleccionamos las opciones “Añadir soporte de Struts” y “Biblioteca de
códigos JSP”

Ahora vamos a agregar la pantalla JSP de Login, seleccionamos WEB -> Pagina JSP
Le ponemos el nombre login.jsp y en el modelo seleccionamos Struts

Diagramamos la pantalla JSP usando la paleta de controles WEB

Luego modificamos la pagina para agregarle los tags de Struts (Ver sección 5.2)

Estos son los tags que reemplazamos

<H1><bean:message key="login.titulo"/></H1>
<HR>

<P><BR>
<html:form action="login.do">
<h5><html:errors/></h5>
<BR><bean:message key="login.labelusuario"/>
<html:text property="usuario" size="16" maxlength="18"/>
<BR><bean:message key="login.labelpassword"/>
<html:password property="password" size="16" maxlength="18"/>
<BR>
<html:submit value="OK">
<BR>
</html:submit>
</html:form>

El tag <bean:message key="login.titulo"/> nos permite utilizar la funcionalidad

multilenguaje de struts. Con este Tag, Struts reemplaza la clave “login.titulo” por el
contenido de la clave “login.titulo” contenida en el archivo
ApplicationResources.properties.
El tag <html:errors/> muestra los errores que ocurrieron al ingresar los datos en el
formulario.
Ahora crearemos dos paginas JSP adicionales, una para mostrar que la autenticación fue
exitosa y otra para indicar que el usuario y/o password no coincide.
Repetimos los pasos utilizados anteriormente para crear pagina JSP Nuevo Web JSP

Le pondremos como nombre loginOK.jsp y como modelo JSP Struts

Una vez mas usaremos el menu Nuevo Web JSP para crear la ultima JSP.

Le pondremos como nombre loginError.jsp y como modelo JSP Struts

Luego vamos a crear una clase AccionForm pulsando en Nuevo Web Struts
Clase ActionFrom

Le damos un nombre, en nuestro caso LoginForm

Le indicamos al form la pagina JSP que posee los campos usuario y password

El asistente de ActionForms nos indica que hay dos campos con tags de ingreso de datos
como html:text o html:password.
Este paso añade el Form Bean al archivo struts-config.xml

Una vez creado el formulario, vamos a crear una clase Action que le pondremos de
nombre LoginAction
Este paso asocia el Action con el ActionForm y lo añade al archivo struts-config.xml

Ahora modificaremos el metodo validate de la clase LoginForm para validar que se

ingrese usuario y password
El código que agregamos es el siguiente
public ActionErrors validate(
ActionMapping mapping,
HttpServletRequest request) {

ActionErrors errors = new ActionErrors();

// Valido que el usuario y password no sean nulos

if(getUsuario() == null)
errors.add("usuario", new ActionError("error.usuarioNulo"));
if(getPassword() == null )
errors.add("password", new ActionError("error.passwordNulo"));

return errors;

}
Retornamos una clase ActionErrors con los errors que detectamos para que Struts
muestre los mismos en la pagina JSP que contenga el tag <html:errors/>

Ahora vamos a crear la clase que va a validar efectivamente que el usuario y password
sean correctos, en la practica esta clase puede validar el usuario contra la BD, un servidor
LDAP, etc,etc,etc. A los efectos de este tutorial esta clase solo va a validar con valores
fijos.

Creamos una nueva clase utilizando Nuevo Java Clase

El código que vamos a agregar en esta clase es el siguiente:

package login.businessdelegate;

public class UserBusinessDelegate {

// Constructor
public UserBusinessDelegate()
{
}

// Metodo utilizado para validar el usuario

public boolean validarUsuario(String usuario,String password)
{
boolean usuarioValido = false;

if (usuario.equals("juan") && password.equals("perez"))

{
usuarioValido = true;
}

return usuarioValido;
}

}
Solamente escribimos un metodo validarUsuario verifica que el usuario sea “juan” y su
password “perez”
Ahora vamos a modificar la clase LoginAction para agregar el codigo que toma los datos
del formulario y valida el usuario.
El código que agregamos fue el siguiente
LoginForm loginForm = (LoginForm) form;
String usuario = loginForm.getUsuario();
String password = loginForm.getPassword();

try {
UserBusinessDelegate userBD = new UserBusinessDelegate();
if (!userBD.validarUsuario(usuario, password))
{
errors.add(ActionErrors.GLOBAL_ERROR,
new ActionError("errores.usuarioinvalido"));
}
} catch (Exception e) {
errors.add(ActionErrors.GLOBAL_ERROR,
new ActionError("errores.errordesconocido"));
}
if (!errors.isEmpty()) {
saveErrors(request, errors);
forward = mapping.findForward("fail");
} else {
forward = mapping.findForward("success");
}

return (forward);

Tomamos los datos del formulario con los metodos getUsuario y getPassword
Luego instanciamos la clase UserBusinessDelegate y ejecutamos el metodo
validarUsuario(Usuario,Password).
Si el usuario es correcto, enviamos un forward a “success”, no lo es enviamos un forward
a “fail”.
Tanto “success” como ”fail” tienen que estar definidos en el archivo struts-config.xml
Para confirgurar esto, hacemos doble clic sobre el archivo struts-config.xml
Veremos esta pantalla de acciones
En la solapa reenvios locales definimos “success” y lo direccionamos a la pagina
loginOK.jsp

Además definimos “fail” y lo direccionamos a la pagina loginError.jsp

El paso final será crear las claves utilizadas en las paginas JSP en el lenguaje español,
para eso modificaremos el archivo ApplicationResources.properties.

y agregamos las siguiente claves:

login.titulo=Laboratorio I+D - IBM WebSphere

login.labelusuario=Usuario :
login.labelpassword=Password :
errores.usuarioinvalido=Usuario / Password invalido
errores.errordesconocido=Error desconocido
Ya estamos en condiciones de probar este ejemplo, nos posicionamos sobre el archivo
login.jsp, presionamos clickk derecho del mouse y seleccionamos “Ejecutar en Servidor.”

Debemos aguardar a que inicie la aplicación en el servidor...

Al fin tenemos la aplicacion funcionando, probaremos en ingresa el usuario “juan” pero
con una password errónea.

La pantalla de salida sera “LoginError.jsp”, la que nos direcciona Struts ante un “fail”.
En cambio si ingresamos el usuario y password OK, la pantalla de salida sera
“LoginOK.jsp”, la que nos direcciona Struts ante un “success”.
 9 Conclusión

En resumen, Struts es un framework de desarrollo de aplicaciones Web basado en el

patron MVC, con lo que nos permite separar perfectamente al lógica de negocio de la
lógica de presentación, de la lógica de control.

10 Bibliografía
Sitios de Internet :
Struts, an open-source MVC implementation –
http://www-106.ibm.com/developerworks/websphere/techjournal/0302_fung/fung.html

Web Site Oficial - http://jakarta.apache.org/struts

Libros :
Struts Kick Start (James Turner, Kevin Bedell) - Sams Publishing