Eduardo Saavedra A.

Desarrollo de aplicación en Struts

Desarrollo de aplicación de prueba.

Eduardo Saavedra A.21/10/2009

Tabla de contenido1 Introducción al primer Proyecto Struts................................................................................3

1.1 Introducción.................................................................................................................3

1.1.1 Requerimientos básicos:.......................................................................................3

1.2 Nociones de MVC.........................................................................................................4

2 Desarrollo del primer Proyecto Struts..................................................................................5

2.1 Interfaz de inicio...........................................................................................................6

2.2 Struts Config.................................................................................................................9

2.3 Vista............................................................................................................................11

2.4 Controlador................................................................................................................15

2.5 Interfaz de respuesta..................................................................................................18

2.6 Pruebas.......................................................................................................................19

1 Introducción al primer Proyecto Struts

1.1 IntroducciónSe generará un proyecto que mostrará lo básico y a su vez la base de struts.

Las aplicaciones en struts tiene la siguiente forma de ejecución en el servidor de aplicaciones:

Figura 1

Paso 1: El cliente (generalmente un navegador) genera una solicitud que es atendida por el Controller (un Servlet especializado).

Paso 2-3: El mismo se encarga de analizar la solicitud, seguir la configuración que se le ha programado en su XML y llamar al Action correspondiente pasándole los parámetros enviados. El Action instanciará y/o utilizará los objetos de negocio para concretar la tarea.

Paso 4-5-6: Según el resultado que retorne el Action, el Controller derivará la generación de interfaz a una o más JSPs, las cuales podrán consultar los objetos del Model a fines de realizar su tarea.

Struts al ser una framework MVC de desarrollo de aplicaciones WEB requiere que los desarrolladores tengan conocimiento o nociones básicas de estas aplicaciones.

Además la generación de interfaces visuales se basa totalmente en HTML.

1.1.1 Requerimientos básicos: Conocimientos en HTML Funcionamiento de aplicaciones WEB en general Programación JAVA

Sintaxis XML

1.2 Nociones de MVCModelo Vista Controlador (MVC) es un patrón de arquitectura de software que separa los datos de una aplicación, la interfaz de usuario, y la lógica de control en tres componentes distintos. El patrón MVC se ve frecuentemente en aplicaciones web, donde la vista es la página HTML y el código que provee de datos dinámicos a la página. El modelo es el Sistema de Gestión de Base de Datos y la Lógica de negocio, y el controlador es el responsable de recibir los eventos de entrada desde la vista.

Java bajo su plataforma J2EE posee varios frameworks para implementación MVC:

Java / J2ee Apache Struts Java / J2ee Apache Beehive Java / J2ee Apache Spring Java / J2ee Apache JavaServerFaces

Asimismo en otras plataformas como PHP y .NET:

PHP BSD Zend Framework PHP MIT CakePHP PHP GPL Symfony .NET Apache Spring .NET .NET MS-PL ASP.NET MVC

La idea del MVC se adopto fuertemente para el desarrollo de aplicaciones WEB dando gran espacio en el mercado para aplicaciones, escalables, seguras, robustas, “forzando” el bajo acoplamiento y alta cohesión.

Aunque se pueden encontrar diferentes implementaciones de MVC, el flujo que sigue el control generalmente es el siguiente:

1. El usuario interactúa con la interfaz de usuario de alguna forma (por ejemplo, el usuario pulsa un botón, enlace, etc.)

2. El controlador recibe (por parte de los objetos de la interfaz-vista) la notificación de la acción solicitada por el usuario. El controlador gestiona el evento que llega, frecuentemente a través de un gestor de eventos (handler) o callback.

3. El controlador accede al modelo, actualizándolo, posiblemente modificándolo de forma adecuada a la acción solicitada por el usuario (por ejemplo, el controlador actualiza el carro de la compra del usuario). Los controladores complejos están a menudo estructurados usando un patrón de comando que encapsula las acciones y simplifica su extensión.

4. El controlador delega a los objetos de la vista la tarea de desplegar la interfaz de usuario. La vista obtiene sus datos del modelo para generar la interfaz apropiada para el usuario donde se refleja los cambios en el modelo (por ejemplo, produce un listado del contenido del carro de la compra). El modelo no debe tener conocimiento directo sobre la vista.

5. La interfaz de usuario espera nuevas interacciones del usuario, comenzando el ciclo nuevamente.

2 Desarrollo del primer Proyecto StrutsTomando como base el documento StrutsLab1 se procederá a confeccionar la aplicación y siguiendo con el flujo expuesto en la fig1 se crearan os distintos archivos representantes de cada parte del framework.

El objetivo de la aplicación será crear un simple formulario que redireccionará mediante un botón a una página de respuesta mostrando los datos ingresados en el formulario.

Por medio de esta actividad se verá de forma práctica el flujo MVC que realiza Struts.

2.1 Interfaz de inicioDel laboratorio anterior se tomará el index.jsp encontrado en la carpeta raíz de WebPages que muestra NetBeans. Debería tener el siguiente contenido:

Con algo de conocimiento HTML y de los tags ofrecidos nativamente por Struts se debe llegar a lo siguiente:

Si bien no es HTML puro debido a que hay tags especiales, su forma es similar y contenida.De forma particular el significado de los tags es:

1. De la línea 1 a 5 se “importan” las “Tag libraries” que el archivo JSP utilizará.2. Entre las líneas 7 a 46 se encuentra el contenido a mostrar:

2.1. Las líneas 8 a 12 muestran las cabeceras a utilizar, esto es típico en el HTML, se utilizan los tags “meta”, “title”, “link”, “script”, etc.

2.2. De la 14 a la 45 está el cuerpo del HTML:2.2.1.El tag especial “html” en la línea 16 utiliza la tag library HTML llamada en la línea

4, este tag indica que se utilizará un FORM con un action especifico hasta la línea 43.

2.2.2.Luego se utiliza una “table” genérica del HTML, donde cada “tr” es una fila y cada “td” una columna, dentro de la tabla se aprecian varios tags “html” y unos “vean”

2.2.3.Los tags vean como el de la línea 21 espera a que llegue una variable por parte de la clase SaludaForm llamada error, esta clase debe tener sus respectivos get y set.

2.2.4.El tag “html” de la línea 26, 30 y 34 generan un campo de tipo texto con sus respectivas propiedades (nombre, edad, email)

2.2.5.El último de la línea 38 genera un botón “submit” con el valor Saluda.2.3. Finalmente en la línea 44 se suele llamar a un tag llamado errors, que se verá más

adelante.

Perfecto, veamos qué ocurre si se llama a la aplicación a través de un navegador, para esto se debe “ejecutar” el proyecto:

La respuesta es:

Si se ve la traza de este error, se puede llegar rápidamente a la conclusión:

“No se puede recuperar la definición para el Bean SaludaForm en la acción “/saluda”, esto hace referencia a las líneas 16/21 del jsp anterior.

2.2 Struts ConfigEn este momento se introducirá un elemento fundamental para Struts el cual es su archivo de configuración, llamado: struts-config.xml

Este archivo XML contiene todo lo relevante para el correcto funcionamiento de la aplicación, desde los mapeos hasta opciones detalladas de las acciones y vistas.

El error que lanzó tomcat hace referencia a que falta asociar una acción a un form Bean que utilizamos en el JSP.

El archivo struts-config.xml se encuentra en la carpeta WEB-INF del proyecto y por defecto se ve así:

En la línea 22 hay un “action”, esta configuración indica que: cada vez que se llame a /Welcome a través del navegador el controlador devolverá la página welcomeStruts, para ser desplegada al cliente.

Este config se cambiará al final del documento por lo siguiente (no editarlo aun!):

En la línea 23 se bautiza un Formulario “SaludaForm” cuyo path es /saluda, su scope “request” y notese el type que hace referencia a un package cl.esati.myfirst.controllers.SaludaAction

Dentro del action se crea un forward llamado “success” cuyo path a mostrar es la página success.jsp alojada e WEB-INF/pages

El forward se gatilla cuando el Action “SaludaAction” lo indica.

A continuación se verá como generar un Action mediante NetBeans

2.3 VistaEntonces se procederá primero a generar un ActionForm, cada pantalla (vista) de la aplicación web debería tener un ActionForm. Para crear uno en NetBeans:

Habiendo creado un package haciendo referencia a “views” crear un archivo de categoría Striuts de tipo ActionForm Bean:

Recordar que este Bean quedará en el package “views”.

Si se observa nuevamente el archivo struts-config.xml se verá que se ha actualizado:

Ahora se hace referencia a un form-bean mediante el nombre SaludaForm haciendo la llamada a la clase respectiva del package respectivo.

El contenido “SaludaForm” debe tener los mismos campos que se muestran en el jsp creado inicialmente, por lo tanto se deben tener atributos:

nombre edad email

Entonces la clase SaludaForm tendrá:

Nota: Favor de borrar lo que netbeans crea por defecto!

Ahora hay que generar los métodos get y set:

Y pinchar Generar

El archivo quedará así:

2.4 ControladorCon esto Struts entenderá como obtener y dejar datos en los bean.

Ahora falta crear una clase Action para llevar a ejecución la acción que corresponda según la interacción del usuario con la vista.

Dar el nombre SaludaAction y definir el Action Path /saluda

Luego seleccionar el Form Bean asociado al action y dejarlo como de scope Request:

Debería crearse en el struts-config.xml:

El archivo SaludaAction.java creado tendrá la siguiente estructura, por el momento no se editará, nótese la variable SUCCESS que representa a un string con valor “success”:

Luego agregar dentro del struts-config.xml de ese tag action el siguiente forward:

Esto indica que cuando el SaludaAction devuelva success (el string designado en el SaludaAction) se redirigirá a la página success.jsp dentro de la carpeta WEB-INF/pages

El scope debe ser request ya que se utilizará tan solo una vez, el path es el mismo del archivo .jsp del formulario, el nombre del action se encontrará asociado al FORM creado anteriormente (SaludForm), esto hará que el form se instancie cuando se instancie el Action.

Finalmente agregar al struts-config.xml el global forward

2.5 Interfaz de respuestaFalta crear la página “success.jsp” que se definió en el struts-config.xml:

Los tags bean:write representan los atributos que se llenaron al momento de hacer el “POST” del formulario del “index.jsp”.

2.6 PruebasSi se visita el index.jsp resultará lo siguiente