5. Curso Java Struts I (Framework para Java) - Curso 2005-2006

Samuel Marrero Lorenzo -
smarlor@iespana.es 1
J2EE – Modelos y Struts
Modelos de programación Web
Apache Jakarta Struts

2
Contenido
Patrón de diseño MVC
La framework Apache Struts
Instalación
Flujo de control en Struts
Procesamiento de peticiones
Control de errores
Manejo de Formularios
Librerías de etiquetas de Struts
Internacionalización
Ejemplos

3
Modelos de desarrollo de
aplicaciones web en Java
Los servlets son buenos ejecutando lógica de negocio,
pero no son tan buenos presentando información
JSPs son muy buenos presentando pero pésimos
introduciendo lógica programática en ellos
La combinación Servlet/JSPs es lo más común hoy en día
en el desarrollo de aplicaciones web
Dos arquitecturas:
Model-1: JSPs para presentación y control y JavaBeans para
la lógica
Model-2: Model-View-Controller = JavaBeans-JSPs-Servlets
MVC es tan común que se han desarrollado varias
infraestructuras en torno a este patrón de diseño:
Apache Struts
Java Server Faces

5
Modelo 1
Aplicaciones y limitaciones
Aplicaciones web simples, con JSP y Servlets.
El cliente accede directamente las páginas JSP.
El JSP contiene código embebido y tags que
acceden a un JavaBeans, el que a su vez contiene
lógica para acceder a una base de datos via JDBC.
Limitaciones:
Código Java de lógica de presentación embebido
en JSP
Consecuencias: mantenimiento y escalabilidad
complejas

7
Modelo 2
Aplicaciones y limitaciones
No hay lógica de presentación en el JSP, no
hay necesidad de demasiados scriptlets.
Las aplicaciones Web son más sencillas de
mantener y extender, ya que las vistas no
refieren unas a otras, y no hay lógica de
presentación en ellas.
El modelo MVC se conoce como modelo 2 en
entorno J2EE

9
Modelo MVC (2)
El Controlador representado por un servlet
central:
1. examina la petición solicitada y desvía el
procesamiento al JavaBean necesario
2. guarda resultado de procesamiento realizado por
JavaBeans en el contexto de la petición, la sesión
o la aplicación
3. transfiere el control a un JSP que lleva a cabo la
presentación de resultados
Ejemplo JSP8-Modelo 2: c:javaJSP8-
Modelo2WEB-INFsrcServletCompra.java

10
Modelo MVC (3)
El Modelo
JavaBeans (o EJBs para aplicaciones más
escalables) juegan el rol de modelo:
Algunos beans ejecutan lógica de negocio
Otros guardan datos
Proceso:
1. El servlet controlador invoca un método en
bean de lógica de negocio y éste devuelve un
o varios bean de datos
2. La vista JSP tiene acceso al bean de datos

11
Modelo MVC (4)
La Vista
Rol ejecutado por JSPs
Servlet Controlador transfiere control al
JSP después de haber guardado en un
contexto el resultado en forma de un bean
de datos
JSP usa jsp:useBean y
jsp:getProperty para recuperar datos
y formatear respuesta en HTML o XML

12
Modelo MVC (5)
En resumen:
Los beans o EJBs ejecutan la lógica de
negocio y guardan los resultados
Los JSPs proveen la información
formateada
Los servlets coordinan/controlan la
ejecución de los beans y los JSPs

13
Frameworks
Framework: término usado en programación orientada a objetos
para definir
un conjunto de clases que definen un patrón de diseño
y una estructura para solucionar un conjunto de problemas
relacionados
Los frameworks facilitan
El desarrollo de aplicaciones que cumplan esas características
La reutilización de código
Apache Struts es un marco de trabajo o framework que
implementa el modelo MVC
Las aplicaciones basadas en Struts consistirán de:
Código Java
Ficheros de configuración XML que configuran la framework para el
uso de nuestra aplicación

14
Apache Jakarta Struts
Implementación del Modelo 2/MVC que
facilita la creación de aplicaciones web
en Java
Creada por Craig McClanahan y donada
a la Apache Software Foundation en el
2000 (pertenece a Apache Jakarta)

15
¿Qué proporciona Struts?
Un servlet (ActionServlet) que actúa como controlador MVC
totalmente configurable
Clases base que son extendidas para implementar la lógica de la
aplicación web:
Struts Action
Struts ActionForm
Un rico conjunto de etiquetas personalizadas JSP que cooperan
con el controlador para su uso en la capa view de MVC
Varias opciones para la validación de entrada de usuario en
formularios HTML: ActionForm o Validator Framework
Mecanismos para el manejo y reporte de errores
Soporte para la internacionalización (i18n) a través de ficheros
de recursos y Java Locales
Soporte para fuentes de datos
Y más …..

16
Instalando Apache Struts I
Primero debemos tener Apache instalado en el equipo
Bajar la última versión de Apache Struts de:
http://www.apache.org/dist/jakarta/struts/binaries/
Crear un proyecto en eclipse para probar Struts
Copiar ficheros .tld en el directorio <jakarta-struts>/lib/ a
<proyecto>/WEB-INF:
struts-config.xml
struts-bean.tld
struts-html.tld
struts-logic.tld
struts-tiles.tld
tiles-def.xml

17
Instalando Apache Struts II
Copiar los ficheros .jar files de <jakarta-
struts>/lib a <proyecto>/WEB-INF/lib
:
commons-beanutils.jar
commons-collections.jar
commons-digester.jar
commons-logging.jar
jakarta-oro.jar
struts.jar

18
Documentación y ejemplos de
Struts
En el directorio webapps de la distribución
de Struts 1.2.4 se pueden encontrar varios
ficheros .war muy útiles:
struts-documentation.war
En el subdirectorio api/index.html se puede
encontrar documentación de Struts API
Si se ejecuta esta aplicación web en
http://localhost:8080/struts-documentation/ se puede
también obtener información detallada sobre el uso de
Struts
Ejemplos de uso de Struts:
struts-example.war
struts-blank.war base para la creación de
cualquier aplicación que use Struts
etc.

19
Probar el primer Struts
Una posibilidad es copiar struts-
blank.war en el directorio webapps de
Apache Tomcat
Esta aplicación web empaquetada
puede utilizarse para comenzar a
programar nuestras aplicaciones struts

22
Funcionamiento de Struts
En el ejemplo JSP8-Modelo 2: el servlet controlador
central ServletCompra.java
pregunta por la acción a realizar
Invoca al objeto de negocio que corresponda
En este entorno las acciones, a realizar por el servlet
(ServletAction),
deben estar mapeadas en el fichero struts-config.xml,
indicando la clase que se encargará de realizar dicha acción
Una acción se corresponderá con una clase Java (heredera
de la clase Action de Struts).

23
Primer ejemplo
Struts1-HolaMundo
Si quisieramos crear la aplicación Struts más simple
posible, por ejemplo una página con un saludo,
debiéramos hacer lo siguiente:
Una página JSP (la presentación)
Una clase Action (componente del controlador)
La clase Action debe definirse en el struts-config.xml
correctamente
Proceso:
1. El servlet controlador ServletAction (implícito a Struts)
recibe la acción de solicitud de la página
2. Mira en struts-config.xml qué clase se encarga de resolver
la acción y la instancia si no existe
3. La clase Action resuelve redirige el control a la página JSP

24
Struts1-HolaMundo (2)
Para desarrollar nuestro primer
ejemplo Struts debemos:
1. Crear la clase Action: HolaMundo.java
2. Crear la página JSP: pagina.jsp
3. Configurar struts-config.xml
4. Configurar web.xml

25
1. Crear la clase Action: HolaMundo.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;  Paquete donde está la clase Action
public final class HolaMundo extends Action  Extiende la clase Action
{
public ActionForward execute(ActionMapping mapping,  Método principal
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
{
// Redirige el control hacia la uri especificada
ActionForward af = mapping.findForward("pagina");  Esta uri está mapeada en
return af; el fichero struts-config.xml
}
}

26
Clase HolaMundo.java
1. El método execute es invocado por el
ServletAction, al recibir la acción HolaMundo.do
2. Este método recibe:
los mapeos de struts, un objeto ActionForm
y los objetos request, response
3. Finalmente redirige a la uri ‘pagina’, nombre
lógico correspondiente a la pagina.jsp mapeado
en el fichero struts-config.xml

27
Pagina.jsp: c:javaStruts1-HolaMundopagina.jsp
struts-config.xml:
<struts-config>
<action-mappings>
<action path="/HolaMundo" type="HolaMundo">
<forward name="pagina" path="/pagina.jsp"/>
</action>
</action-mappings>
…
</struts-config>
Url Clase Action
Uri lógico Pagina JSP

28
web.xml:
<web-app>
<servlet>  CONFIGURACION DE SERVLETACTION
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>application</param-name>  Fichero de recursos de la aplicación
<param-value>ApplicationResources</param-value>
</init-param>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>  fichero de configuración
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>validate</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>

29
web.xml (2):
  DEFINICION DE SERVLET MAPPING
<servlet-mapping>
<servlet-name>action</servlet-name>  Cualquier url del tipo *.do es considerada una acción
<url-pattern>*.do</url-pattern> por el servlet
</servlet-mapping>
<taglib>  DEFINICIÓN DE LAS LIBRERIAS DE ETIQUETAS
<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>strutsHtml</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>strutsLogic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>strutsTemplate</taglib-uri>
<taglib-location>/WEB-INF/struts-template.tld</taglib-location>
</taglib>
</web-apps>

30
Para probar el ejemplo
http://localhost:8080/Struts1-
HolaMundo/HolaMundo.do
Fíjate que las acciones están mapeadas en
el url como accion.do, en este caso
HolaMundo.do
La acción HolaMundo está definida en el
fichero struts-config.xml

31
Struts con formularios
El ejemplo que hemos visto no contiene
formularios, el trabajo con formularios en
Struts es algo más complejo
Clase ActionForm:
Un objeto ActionForm es instanciado cuando se
realiza una petición desde un formulario
Consiste en un JavaBean que extiende
ActionForm, con las mismas propiedades que el
formulario
Permite realizar la validación de los datos

33
Flujo de control en Struts (2)
La clase org.apache.struts.action.ActionServlet es
el eje de Struts, su controlador principal
Dada una petición de entrada HTTP desde un formulario:
El Controlador busca en el scope el ActionForm Bean
correspondiente, o lo crea si no existe, donde guarda los
parámetros de entrada
Valida los datos guardados y existieran errores, el controlador
llamaría de nuevo a la JSP con los valores establecidos
Si no existen errores, decide que objeto Action se debe invocar y
le pasa el objeto ActionForm creado
El objeto Action
Accede a los beans de lógica de negocio si lo necesita y
transfiere el control a la siguiente etapa de procesamiento de la
petición (típicamente un JSP).

34
Form-Beans
Los form beans creados por ActionServlet deben ser
implementados por el programador, extendiendo
org.apache.struts.action.ActionForm.
El programador deberá definir un conjunto de métodos getProp y
setProp y
Sobreescribir los métodos validate() y reset()
El ActionServlet usará los métodos para rellenar las propiedades
a partir del formulario y validarlo si se solicita
El ActionForm Bean se define en el struts-config.xml
El ActionForm tiene características que corresponden al Modelo
pero realmente pertenece a la Vista

35
¿Por qué se necesitan Forms
Beans?
¿Por qué no simplemente se accede a los parámetros de una
petición, en vez de usar un form bean como intermediario?
Razones:
Los Form beans pueden ser validados antes de que una acción sea
invocada
Si la propiedad validate de un elemento Action en el fichero
struts-config.xml contiene el valor true (por defecto), el método
validate será invocado
Si un form bean falla en la validación puede hacer que Struts envíe
al usuario de vuelta a la vista (JSP) desde la que se realizó el POST
en primer lugar, junto con un mensaje de error
Es importante asignar a la propiedad input del elemento action en
struts-config.xml una referencia a la vista que entregó el
formulario
Los form beans pueden ser usados por múltiples acciones o incluso
una aplicación completa
Si se configura al ActionController para que guarde un form bean
en el contexto de sesión se permitirá el uso del form bean en todas las
peticiones web que llegan a la aplicación

36
Ejemplo
Struts2-FormHTML
Este ejemplo presenta un formulario HTML y
en la página de resultado devuelve una tabla
con los valores recogidos
Componentes:
Acciones:
EditInsertarAction.java: primera acción que redirige a la
página InsertarCliente.jsp
InsertarAction.java: redirige a la página de resultados
ConfirmacionInsertar.jsp
Form-Beans:
InsertarForm.java: recoge y valida los datos introducidos
en el formulario

37
Struts2-FormHTML
Acciones
Accion EditInsertar.java:
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
{
Locale locale = getLocale(request);
MessageResources messages = getResources(request);
ActionErrors errors = null;
try {
// Inserta en el log definido para la aplicación
// el mensaje enviado como parámetro (opcional)
servlet.log(" Redirigiendo a pagina 'editInsertar'“);
//Redirige hacia la uri ‘editInsertar’
ActionForward af = mapping.findForward("editInsertar");
return af;
}
catch (Exception e)
{
…
return (mapping.findForward("error"));
}
}

38
Struts2-FormHTML
Uso de tags de Struts
Pagina: InsertarCliente.jsp
<%@ page language="java" %>
<%@ taglib uri="strutsHtml" prefix="html" %>  referencia a la librería de tags HTML
<html:html>
<head><title>STRUTS :: ejemplo de ALTA</title></head>
<body BGCOLOR="#FFFFFF">
<H1 ALIGN="CENTER"> Ejemplo 2: Struts</H1>
<H2 ALIGN="CENTER"> Rellena el siguiente formulario y pulsa ENVIAR </H2>
<html:errors/>  Muestra los errores que hubieron en el form
<html:form action="/Insertar.do" >  Formulario
<TABLE><TR><TD> Escribe tu nombre:</TD>
<TD><html:text property="nombre" size="20" maxlength="20" /></TD>
</TR><TR> <TD>Selecciona tu ciudad: </TD><TD>
<html:select property="ciudad">
<html:option value="">Selecciona ...</html:option>
<html:option value="1">Las Palmas de GC</html:option>
…
</html:select>
</TD></TR><TR>
</TABLE>
<html:submit property="insertar" value="Insertar"/>
</html:form>
</body>
</html:html>

39
Struts2-FormHTML
Form-Bean
Form-Bean: InsertarForm.java
import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.*;
public final class InsertarForm extends ActionForm {
private String nombre = null;
private String ciudad = null;
public String getNombre() {
return (this.nombre);
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getCiudad() {
return this.ciudad;
}
public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}

40
Struts2-FormHTML
Form-Bean (2)
public void reset(ActionMapping mapping, HttpServletRequest request) {}
/**
* Valida las propiedades asignadas desde el HTTP request y devuelve un objeto ActionErrors que encapsula cualquier
* validación de error que haya sido encontrada. Si no se han encontrado errores, devuelve null o un objeto ActionErrors sin
* mensajes de error grabados.
*/
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if (getNombre().trim().compareTo("") == 0 || getNombre() == null)
{
// El nombre de usuario es nulo, se devuelve mensaje de error
errors.add("insertar",new ActionMessage(“insertar.nombre.nulo"));
}
if (getCiudad().trim().compareTo("") == 0 || getCiudad() == null)
{
// El password es nulo, se devuelve mensaje de error
errors.add("insertar",new ActionMessage(“insertar.ciudad.nulo"));
}
return errors;  Devuelve los errores generados al ServletAction
}
}

41
Struts2-FormHTML
Configuración de mensajes
Struts permite configurar los mensajes de la
aplicación, para que luego sean referenciados
desde la Vista o páginas JSP
Esto permite
Definir los mensajes en las páginas
Definir mensajes para diferentes idiomas
(internacionalización)
Definir los mensajes de error

42
Struts2-FormHTML
Configuración de mensajes (2)
Para configurar un recurso de mensajes:
1. Crear un paquete donde guardar el recurso.
Ejemplo resources
2. Crear un fichero de mensajes. Ejemplo
application.properties
3. Definir el recurso en el fichero struts-config.xml:
<message-resources
parameter="resources.application" />
El parámetro indica la localización del fichero (sin
.properties)

43
Struts2-FormHTML
Configuración de mensajes (3)
Fichero application.properties:
prompt.nombre=Introduce tu nombre:
prompt.ciudad=Selecciona tu ciudad:
prompt.email=Escribe tu email:
prompt.telefono=Escribe tu teléfono:
insertar.ciudad.nulo=Campo ciudad obligatorio
insertar.nombre.nulo=Campo nombre obligatorio
insertar.error=No se pudo insertar registro en la base de datos
editInsertar.error=No se puedo abrir la pagina
Escribir aquí los errores y mensajes personalizados
de la aplicación

44
Struts2-FormHTML
Uso de tags
Pagina ConfirmacionInsertar.jsp
<%@ page language="java" %>
<%@ taglib uri="strutsBean" prefix="bean" %>
<%@ taglib uri="strutsHtml" prefix="html" %>
<html:html>
<head><title>Ejemplo Struts 2 - FormHTML</title></head>
<body BGCOLOR="#FFFFFF">
<H1 ALIGN="CENTER"> Ejemplo 2: Struts-FormHTML</H1>
<H2 ALIGN="CENTER"> Validación correcta de los siguientes datos </H2>
<TABLE BORDER=1>
<TR><TD> Nombre </TD><TD> Ciudad </TD></TR>
<TR>
<TD> <bean:write name="insertarForm" property="nombre"/> </TD>
<TD> <bean:write name="insertarForm" property="ciudad"/> </TD>
</TR><TR>
</TABLE>
<html:link page='/EditInsertar.do'>Probar de nuevo</html:link>
</body>
</html:html>
En esta pagina JSP escribimos los valores recuperados del form bean insertarForm

45
Struts2-FormHTML
Definición de form-bean y acciones
Fichero struts-config.xml:
<struts-config>

<form-beans>
<form-bean name="insertarForm" type="form.InsertarForm"/>
</form-beans>
<!– Definiciones de Action mappings -->
<action-mappings>
<action path="/EditInsertar" type="action.EditInsertarAction">
<forward name="editInsertar" path="/paginas/InsertarCliente.jsp"/>
</action>
<action path="/Insertar" type="action.InsertarAction" name="insertarForm"
scope="request" input="/paginas/InsertarCliente.jsp" validate="true">
<forward name="insertar" path="/paginas/ConfirmacionInsertar.jsp"/>
</action>
</action-mappings>

46
Struts2-FormHTML
Probar el ejemplo
http://localhost:8080/Struts2-
FormHTML/EditInsertar.do
Si los datos solicitados no son
insertados se muestran mensajes de
error
Si no existen errores se muestra una
tabla con los valores

47
Procesamiento de una petición
en Struts
Si el cliente envía la petición:
http://localhost:8080/Struts2-FormHTML/EditInsertar.do
El ActionServlet de Struts quita la extensión
(.do) y mira la acción correspondiente en el fichero
de configuración Struts para la acción
EditInsertar
Si la encuentra encontrará o creará una instancia del
‘tipo’ (type) indicado: EditInsertarAction
El método perform() en Struts 1.0 o execute()
en Struts 1.1 será invocado en el objeto
EditInsertarAction:
Este es el lugar donde la lógica de negocio de la petición es
ejecutada

48
Procesamiento de petición en
Struts (2)
public class EditInsertarActionEditInsertarActionEditInsertarActionEditInsertarAction
extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm actionForm,
throws IOException, ServletException {
// Aquí se implementa la lógica de negocio
// En este caso solo se redirige a la pagina JSP
ActionForward af = mapping.findForward(“exito");
return af;
}
}

49
Struts (3)
De los cuatro parámetros recibidos en
execute(), ActionMapping y
ActionForm son específicos a Struts
El objeto ActionMapping contiene
información de configuración proveniente de
struts-config.xml file.
El objeto ActionForm contiene el bean del
formulario que fue inicializado por el
ActionServlet al procesar la petición

50
Struts IV
En el mapeo de la acción EditInsertarAction
hay dos posibles forward definidos:
Uno con el nombre “exito" y otro
“error“
Si el método execute() se completa sin errores el
método ActionMapping.findForward() es
llamado, pasando el nombre del siguiente recurso a
llamar.
El método findForward() devuelve un objeto
ActionForward que es pasado al ActionServlet
El objeto ActionForward contiene detalles de a dónde
debería el ActionServlet enviar la petición (contiene el
path del JSP que va a visualizar los resultados)

51
Dynamic Action Forms
Son subtipos de ActionForms creados de manera declarativa en
struts-config.xml
No hace falta escribir el código del Form-Bean ya que las propiedades
se declaran en el fichero de configuración
Una o varias propiedades dinámicas pueden ser pasadas a una
instancia de org.apache.struts.action.DynaActionForm
<form-bean name=“insertarForm”
type=“org.apache.struts.action.DynaActionFormorg.apache.struts.action.DynaActionFormorg.apache.struts.action.DynaActionFormorg.apache.struts.action.DynaActionForm”>
<formformformform----propertypropertypropertyproperty namenamenamename=“nombre”
typetypetypetype=“java.lang.String”/>
<form-property name=“ciudad”
type=“java.lang.String”/>
</form-bean>

52
Recursos de String/Manejo de
Errores
Recursos de String
Todos los strings usados en mensajes en JSPs tanto de datos de aplicación
como de errores puedes ser colocados en un fichero de recursos
(ApplicationResources.properties)
Struts proporciona etiquetas personalizadas JSP tags para acceder a estos
recursos
<bean:message key="global.title"/>
Manejo de errores
Se recomienda que el manejo de errores se lleve a cabo dentro del método
execute() y el control se transfiera a la vista apropiada
errors.add(“insertar",new ActionError("error.insertar"));
Struts proporciona un mecanismo separado para permitir la implementación
de un manejador global de excepciones
Struts proporciona etiquetas JSP que ayudan en la visualización de los
errores en tu JSP:
<html:errors property=“insertar”/>

53
Internationalization i18n
Struts soporta internacionalización a través de ficheros de recursos, sus
librerías de etiquetas personalizadas y Java Locales
Se pueden definir strings a visualizar en tu fichero de recursos, y luego ser
usados en tus JSPs
Los strings del idioma por defecto se guardan en el fichero
ApplicationResources.properties
Otros ficheros de recursos adicionales pueden ser definidos que incluyen el
idioma a usar en el nombre del fichero.
Ejemplo:
ApplicationResources_en.properties (Contiene mensajes en Inglés)
ApplicationResources_es.properties (Contiene mensajes en Español)
Para cambiar el idioma preferido en IE: Tools Internet Options Languages
Los navegadores envían la cabecera HTTP Accept-Language en cada
petición que indica cuál es el idioma preferido por el usuario
Los ficheros de recursos deben colocarse en un lugar accesible desde el
CLASSPATH de la aplicación web, por ejemplo, debajo del directorio WEB-
INF/classes

54
Manejo de errores en Struts
Struts define la clase ActionErrors que mantiene una colección de objetos
ActionError.
ActionErrors errores = new ActionErrors();
errores.add (“insertar”,
new ActionError("error.insertar"));
addErrors(request,erroresaddErrors(request,erroresaddErrors(request,erroresaddErrors(request,errores););););
return (new ActionForward (mapping.findForward(“error")));
El código añade un sólo objeto ActionError a la colección, pero si se llevase a
cabo validación de los campos de un formulario varios errores podrían ser
mostrados.
Luego devuelve una instancia de ActionForward que redirige a “error".
El ActionServlet guardará en el objeto request el objeto ActionErrors
bajo un nombre bien conocido por Struts:
request.setAttribute( Action.ERROR_KEY, errores);
Este objeto ActionErrors es ahora disponible a cualquier página o acción
consecutiva.
La página JSP “error” anterior debería tener un área donde se mostrasen los
errores producidos.
El string usado para construir un objeto ActionError no es un mensaje de
error sino que un identificador de un recurso (i18n Struts)

55
Manejo de errores en Struts
(2)
public class InsertarAction extends org.apache.struts.action.Action {
public ActionForward execute(ActionMapping mapping,
ActionForm actionForm,
throws IOException, ServletException {
ActionErrors errors = new ActionErrors();
try {
// lógica de negocio
} catch(SQLException e) {
errors.add(“insertar”, new ActionError(“error.insertar"));
}
if (!errors.empty()) {
saveErrors(requestsaveErrors(requestsaveErrors(requestsaveErrors(request, errors);, errors);, errors);, errors);
ActionForwardActionForwardActionForwardActionForward afafafaf ==== mapping.findForward(mapping.findForward(mapping.findForward(mapping.findForward(““““errorerrorerrorerror");");");");
return af;
}
request.setAttribute(Message.MESSAGE_NAME, message);
ActionForward af = mapping.findForward(“exito");
return af;
}
}

56
Configurando Struts
Como en toda framework se minimiza el código Java
a escribir y se maximiza la configuración a través de
ficheros XML
Struts se configura a través struts-config.xml
Leído por la framework cuando arranca
Contiene:
Fuentes de datos (data-sources)
Form beans, variaciones de JavaBeans.
Ejecutan una petición basado en una entrega de un formulario.
Son poblados por el controlador con los datos del formulario
Llevan a cabo validación de datos
Son procesados por objetos Action
Global forwards y
ActionMappings
Mapean el nombre de una acción a un objeto Action

57
Configuración de un
pool de conexiones
<struts-config>
<datadatadatadata----sourcessourcessourcessources>
<data-source>  Fuentes deFuentes deFuentes deFuentes de datosdatosdatosdatos (Pool de(Pool de(Pool de(Pool de conexionesconexionesconexionesconexiones))))
<set-property property= "autoCommit" value="false"/>
<set-property property= "description" value="MessageBoard"/>
<set-property property= "driverClass" value="..SQLServerDriver"/>
<set-property property= "maxCount" value="4"/>
<set-property property= "minCount" value="2"/>
<set-property property="password" value=""/>
<set-property property= "url“ value="someurl"/>
<set-property property= "user" value="someuser"/>
</data-source>
</data</data</data</data----sources>sources>sources>sources>

<formformformform----beans>beans>beans>beans>
<form-bean name=“insertarForminsertarForminsertarForminsertarForm“ type= “form.InsertarFormform.InsertarFormform.InsertarFormform.InsertarForm"/>
</form-beans>

<globalglobalglobalglobal----forwardsforwardsforwardsforwards>
<forward name=“errorerrorerrorerror" path="////error.jsperror.jsperror.jsperror.jsp"/>
</global-forwards>
…

58
DataSources en Struts
El acceso a bases de datos suele hacerse en los objetos de lógica de
negocio. En estos ejemplos se realiza en las clases Action
try {
DataSource dataSource = getDataSource(request);
con = dataSource.getConnection();
}
El código arriba muestra otra característica de Struts, la habilidad de
configurar y usar referencias a javax.jdbc.DataSources
El extracto de struts-config.xml anteriormente mostrado tiene una
sección <data-sources> para configurar las data sources de la
aplicación.
Struts provee las clases GenericDataSource y
GenericConnection que son wrappers sobre los objetos JDBC
Connections y DataSources definidos en el fichero de
configuración.

59
Struts Tag Libraries
Documentadas en http://www.onjava.com/lpt/a/4034
La framework Struts proporciona un conjunto de 6
librerías de etiquetas, que asisten en la tarea de la
creación de la vista de MVC para evitar incluir código
Java en los JSPs:
Bean Tags
HTML Tags
Logic Tags
Nested Tags
Tiles Tags
Las funcionalidad de las etiquetas definidas en las
librerías Bean y Logic es también provista por las
librerías core y fmt de JSTL
Se recomienda el uso de las librerías en JSTL

60
HTML Tags
Estas etiquetas son principalmente usadas para:
Crear formularios de entrada de datos y
Otras utilidades para visualizar interfaces basados en HTML.
Algunas de las acciones más útiles son:
base genera un elemento HTML <base>
errors condicionalmente visualiza un conjunto
acumulado de mensajes de error
form define un formulario de entrada
text visualiza un campo de entrada de tipo texto
messages condicionalmente visualiza un conjunto de
mensajes acumulados
submit visualiza un botón de entrega
Etc.

61
Logic Tags
Usadas para:
Iterar sobre colecciones
Generación condicional de salida, y
Flujo de aplicación
Algunas de las acciones más útiles son:
present genera el contenido de marcado dentro de esta
etiqueta si el valor indicado es encontrado en esta petición
notPresent lo opuesto a present
iterate repite el contenido anidado dentro de esta
etiqueta al iterar sobre una colección
forward transfiere control a la página especificada por
la entrada ActionForward.
Etc.

62
Tiles Tags (Framework)
La librería de etiquetas Tiles es un super-conjunto de la librería
Templates
Intenta evitar la duplicación de contenido de lenguaje de
marcado dentro de una aplicación web con respecto al look-
and-feel de un portal:
Un mecanismo normalmente utilizado es usar la directiva
jsp:include para añadir cabeceras/menús y pies de páginas a
un portal web
Tiles reduce el tamaño de código redundante en una aplicación
web y separa el contenido de la visualización del mismo de
manera más eficiente
Tiles define Layout Managers para JSPs
Su objetivo principal es evitar en los JSPs contenido de marcado
que corresponda con el look-and-feel del portal factoriza este
marcado, de tal manera que la modificación del layout sea
sencilla y eficiente

63
Ejemplo: Struts4-CliPool
Este ejemplo implementa una pequeña
aplicación para insertar, mostrar y
eliminar clientes de la base de datos
‘agenda’.
Características:
Pool de conexiones con Oracle
Validación de datos y muestra de errores
Uso de Tiles para plantillas JSP

64
Struts4-CliPool
Componentes
Modelo:
Acciones: paquete actions
EditInsertarAction: redirige a la pagina de
inserción de clientes, c:javaStruts4-
CliPoolWEB-
INFsrcactionsEditInsertarAction.java
InsertarAction: inserta el registro con los datos
introducidos en el formulario, c:javaStruts4-
CliPoolWEB-INFsrcactionsInsertarAction.java

65
Struts4-CliPool
Componentes (2)
Modelo:
Acciones: paquete actions
MostrarAction: muestra todos los clientes de la
tabla ‘contactos’, c:javaStruts4-CliPoolWEB-
INFsrcactionsMostrarAction.java
EliminarAction: elimina el cliente seleccionado,
c:javaStruts4-CliPoolWEB-
INFsrcactionsElminarAction.java

66
Struts4-CliPool
Componentes (3)
Modelo:
Beans de estado del sistema (entidad): paquete
beans
CiudadBean: representa una ciudad, c:javaStruts4-
CliPoolWEB-INFsrcbeansCiudadBean.java
ClienteBean: representa un cliente, c:javaStruts4-
CliPoolWEB-INFsrcbeansClienteBean.java
Beans de lógica de negocio: paquete beans
BDClientesBean: métodos estáticos para realizar la lógica
de negocio, c:javaStruts4-CliPoolWEB-
INFsrcbeansBDClientesBean.java

67
Struts4-CliPool
Componentes (4)
Modelo-Vista: los form-beans tienen
características del Modelo pero
realmente pertenecen a la Vista
Form-Beans: paquete form
ClienteForm: asociado al formulario de
inserción de clientes, c:javaStruts4-
CliPoolWEB-INFsrcformClienteForm.java

68
Struts4-CliPool
Componentes (5)
Vista: dieciocho páginas JSP que
representan cada una de las vistas
Plantillas: se usan Tiles para generar
plantillas de las vistas.
Páginas JSP

69
Struts4-CliPool
Configuración
Ficheros de configuración:
web.xml: c:javaStruts4-CliPoolWEB-
INFweb.xml
struts-config.xml: c:javaStruts4-
CliPoolWEB-INFstruts-config.xml
El fichero de configuración define:
Pool de conexiones
Fichero de recursos de mensajes

70
Tiles para crear interfaces de
usuario
A la hora de un desarrollo web medio-
grande es un buen propósito organizar
los componentes de la Vista
A continuación se ven diferentes
soluciones para conseguir este objetivo
El ejemplo Struts4-CliPool sigue una
organización de plantillas (Tiles)

71
usuario. Aproximaciones
JSP básicos:
incorporan en una página todo el código para la
página (cabecera, menú, pie y cuerpo)
No aprovechan las partes comunes
Uso de <jsp:include>:
Usan esta directiva para incluir las partes comunes
en las diferentes páginas
Aumentan algo el número de páginas JSP pero
disminuyen el código de las mismas (reutilización)
Inconveniente: si se cambia el diseño base de las
páginas modificar el código de todas ellas

72
usuario. Aproximaciones (2)
Uso básico de Tiles:
<%@ taglib uri=“strutsTiles" prefix="tiles" %>
<tiles:insert page="/cabecera.jsp" flush="true"/>
Mismas ventajas y desventajas que <jsp:include>
Tiles con extracción de cuerpos:
Insertar con Tiles todos los componentes de la
página
Permite la reutilización del cuerpo y de los demás
componentes de la página

73
Plantillas Tiles:
Define una ‘plantilla base’ o ‘estructura’ para un conjunto de páginas JSp
<html><body>
<tiles:insert attribute=“cabecera"/>
<tiles:insert attribute=“cuerpo"/>
<tiles:insert attribute=“pie"/>
</body></html>
En cada página que use la plantilla Tile
<tiles:insert page="/plantilla.jsp" flush="true">
<tiles:put name=“cabecera" value="/cabecera.jsp"/>
<tiles:put name=“cuerpo" value="/cuerpo1.jsp"/>
<tiles:put name=“pie" value="/pie.jsp"/>
</tiles:insert>

74
Struts y Tiles:
Permite definir las páginas que usan plantillas en el fichero struts-
config.xml
<component-definitions>
<definition name=“def1" path="/estructura.jsp">
<put name=“cabecera" value="/cabecera.jsp"/>
<put name=“pie" value="/pie.jsp"/>
<put name=“cuerpo" value="/cuerpo1.jsp"/>
</definition>
</component-definitions>
Para referirse a ella en una action
<action path="/accion" type=“ClaseAction">
<forward name=“exito" path=“def1"/>
</action>
Por último decir que la aproximación a utilizar depende de las
características de la aplicación web y de su escalabilidad

75
Struts4-CliPool. Vista
Aproximación utilizada ‘Plantillas Tiles’
Plantilla base ‘estructura.jsp’ conteniendo una
cabecera, menu, pie y cuerpo
c:javaStruts4-
CliPoolpaginasplantillasestructura.jsp
Plantilla.jsp: define una plantilla concreta a
partir de la estructura fijando la cabecera, el
pie y el menu de las páginas que la usan.
c:javaStruts4-
CliPoolpaginasplantillasplantilla.jsp

76
Struts4-CliPool. Vista (2)
Componentes fijos de la vista:
cabecera.jsp: c:javaStruts4-
CliPoolpaginasplantillascabecera.jsp
menu.jsp: c:javaStruts4-
CliPoolpaginasplantillasmenu.jsp
pie.jsp: c:javaStruts4-
CliPoolpaginasplantillaspie.jsp

77
Struts4-CliPool. Vista (3)
Vista: las páginas de la vista usan la plantilla
y se definen mediante dos páginas
Página:
insertar.jsp: c:javaStruts4-CliPoolpaginasinsertar.jsp
…, en estas se define un cuerpo concreto
Cuerpo de la página:
insertar_cuerpo.jsp: c:javaStruts4-
CliPoolpaginasinsertar_cuerpo.jsp
…, cuerpo concreto de cada página

5. Curso Java Struts I (Framework para Java) - Curso 2005-2006

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a 5. Curso Java Struts I (Framework para Java) - Curso 2005-2006

Similar a 5. Curso Java Struts I (Framework para Java) - Curso 2005-2006 (20)

Último

Último (20)

5. Curso Java Struts I (Framework para Java) - Curso 2005-2006