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

Samuel Marrero Lorenzo [email protected] 1

J2EE – Modelos y Struts

Modelos de programación WebApache 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

4

Arquitectura Model 1

5

Modelo 1Aplicaciones 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

6

Arquitectura Model 2

7

Modelo 2Aplicaciones 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

8

Modelo MVC

9

Modelo MVC (2)

� El Controlador representado por un servletcentral:1. examina la petición solicitada y desvía el

procesamiento al JavaBean necesario2. 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:\java\JSP8-Modelo2\WEB-INF\src\ServletCompra.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 beande 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

20

Estructura Struts

21

Flujo de Control en 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 ejemploStruts1-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.java2. Crear la página JSP: pagina.jsp3. Configurar struts-config.xml4. Configurar web.xml

25

Struts1-HolaMundo (3)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 principalActionForm 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.java1. El método execute es invocado por el

ServletAction, al recibir la acción HolaMundo.do2. 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 mapeadoen el fichero struts-config.xml

27

Struts1-HolaMundo (5)� Pagina.jsp: c:\java\Struts1-HolaMundo\pagina.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

Struts1-HolaMundo (6)� 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


<param-name>debug</param-name><param-value>2</param-value>


<param-name>detail</param-name><param-value>2</param-value>


<param-name>validate</param-name><param-value>true</param-value>

</init-param><load-on-startup>2</load-on-startup>

</servlet>

29

Struts1-HolaMundo (7)� 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

32

Flujo de control en Struts

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 Beancorrespondiente, 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 FormsBeans?� ¿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 beanen el contexto de sesión se permitirá el uso del form bean en todas las peticiones web que llegan a la aplicación

36

EjemploStruts2-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-FormHTMLAcciones� Accion EditInsertar.java:

public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,HttpServletResponse response)

{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-FormHTMLUso 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-FormHTMLForm-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-FormHTMLForm-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 errorerrors.add("insertar",new ActionMessage(“insertar.nombre.nulo"));

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

// El password es nulo, se devuelve mensaje de errorerrors.add("insertar",new ActionMessage(“insertar.ciudad.nulo"));

}return errors; Devuelve los errores generados al ServletAction}

}

41

Struts2-FormHTMLConfiguració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-FormHTMLConfiguración de mensajes (2)

� Para configurar un recurso de mensajes:1. Crear un paquete donde guardar el recurso.

Ejemplo resources2. Crear un fichero de mensajes. Ejemplo

application.properties3. Definir el recurso en el fichero struts-config.xml:

� <message-resourcesparameter="resources.application" />

� El parámetro indica la localización del fichero (sin .properties)

43

Struts2-FormHTMLConfiguració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 datoseditInsertar.error=No se puedo abrir la pagina

� Escribir aquí los errores y mensajes personalizados de la aplicación

44

Struts2-FormHTMLUso 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-FormHTMLDefinició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-FormHTMLProbar 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, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

// Aquí se implementa la lógica de negocio// En este caso solo se redirige a la pagina JSPActionForward af = mapping.findForward(“exito"); return af;

} }

49

Procesamiento de petición en 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

Procesamiento de petición en 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() esllamado, pasando el nombre del siguiente recurso a llamar.� El método findForward() devuelve un objetoActionForward que es pasado al ActionServlet

� El objeto ActionForward contiene detalles de a dóndedeberí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 apropiadaerrors.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,HttpServletRequest request,HttpServletResponse response)

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 de Fuentes de Fuentes de Fuentes 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 Actiontry {

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-CliPoolComponentes

� Modelo:� Acciones: paquete actions

� EditInsertarAction: redirige a la pagina de inserción de clientes, c:\java\Struts4-CliPool\WEB-INF\src\actions\EditInsertarAction.java

� InsertarAction: inserta el registro con los datos introducidos en el formulario, c:\java\Struts4-CliPool\WEB-INF\src\actions\InsertarAction.java

65

Struts4-CliPoolComponentes (2)

� Modelo:� Acciones: paquete actions

� MostrarAction: muestra todos los clientes de la tabla ‘contactos’, c:\java\Struts4-CliPool\WEB-INF\src\actions\MostrarAction.java

� EliminarAction: elimina el cliente seleccionado, c:\java\Struts4-CliPool\WEB-INF\src\actions\ElminarAction.java

66


� Modelo:� Beans de estado del sistema (entidad): paquete beans

� CiudadBean: representa una ciudad, c:\java\Struts4-CliPool\WEB-INF\src\beans\CiudadBean.java

� ClienteBean: representa un cliente, c:\java\Struts4-CliPool\WEB-INF\src\beans\ClienteBean.java

� Beans de lógica de negocio: paquete beans� BDClientesBean: métodos estáticos para realizar la lógica de negocio, c:\java\Struts4-CliPool\WEB-INF\src\beans\BDClientesBean.java

67


� 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:\java\Struts4-CliPool\WEB-INF\src\form\ClienteForm.java

68


� 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-CliPoolConfiguración

� Ficheros de configuración:� web.xml: c:\java\Struts4-CliPool\WEB-INF\web.xml

� struts-config.xml: c:\java\Struts4-CliPool\WEB-INF\struts-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

Tiles para crear interfaces de 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

Tiles para crear interfaces de 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

Tiles para crear interfaces de usuario. Aproximaciones (3)� Plantillas Tiles:

� Define una ‘plantilla base’ o ‘estructura’ para un conjunto de páginas JSp

<%@ taglib uri=“strutsTiles" prefix="tiles" %><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

<%@ taglib uri=“strutsTiles" prefix="tiles" %><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

Tiles para crear interfaces de usuario. Aproximaciones (4)� 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:\java\Struts4-CliPool\paginas\plantillas\estructura.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:\java\Struts4-CliPool\paginas\plantillas\plantilla.jsp

76

Struts4-CliPool. Vista (2)

� Componentes fijos de la vista:� cabecera.jsp: c:\java\Struts4-CliPool\paginas\plantillas\cabecera.jsp

� menu.jsp: c:\java\Struts4-CliPool\paginas\plantillas\menu.jsp

� pie.jsp: c:\java\Struts4-CliPool\paginas\plantillas\pie.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:\java\Struts4-CliPool\paginas\insertar.jsp� …, en estas se define un cuerpo concreto

� Cuerpo de la página: � insertar_cuerpo.jsp: c:\java\Struts4-CliPool\paginas\insertar_cuerpo.jsp

� …, cuerpo concreto de cada página

Education

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