STRUTS

Autor: Fecha: Estado: Número Documento Revisión:
Pello (pello@pello.info) 23/06/2003 Borrador 1 2
Implementación del patrón MVC

en aplicaciones Web
Por Pello Xabier Altadill Izura
Ingeniero Informático por la UPV-EHU
pello@pello.info
(Actualizaciones y ejemplos en http://www.pello.info )
Agradecimientos: Mikel Alberdi (por calentarme la cabeza),a mis ex compañeros de AXPE, y

a los de Jazztel: Dani, Sara, Julio, Izaskun, al loco del jefe, a los de Ebussiness,
chicho_talavera, Maria, Gemma, Maria, Jose, etc.. A la gente que conocí en un proyecto de
Andersen para Safei, sobre todo Alex que era un jashondo y al gerente que era clavao al calvo
del anuncio de la loteria y guíaba a los muchachos con mano ferrea.
STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 1

INDICE
1. INTRODUCCIÓN.................................................................................................. 3
2. MVC: Model View Controller ............................................................................... 4
3. STRUTS.................................................................................................................. 7
ESTUCTURA .......................................................................................................................... 8
UN EJEMPLO SENCILLO DE STRUTS .......................................................................... 12
UN EJEMPLO DE STRUTS MÁS COMPLEJO............................................................... 14
UN EJEMPLO DE STRUTS MÁS COMPLEJO............................................................... 15
4. Una aplicación completa: MECANO.................................................................. 29
5. Errores comunes con Struts ................................................................................ 31
6. ENLACES, NOTAS, AUTOR.............................................................................. 33

1. INTRODUCCIÓN
Este documento describe el patrón de diseño MVC (Model View Controller). Como
ejemplo de implementación se utiliza el framework Struts, que facilita el desarrollo de
aplicaciones web en Java basadas en MVC.
En al ámbito del desarrollo web se siguen unas pautas que tratan más o menos de
conseguir un desarrollo estructurado de las aplicaciones, donde la verificación de
sesión se centraliza y cada caso de uso se distingue claramente. Utilizando Struts ese
“más o menos” se convierte en una arquitectura completamente estructurada que
divide perfectamente lógica de negocio (Model), presentación (View) y control de flujo
de aplicaciones(Controller). En muchos desarrollos web se diseña consciente o
inconscientemente siguiendo este patrón, por tanto la adopción del modelo Struts no
debiera suponer un quebradero de cabeza.
Además hay que tener en cuenta que Struts nos da parte del trabajo hecho, funciona
correctamente, y nos da ciertos extras. Teniendo en cuenta además las aportaciones
de grupos de desarrollo (taglibs nuevos, etc..), la adopción de esta plataforma puede
resultar muy interesante.
Parte del éxito de Struts se debe a que el desarrollo de aplicaciones web resulta ser
un caos y cada grupo de desarrollo lo hace a su manera. Al menos para entorno
puramente web Struts le esta comiendo terreno a los EJB y esta consiguiendo que los
desarrollos sigan unas pautas estándar, lo que facilita que en el cambiante mundo de
la ingeniería informática donde impera el movimiento de recursos humanos el
mantenimiento y mejora de una aplicación web sea más llevadero.

2. MVC: MODEL VIEW CONTROLLER
MVC o Model view Controller es un patrón de diseño aportado originariamente

por el lenguaje SmallTalk a la Ingeniería del Software. El paradigma MVC consiste en
dividir las aplicaciones en tres partes:
• Controlador
• Modelo
• Vistas.
El controlador es el encargado de redirigir o asignar una aplicación (un

modelo) a cada petición; el controlador debe poseer de algún modo, un "mapa" de
correspondencias entre peticiones y respuestas (aplicaciones o modelo) que se les
asignan.
El modelo seria la aplicación que responde a una petición, es 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.
Vemos las diferencias que supone el modelo con los modelos convencionales.
Llendonos al esquema más básico de programa, tenemos una entrada o parámetros

que llegan(INPUT), se procesan y se muestra el resultado (OUTPUT).

En el caso del patrón MVC el procesamiento se lleva a cabo entre sus tres
componentes. El controller recibe una orden y decide quien la lleva a cabo en el
modelo. Una vez que el modelo (la lógica de negocio) termina sus operaciones
devuelve el flujo vuelve al controller y este envía el resultado a la capa de
presentación.

El Controller en cierta forma debe tener un registro de la relación entre ordenes que le
pueden llegar y la lógica de negocio que le corresponde (Es como una operadora de
teléfono que recibe una petición y une dos lineas). En el siguiente gráfico se
representa ese funcionamiento:
¿Que ventajas obtenemos de este modelo? Obviamente una separación total entre
lógica de negocio y presentación. A esto se le pueden aplicar opciones como el
multilenguaje, distintos diseños de presentación,.. etc sin alterar la lógica de negocio.
La separación de capas como presentación, lógica de negocio, acceso a datos

es fundamental para el desarrollo de arquitecturas consistentes, reutilizables y más
fácilmente mantenibles, lo que al final resulta en un ahorro de tiempo en desarrollo en
posteriores proyectos.
En el lenguaje Java disponemos de una clases muy sencillas para implantar el modelo
MVC: la clase Observer, Observable del paquete util.
Aunque esa implementación del MVC con esas clases se podría hacer a un nivel muy
simple de interacción entre unas pocas clases.
En este caso, mediante Struts se aplica el MVC en toda una aplicación Web
convencional.

3. STRUTS
Struts Framework (http://jakarta.apache.org/struts)

Struts es un framework para aplicaciones web java que implementa el modelo MVC.
Realmente lo que provee es un conjunto de clases y TAG-LIBS que conforman el
Controlador, la integración con el Modelo (o lógica de negocio) y facilitan la
construcción de vistas.
Naturalmente, el Modelo o lógica de negocio es la parte que nos corresponde
desarrollar. Por eso Struts es una plataforma sobre la que montamos la lógica de
negocio, y esta plataforma nos permite dividir la lógica de la presentación entre otras
cosas.

ESTUCTURA
Supongamos que tenemos una aplicación Web que consiste en un formulario que recoge datos
y los manda al servidor para su proceso. Este ejemplo tan simple necesitaría implementar unos
6 ficheros (2 de ellos jsps). ¿Suena mal eh? Es el precio que hay que pagar por una aplicación
bien estructurada.
Utilizando Struts nunca se llega a una pagina de la capa de presentación directamente. Esto
es, en la url nunca se llega a una pagina jsp o html a traves de su nombre. De eso se trata el
MVC, la presentación esta separada en otra capa.
En este entorno, se debe invocar una acción o aplicación que debe estar mapeada en Struts:
una acción se corresponderá con una clase Java (heredera de la clase Action de Struts). El
mapeo de acciones y clases se especifica en un fichero de importancia vital: struts-
config.xml. Ahí se especifican todas las relaciones entre acciones y clases, formularios y
clases, acciones y jsps de presentación, que globalmente conforman el “mapa” de la
aplicación.
Si quisieramos crear la aplicación Struts más simple posible, por ejemplo una página con un
saludo, debiéramos hacer lo siguiente:
1. -Una página JSP (la presentación)
2. -Una clase Action (componente del controlador)
3. -La clase Action debe definirse en el struts-config.xml correctamente
Veamos los diagramas correspondientes a ese caso:
Diagrama de clases
En el caso más simple este sería el conjunto de clases utilizadas y sus relaciones.
Como se puede ver, no tendríamos más que dos ficheros, una clase que hereda de
struts.Action y una JSP con la presentación. La clase Action se configura en el strtus-config.xml
y se convierte en parte del controlador. Cuando la aplicación recibe una petición, Struts
decidirá que debe cargar esa clase y través de ella cargará la JSP. Así se puede ver en el
siguente diagrama:
Diagrama de colaboración
Esta sería la manera de interactuar entre la clases y Struts

Una petición llega a struts (una URL); este mira en su “mapa” (el fichero struts-config.xml), y
deduce que tiene que cargar la ClaseAction. Esta clase esta configurada para que cargue una
pagina JSP.
Como se puede observar,no se carga la JSP directamente, hay que pasar por el controlado
Diagrama de secuencia.
Estos serían los pasos seguidos por la aplicación en el plano temporal.
Obviamente, este no es el ejemplo más clásico de una acción de Struts. Por lo general, en
cualquier aplicación web siempre se sigue un mismo esquema:
1. se muestra un formulario
2. se rellena
3. se validase
4. se manda a una página que realiza la lógica de negocio
5. se muestra el resultado.
Todo esto se podría hacer con dos JSPs o dos ASPs, o dos CFM, o dos PHP o con un CGI,
etc…
En Struts necesitaríamos lo siguiente:
1. -Una clase Action (su nombre podría empezar por Edit) encargada de cargar el formulario.
2. -Un Bean tipo Form cuyos campos u atributos de instancia coinciden con los campos del
formulario. (al ser tipo JavaBean tendrá los correspondientes métodos set y get para los
atributos) . Este form y sus atributos son un requisito imprescindible.
3. -Una JSP que contiene el formulario citado. Los campos deben coincidir con los definidos
en el Bean de formulario
4. -Una clase Action (su nombre podría empezar por Save) encargada de pasar la instancia
del formulario al Bean de Logica de Negocio, esperar su resultado y redirigir el flujo a una
JSP de error o de éxito.
5. -Un Bean de lógica de negocio (El que hace algo con los datos del formulario)
6. -Una JSP para mostrar un mensaje en caso de éxito (o puede ser la misma del principio)
7. -Una JSP para mostrar los errores en caso de error (o puede usarse una genérica).
Struts permite cierta flexibilidad en cuanto a nombres, pero conviene especificar cual es
Action, cual es Form, cual es Bean de negocio, etc.. así como meterlos en subpaquetes con
ese nombre.
Veamos como quedan esos siete elementos en diagramas

Diagrama de clases
Este sería el conjunto de clases utilizadas y sus relaciones.
La clase edit también podría usar el formulario, pero en principio no tiene porqué.
Sería interesante ver como interactúan las clases entre ellas, y eso se ve en el siguiente
gráfico.
Esta sería la manera de interactuar entre las clases y Struts

Diagrama de secuencia.
Estos serían los pasos seguidos por la aplicación en el plano temporal.

UN EJEMPLO SENCILLO DE STRUTS
Bien, veamos ahora el ejemplo mítico de HelloWorld por el que se suele empezar cuando no se
tiene ni idea de algo.
Vamos a crear una aplicación que muestra una página con el saludo Kaixo! que significa hola
en euskera. Es fácil de narices.
Entrada de aplicación: ninguna

Salida: Una página que muestra el texto “Kaixo!”
Diagrama de clases
• Clase EditKaixoAction
/**
* EditKaixoAction.java
* Pello Xabier Altadill Izura
*/
package pxai.struts.kaixo.action;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Locale;
import java.util.Vector;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.util.MessageResources;
import org.apache.struts.util.PropertyUtils;
import com.jazztel.numeracionip.comun.Log;
/**
* EditKaixoAction.java
* Maneja las peticiones enviadas por el browser
* en el url se pondra: /kaixo.do y struts cargara esta clase
* que redirigira el flujo a una jsp: Kaixo.jsp
*
* @author Pello Xabier Altadill Izura
* @version 1.0 ,date 13/2/02
*/
public final class EditKaixoAction extends Action {
/**
* Procesa la peticion HTTP (request) especificada y genera su correspondiente

* respuesta HTTP (response) (o lo redirige a otro componente web que podria

crear).
* Devuelve una instancia code>ActionForward</code> que describe a DONDE y COMO
* se redirige el control, o sino, si la respuesta se ha completado se devolveria
* <code>null</code>
*
* @param mapping El mapeo utilizado para seleccionar esta instancia
* @param request El request que estamos procesando
* @param actionForm La instancia ActionForm que estamos utilizando (si la hay)
* @param response La respuesta HTTP que creamos.
*
* @exception IOException en caso de error de entrada/salida (i/o)
* @exception ServletException en caso de error de servlet
*/
public ActionForward perform(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// Extrae los atributos que se necesitan

Locale locale = getLocale(request);
MessageResources messages = getResources();
HttpSession session = request.getSession();
String action = request.getParameter("action");
ActionErrors errors = null;
try {
if (action == null)
action = "Create";
if (servlet.getDebug() >= 1)
servlet.log("EditKaixoAction: Procesando action " + action);
/***** Logica segun el parametro action (no
imprescindible)**************/
/************************************ fin de logica
*********************/
// Redirige el control en caso de exito a la pagina espcificada en
struts-config.xml
servlet.log(" Redirigiendo a pagina 'success'");
return (mapping.findForward("success"));
} catch (Exception e) {
e.printStackTrace(System.out);//Escribe en el fichero de log del
servidor de aplicaciones
errors = new ActionErrors();
errors.add("action",new
ActionError("action.perform.carga.error"));//Se incluye un mensaje de error que se
encuentra en el fichero especificado especificado en las propiedades de Struts
saveErrors(request,errors);
return (mapping.findForward("failure"));
}
}
El fichero JSP Kaixo.jsp

<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/app.tld" prefix="app" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
<html:html>
<head>
<title>STRUTS :: ejemplo</title>
</head>
<body>
<H1>
<%
out.println("Kaixo!!");
%>
</H1>

</body>
</html:html>
Configuracion del fichero struts-config.xml para este sencillo caso.

Se debiera añadir, dentro de action mappings:
<action-mappings>






<action path="/kaixo" type="pxai.struts.kaixo.action.EditKaixoAction"
name="" scope="request" validate="false">
<forward name="success" path="/Kaixo.jsp"/>
</action>
(Nota: debe reiniciarse el servidor de aplicaciones si se cambia este fichero)
El resultado:

UN EJEMPLO DE STRUTS MÁS COMPLEJO

En fin, el ejemplo anterior era el típico “toy-code” que únicamente es valido como iniciación al
Struts. Ahora veremos un ejemplo más acorde con la funcionalidad esperada de una aplicación
web cualquiera.
Se trata de una aplicación de alta de usuario, un tipo de aplicación muy común y que presente
en muchos sistemas. Veremos como implementar esto con struts. En cualquier otro entorno
bastaría con crear un formulario y una página que realiza el alta y da el mensaje
correspondiente; pero aquí no será tan simple.
Entrada de aplicación: Un formulario de datos: username, password,edad,fechanacimiento y
profesion
Salida: Una página que muestra si se ha dado de alta correctamente
Diagrama de clases
Aquí se puede contemplar las clases que serán necesarias para este ejemplo

Esta sería la manera de interactuar entre las clases action, form, bean, jsp y Struts .
Diagrama de secuencia
Aquí podemos ver como interactúan las clases en el tiempo.

El código
EditAltaAction
/**
* EditAltaAction.java
*/
package pxai.struts.alta.action;
import java.lang.reflect.InvocationTargetException;
import java.util.Vector;
import javax.servlet.RequestDispatcher;
import org.apache.struts.util.PropertyUtils;
import com.jazztel.numeracionip.bean.MigracionNumeracionBean;
/**
* EditAltaAction.java
* Maneja las peticiones enviadas por el browser
* @version 1.0 ,date 13/2/02
*/
public final class EditAltaAction extends Action {
/**
crear).
* <code>null</code>
*
*
*/
public ActionForward perform(ActionMapping mapping,
ActionForm form,
// Extrae los atributos que se necesitan

try {
if (action == null)
action = "Create";
servlet.log("EditAltaAction: Procesando action " + action);

/************************************
*******************************************/
// En este caso unicamente cargamos la JSP
/************************************
*******************************************/
// Redirige el control en caso de exito a la pagina espcificada en
struts-config.xml
servlet.log(" Redirigiendo a pagina 'success'");
} catch (Exception e) {
// Creamos un error y lo salvamos para mostrarlo por pantalla
errors.add("alta",new ActionError("alta.edit.error"));
}
}
alta.jsp
<html:html>
<head>
<title>STRUTS :: ejemplo de ALTA</title>
</head>
<body>
<html:form action="/saveAlta.do" >
<b>ALTA de USUARIO</b><hr>
Usuario:<html:text property="username" size="8" maxlength="8" /><br>

Password:<html:text property="password" size="8" maxlength="8" /><br>
Edad:<html:text property="edad" size="3" maxlength="3"/><br>
Fecha Nacimiento(dd/mm/aaaa):<html:text property="fechanacimiento" size="10"
maxlength="10"/><br>
Profesion:<html:select property="profesion">
<html:option value="-1">Selecciona ...</html:option>
<html:option value="Parado">Parado</html:option>
<html:option value="Estudiante">Estudiante</html:option>
<html:option value="Profesional liberal">Profesional
liberal</html:option>
<html:option value="Empresario">Empresario</html:option>
<html:option value="Currela">Currela</html:option>
</html:select><br>
<html:submit property="alta"/>
</html:form>
</body>
</html:html>
AltaForm
/**
* AltaForm.java
*/
package pxai.struts.alta.form;

import com.jazztel.numeracionip.comun.IP;
import java.sql.Date;
/**
* AltaForm
*
* Implementa el formulario de ALTA que se muestra en html
* @version 1.0
* date 13/2/02
*/
public final class AltaForm extends ActionForm {
/**
* @field Mantenimiento de la accion que estamos procesando (Create or Edit).
* atributo IMPRESCINDIBLE para STRUS
*/
private String action = "Create";
private String username = null;

private String password = null;
private Integer edad = null;
private String fechanacimiento = null;
private String profesion = null;
/**
* Devuelve la accion.
*
* @return String la accion
*/
public String getAction() {
return (this.action);
}
/**
* Establece la accion
*
* @param action La nueva accion
*/
public void setAction(String action) {
this.action = action;
}
/**
* getUsername
* Devuelve nombre de usuario
* @return String
*/
public String getUsername() {
return (this.username);
}
/**
* setUsername
* Establece el nombre de usuario
* @param String
*/
public void setUsername(String username) {
this.username = username;
}
/**
* getPassword
* Devuelve el password
* @return String
*/
public String getPassword() {
return (this.password);
}
/**
* setPassword
* Establece el password

* @param String
*/
public void setPassword(String password) {
System.out.println("Aqui estamos: " +password);
this.password = password;
}
/**
* getEdad
* Devuelve edad
* @return Integer
*/
public Integer getEdad() {
return (this.edad);
}
/**
* setEdad
* Establece la edad
* @param Integer
*/
public void setEdad(Integer edad) {
this.edad = edad;
}
/**
* getFechanacimiento
* Devuelve la fecha de nacimiento dd/mm/aaaa
* @return String
*/
public String getFechanacimiento() {
return (this.fechanacimiento);
}
/**
* setFechanacimiento
* Establece la fechanacimiento
* @param String
*/
public void setFechanacimiento(String fechanacimiento) {
this.fechanacimiento = fechanacimiento;
}
/**
* getProfesion
* Devuelve la profesion
* @return String
*/
public String getProfesion() {
return (this.profesion);
}
/**
* setProfesion
* Establece la profesion
* @param String
*/
public void setProfesion(String profesion) {
this.profesion = profesion;
}
/**
* Resetea todas las propiedades a sus valores por defecto.
*
* @param mapping El mapping utilizado por la instancia.
* @param request El servlet request que estamos procesando.
*/
public void reset(ActionMapping mapping, HttpServletRequest request) {
this.action = "Create";

/**
* Valida las propiedades asignadas desde el HTTP request
* y devuelve un objeto <code>ActionErrors</code> que encapsula cualquier
* validación de error que haya sido encontrada. Si no se han encontrado errores
* , devuelve <code>null</code> o un objeto <code>ActionErrors</code> sin mensajes
* de error grabados.
*
* @param mapping El mapping utilizado por la instancia.
* @param request El servlet request que estamos procesando.
*/
public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if (getUsername().trim().compareTo("") == 0 || getUsername() == null) {

// El nombre de usuario es nulo, se devuelve mensaje de error
errors.add("alta",new ActionError("alta.username.nulo"));
}
if (getPassword().trim().compareTo("") == 0 || getPassword() == null) {

// El password es nulo, se devuelve mensaje de error
errors.add("alta",new ActionError("alta.password.nulo"));
}
return errors;
}//class
SaveAltaAction
/**
* SaveAltaAction.java
*/
package pxai.struts.alta.action;
import pxai.struts.alta.bean.AltaBean;
import com.jazztel.numeracionip.comun.Data;
/**
* Invoca al bean de lógica de negocio para procesar la migracion
* en caso de encontrar datos validos devuelve un objeto data en
* la sesión.
* @version 1.0 , date 13/2/02
*/
public final class SaveAltaAction extends Action {
/**
crear).
* <code>null</code>
*


*
*/
public ActionForward perform(ActionMapping mapping, ActionForm theForm,
// Extract attributes and parameters we will need


if (action == null)
action = "Create";
try{
/********************** LOGICA DE NEGOCIO
*****************************/
//Instancia el bean de lógica de negocio
AltaBean theAltaBean = new AltaBean();
//Invoca al proceso de carga y recoge el valor de vuelta

errors = theAltaBean.alta(theForm);
/********************** FIN de LOGICA DE NEGOCIO

**********************/
if (errors==null ) //Se ejecutó correctamente

else { //Hubo errores
}
}catch (Exception e) {
errors.add("action",new ActionError("alta.save.error"));
}
AltaBean
/**
* AltaBean.java
*/
package pxai.struts.alta.bean;
import com.jazztel.numeracionip.comun.Propiedades;
import com.jazztel.numeracionip.comun.DataService;
import com.jazztel.numeracionip.comun.Data;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

import pxai.struts.alta.form.AltaForm;
/**
* Implementa la lógica de negocio para el proceso Alta
* @author Pello Xabier Altadill Izura, AXPE
* @version 1.0
* date 23/1/02
*/
public class AltaBean {
/**
* @field Constante que identifica el estado libre en la tabla de estados
*/
private static final Integer _ESTADO = new Integer(1);
/**
* alta
*
* Da el alta de un usuario
* @param formulario con los datos a guardar
*
* @return null si no hay errores o ActionErrors con los
* errores capturados en caso de error.
*/
public synchronized ActionErrors alta (ActionForm theActionForm) {
//Instancia un objrcto ActionErrors para recoger los errores

ActionErrors theActionErrors = null;
Connection conn = null;
Statement stmn = null;
try {
// Casting de ActionForm a nuestro FORM concreto
AltaForm form = (AltaForm)theActionForm;
// AQUI SER REALIZA UNA CONEXION A UNA ORIGEN DE DATOS ODBC,

// PARA INSERTAR EL NUEVO USUARIO. NO RESULTA UNA FORMA MUY
CORRECTA
// DE HACERLO, MENOS AUN EN SERVIDORES DE APLICACIONES Y EN
APLICACIONES
// BIEN ESTRUCTURADAS, PERO PARA SIMPLIFICAR EL EJEMPLO SE HA
HECHO ASI.
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
conn =
DriverManager.getConnection("jdbc:odbc:usuarios","db_user","db_password");
// CREAMOS la SENTENCIA
stmn = conn.createStatement();
// Siii, ya se que es una forma poco elegante de alterar
// la BBDD, pero se trata de simplificar el ejemplo.
stmn.executeUpdate("INSERT INTO USUARIOS VALUES
('"+form.getUsername()+"','"+form.getPassword()+"',"+form.getEdad()+",'"+form.getFechana
cimiento()+"','"+form.getProfesion()+"')");
// Cerramos sentencia y conexion

stmn.close();
conn.close();
// Si llegamos aqui: Devolvemos objeto ActionErrors (nulo == sin

error)
return theActionErrors;
} catch(Exception e){
theActionErrors = new ActionErrors();
theActionErrors.add("alta",new ActionError("alta.bean.error"));
return theActionErrors;
}
} //Logica de Negocio
} // Fin class

confirmacionalta.jsp
<html:html>
<head>
<title>STRUTS :: ejemplo de ALTA :: Confirmacion ALTA</title>
</head>
<body>

<h3>Alta de usuario <bean:write name="altaForm" property="username"/>
correcta</h3>
</body>
</html:html>
errorAlta.jsp
<html:html>
<head>
<title>Error en el proceso de alta de usuario</title>
</head>
<body>
<table cellspacing="8" cellpadding="8" border="0" align="center">
<tr>
<td colspan ="3">
<H3><b>Se ha producido un error en la operacion.</b></H3>
</td>
</tr>
<td align="center">
<input type="button" name="volver" value="Volver"
onclick="javascript:history.back()">
</td>
</tr>
</table>
</body>

<h3><center><html:errors property="alta" /><center><h3>
</html:html>

Configuracion del fichero struts-config.xml para este sencillo caso.

Se debiera añadir, dentro de action mappings:


<form-bean name="altaForm" type="pxai.struts.alta.form.AltaForm"/>







<action path="/editAlta" type="pxai.struts.alta.action.EditAltaAction" name=""
scope="request" validate="false">
<forward name="success" path="/alta.jsp"/>
</action>
<action path="/saveAlta" type="pxai.struts.alta.action.SaveAltaAction" name="altaForm"
scope="request" input="/alta.jsp" validate="true">
<forward name="success" path="/confirmacionalta.jsp"/>
<forward name="failure" path="/erroralta.jsp"/>
</action>
Este sería el formulario de alta, al que accedemos a través de la url “editAlta.do”, tal como se
especifica en struts-config.xml. Al invocar editAlta.do, según el “mapa” de acciones de Struts,
se invoca la clase EditAltaAction y esta a su vez carga la JSP alta.jsp.

El formulario se envía a la url saveAlta.do, que según el “mapa” de acciones de struts

especificado en strtus-config.xml, provoca la carga de SaveAltaAcion; esta instancia invoca la
lógica de negocio (AltaBean) y devuelve un resultado (un objeto ActionErrors que puede estar
cargado o ser nulo). Si el bean de lógica de negocio devuelve un valor nulo en el ActionErrors,
todo ha ido correctamente y se mostrará la siguiente página.
En caso contrario, según el struts-config.xml se redirigiría el flujo a la página de error

“erroralta.jsp”, que sencillamente mostraría un mensaje de error al usuario.

TIPS
A continuación se explican una serie de soluciones para ciertas necesidades
frecuentes en la programación Web; básicamente se trata de modos de comunicar las
clases de la capa de negocio con los JSP.
Entre la logica de negocio y un JSP de presentación media una clase de la capa
Controller. Lo que las une a las tres es el la instancia actual de
javax.servlet.http.HttpServletRequest; En ese request se pueden cargar resultados que
podemos presentar mas tarde en JSP. Struts lo hace implicitamente con el las
instancias de lal clases Formulario.
-Mostrar valores de los Bean por pantalla:

Dentro de un objeto action, debemos guardar el Bean en la sesion:
..
// En un bean de negocio se puede cargar un objeto en el request
// para poder recuperarlo en el JSP con etiquetas STRUTS
// También se podría hacer en el objeto action (editXAction, saveXAction,
// etc...), aunque no quedaría muy limpio.
// Creamos el objeto Red, le asignamos valores, y lo añadimos a las
// propiedades del request, para poder recuperarlo en la JSP.
Red red2 = new Red();
red2.setNombre("SuperRed");
red2.setCodigo(747);
red2.setTipo("Red IP de telefonica");
red2.setIp("166.166.166.100");
request.setAttribute("red2",red2);
...
// en el JSP
<bean:write name="red2" property="nombre"
scope="request"/>
//eso sacaria por pantalla: SuperRed
-Mostrar valores en Iteracion.

Es parecido a mostrar un bean por pantalla, salvo que hay que definir un
bean de tipo Vector, Lista, etc...
// Supongamos que definimos un objeto llamado Redes
public class Redes extends Vector {...}
..
// Al igual que antes, en un Bean de negocio cargamos un objeto
// en el request para poder recuperarlo mas tarde.
// Creamos el objeto Redes, le asignamos valores, y lo añadimos a las
// propiedades del request, para poder recuperarlo en la JSP.
Redes redes = new Redes();
redes.addElement("www.el-mundo.es");
redes.addElement("www.elpais.es");
redes.addElement("www.cisco.com");
redes.addElement("www.a3n.tv");
request.setAttribute("misredes",redes);
...

// en el JSP utilizamos el tag logic:iterate

// donde:
//lista: bean en el que se guarda cada elemento de iteracion
//type: el tipo Java de ese elemento
//name: nombre del atributo que contiene los valores
// que debe coincidir con el que usamos en "setAttribute"
<logic:iterate id="lista" name="misredes"
type="java.lang.String">
<bean:write name="lista" /><br>
</logic:iterate>
// Lo cual mostrara por pantalla:
www.cisco.com
www.el-mundo.es
www.elpais.es
www.jazztel.com
www.a3n.tv
Nota: a traves de los tag logic se pueden realizar comapraciones de valores

y se puede condicionar los valores a mostrar. Para conocer estos y otros tags
mirar documentacion sobre tags.
(http://jakarta.apache.org/struts/userGuide/index.html)
(http://jakarta.apache.org/struts/api-1.0/org/apache/struts/taglib/logic/package-
summary.html)
-Mostrando valores de ResultSet.

El caso mas usual en aplicaciones web es el de mostrar el resultado de una consulta
por pantalla. Esto se puede hacer de manera parecida a la anterior, pero habria que
mapear el ResultSet a una estructura que pueda recorrerse iterativamente; segun la
documentacion de Struts la estructura puede ser Enumeration,Hashtable, Vector o un
array de Objetos.
-Fichero con mensajes y etiquetas:

AplicationResources.properties, debe estar colocado junto a los ficheros .class de
struts.Si se realizan cambios en el, hay que reiniciar jrun. Para mostrar estas
etiquetas, debe crearse el siguiente tag:
<bean:message key="mensaje01"/>
En el fichero de AplicationResources.properties
mensaje01=Introduzca el usuario
Para mostrar mensajes de error (los que cargamos en el ActionErrors)

En las clases actio, Form o Bean capturamos un error
ActionErrors errors = new ActionErrors();
errors.add(“alta”,new ActionError(“alta.error”));
saveErrors(errors);
En el fichero JSP añadimos el TAG:

<html:errors property="alta" />
En el fichero de AplicationResources.properties
alta.error=Se ha producido un error al dar de alta.

4. UNA APLICACIÓN COMPLETA: MECANO
Vale, ya hemos visto un par de ejemplos que pueden ayudarnos a iniciarnos con struts. Por
otro lado hemos conocido algunos prácticas recomendadas así como los errores típicos que
cometeremos al desarrollar una aplicación web. Pero es probable que si estas leyendo este
documento es porque estas involucrado en el desarrollo de una aplicación Struts compleja y
por tanto el ejemplo de HelloWorld no te sirve de mucho.
Presentando MECANO.
Mecano es una aplicación web para aprender mecanografía. Esta dividido en dos partes:
1.- Entorno administración: un usuario (admin) administra las lecciones, los usuarios, etc.. a
través de un entorno de administración.
2.- Entorno aprendizaje: es el entorno de los alumnos.
La aplicación es sencilla, se inicia con una pantalla de login en la que el usuario se valida y
accede a la pantalla en la que se explica la lección en la que está. De ahí puede pasar a
ejecutar la lección. Los resultados se van guardando en una BD relacional.
La aplicación esta desarrollada en java, esta guardada como una webapp (supuestamente
valida para cualquier servidor de aplicaciones) y utiliza el framework struts. Con esta
aplicación se pretende ilustrar el uso de struts en un entorno más “serio”, dentro de lo que
cabe, ya que se muestra el uso de struts para controlar la sesión, usar una BBDD (a través de
capas), mostrar mensajes de error, etc… que es lo típico en cualquier aplicación web.
La aplicación se puede descargar de http://www.pello.info
NOTAS IMPORTANTES:
Hasta ahora la aplicación podía dar problemas a quienes lo probarais ya que arrastraba
algunas dependencias con Sybase. Si, aunque se suponga que jdbc te hace la conexión
transparente, había que hacer algunas cosillas para que funcionara. Eso si: en una única clase,
La que encapsula toda la lógica de acceso. Por otro lado, se ha eliminada el acceso a la
conexión a BD mediante JNDI, y se ha limitado a una conexión estática con un puente
jdbc:ODBC. El fichero zip se incluye una BBDD access.
Si, es verdad, puede que no sea el mejor ejemplo de acceso transparente, pero de lo que se
trata es que funcione en un entorno simple, lo que interesa es mostrar los struts. Tal como esta
la aplicación ahora, se ha probado en un Tomcat3.2 que se puede montar en windows.

Algunos pantallazos de MECANO
Imagen de la pantalla de login (acción login.do)
Aquí una imagen de la pantalla de lección de mecanografía acción:(EditMecanoMecano.do)

5. ERRORES COMUNES CON STRUTS
- Erorres en el mapa de acciones.

Es muy frecuente a la hora de desarrollar aplicaciones con Struts no indicar correctamente el
nombre de una aplicación, de una clase de formulario, etc… hay que revisar el struts-config.xml
para comprobar que los nombres de clases que ahí se especifican son los correctos y se
corresponden con las clases generadas.
Hay que tener especial cuidado también (como en cualquier otra aplicación Java) con la
nomenclatura de los paquetes que precede al nombre de la clase.
De todas formas, la plataforma struts nos avisa sobre los errores de este tipo y nos dice que tal
acción no existe en el mapa, o que tal formulario tampoco esta definido o no se corresponde
con la acción. Lo veremos en forma de excepción de mapping.
A veces, como consecuencia de un copy-paste en el struts-config.xml, pueden quedar
mapeadas acciones que existen pero que no se corresponden con lo que queremos; en esos
casos no hay error por la inexistencia de un fichero, y se puede hacer difícil detectar el
problema.
La solución universal siempre será REVISAR bien los nombres hasta que nos lloren los ojos; la
evidencia empírica a demostrado que la mayoría de problemas en ese sentido vienen por
errores en los nombres.
- java.lang.NullPointerException
Este error será el pan nuestro de cada día en el desarrollo de Struts ya que los datos de los
formularios deben viajar desde una jsp pasando por 3 clases, y es fácil que no todos los datos
lleguen cargados. Lo que se recomienda es que cuando se desarrolle el Bean de lógica de
negocio, en principio solo se haga una traza de los valores del formulario, para comprobar que
llegan como se espera. Una vez depurado el paso de datos, conviene tener la costumbre
(como en cualquier otra aplicación, en cualquier otro lenguaje), de comprobar los objetos
para ver si realmente traen un valor distinto de nulo, y en caso afirmativo asignarlo. En una
sola linea se puede comprobar y asignar:
//aquí va un atentado contra la legibilidad:(<condicion>)?val1:val2;

codigo = (formulraio.getCodigo() != null) ?formulario.getCodigo():new Integer(0);
El formulario puede traer valores vacíos (Strings “”) o nulos. Dependiendo de nuestra lógica de
negocio habrá que comprobar lo que llega desde la jsp y transformarlo. Por ejemplo, en el caso
de una cadena de caracteres, en caso de venir vacía o con espacios quizá nos interese
convertirla a null:
// Dentro de la clase Form

public void setNombre (String nombre) {
if (nombre.trim().compareTo(“”) == 0) // si es nulo
this.nombre = null;
else
this.nombre = nombre;
}
o más brevemente:
public void setNombre (String nombre) {

this.nombre = (nombre.trim().compareTo(“”) == 0)?null:nombre;
}
- Errores en TAGs struts

El más frecuente suele ser dejar sin cerrar un tag, por ejemplo:
<html:text property=”username” maxlength=”10”>

Fallará estrepitosamente con un hermoso volcado de pila en torno al parseado.. etc.

Simplemente basta con cerrar el tag:
<html:text property=”username” maxlength=”10”/>

Ya se sabe que existen TAGs con apertura y cierre en distintas etiquetas y otros que no tienen
un cierre aparte. Ejemplo:
<a href=”index.html”>Home </a>

<img src=”images/icono.gif” alt=”hola”> <!—en html no obliga a cerrar
Æ
Los tags de struts y cualquier tag que nos hagamos, al ser parseados como XML deben
respetar sus normas más básicas, y una de ellas es CERRAR todos los tags, de una u otra
forma:
<bean:write name=”bean” property=”username” />
- Disable/Readonly campos: no editables

Es probable que por alguna razón de lógica de negocio algún campo de formulario no pueda
ser editable (y que solo se pueda cambiar de una manera indirecta). En los tags de struts
podemos incluir la siguiente opción:
<html:text property=”username” disabled=<%=true%> />
Pero OJO! Cuando mandemos el formulario, ese campo, tenga el valor que tenga en
apariencia, llegará como NULL. Aparentemente eso es lo que hace, en las pruebas que yo he
realizado, y para cuando leas esto seguramente habrán cambiado de versión, tanto Struts
como explorer y como Opera (Netscape/Mozilla seguirá languideciendo :>).
En fin, para que el campo no se pueda editar y no de problemas al editar mejor usar el atributo
readonly:
<html:text property=”username” readonly=<%=true%> />
Y no olvidar cerrar el TAG!!
- Cannot find bean org.apache.struts.taglib.html.BEAN in scope null

Suele aparecer con frecuencia, y como en los demás casos es debido a algún despiste o una
consecuencia del copy-paste. El mensaje se refiere a que se ha intentado mostrar información
de un bean que debiera ir metido en algún ambito de la aplicación (la sesion, la request, o la
página), y no estaba. Puede ocurrir al tratar de escribir el contenido de un bean con
<bean:write name=”cliente” property=”nombre” />
O también puede ser que hayamos creado un formulario con etiquetas struts y no la hayamos
encerrado en su correspondiente tag de form.

6. ENLACES, NOTAS, AUTOR
Enlaces:
-Página oficial: http://jakarta.apache.org/struts
-Bibliografía
Ya existen unos cuantos libros de O’rielly, en general suelen ser libros muy recomendables por
la claridad de los textos y el nivel de sus autores.
-Struts Fast Track: J2EE / JSP Framework by
-Mastering Jakarta Struts by James Goodwill. August 2002.
-Struts in Action by Ted Husted, Cedric Dumoulin, George Franciscus, and David Winterfeldt;
-The Struts Framework: Practical Guide for Programmers by Sue Spielman. November
2002
-Struts Kick Start by James Turner and Kevin Bedell - December 2002.
-Programming Jakarta Struts by Chuck Cavaness. November 2002.
-Professional Struts Applications: Building Web Sites with Struts, Object Relational
Bridge, Lucene, and Velocity by John Carnell, Jeff Linwood, Maciej Zawadzki
-Otros tutoriales:
Como no, mencionar el de un excompañero, Javier Antoniucci, consultor de Altran y
apasionado seguidor de Java y todo el mundo que le rodea.
Notas:
Este manual se inicio durante el desarrollo de una aplicación de struts en un entorno
profesional, trata de exponer la tecnología para desarrolladores con poco tiempo que necesiten
hacerse con esta tecnología y procura aclarar los problemas comunes que se encontrarán al
usar struts.
Autor:
Pello Xabier Altadill Izura

Ingeniero en Informática por la UPV-EHU
URL: http://www.pello.info
Emails: pello@pello.info, pello.altadill@terra.com

STRUTS

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

STRUTS

Diunggah oleh

Hak Cipta:

Format Tersedia

Autor: Fecha: Estado: Número Documento Revisión:

Pello (pello@pello.info) 23/06/2003 Borrador 1 2

Implementación del patrón MVC

(Actualizaciones y ejemplos en http://www.pello.info )

Agradecimientos: Mikel Alberdi (por calentarme la cabeza),a mis ex compañeros de AXPE, y

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 1

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 2

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 3

2. MVC: MODEL VIEW CONTROLLER

MVC o Model view Controller es un patrón de diseño aportado originariamente

El controlador es el encargado de redirigir o asignar una aplicación (un

Llendonos al esquema más básico de programa, tenemos una entrada o parámetros

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 4

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 5

La separación de capas como presentación, lógica de negocio, acceso a datos

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 6

Struts Framework (http://jakarta.apache.org/struts)

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 7

Veamos los diagramas correspondientes a ese caso:

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 8

Estos serían los pasos seguidos por la aplicación en el plano temporal.

Veamos como quedan esos siete elementos en diagramas

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 9

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 10

Estos serían los pasos seguidos por la aplicación en el plano temporal.

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 11

UN EJEMPLO SENCILLO DE STRUTS

Entrada de aplicación: ninguna

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 12

* respuesta HTTP (response) (o lo redirige a otro componente web que podria

// Extrae los atributos que se necesitan

El fichero JSP Kaixo.jsp

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 13

Configuracion del fichero struts-config.xml para este sencillo caso.

(Nota: debe reiniciarse el servidor de aplicaciones si se cambia este fichero)

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 14

UN EJEMPLO DE STRUTS MÁS COMPLEJO

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 15

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 16

// Extrae los atributos que se necesitan

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 17

Usuario:<html:text property="username" size="8" maxlength="8" /><br>

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 18

private String username = null;

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 19

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 20

ActionErrors errors = new ActionErrors();

if (getUsername().trim().compareTo("") == 0 || getUsername() == null) {

if (getPassword().trim().compareTo("") == 0 || getPassword() == null) {

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 21

* @param actionForm La instancia ActionForm que estamos utilizando (si la hay)

// Extract attributes and parameters we will need

String action = request.getParameter("action");

ActionErrors errors = null;

//Instancia el bean de lógica de negocio

AltaBean theAltaBean = new AltaBean();

//Invoca al proceso de carga y recoge el valor de vuelta

/********************** FIN de LOGICA DE NEGOCIO

if (errors==null ) //Se ejecutó correctamente

STRUTS, implementación del patrón MVC en Java - (Actualizaciones en http://pello.info/) 22

//Instancia un objrcto ActionErrors para recoger los errores

// AQUI SER REALIZA UNA CONEXION A UNA ORIGEN DE DATOS ODBC,

// Cerramos sentencia y conexion

// Si llegamos aqui: Devolvemos objeto ActionErrors (nulo == sin