Desarrollo de aplicación en Struts

Eduardo Saavedra A.
Desarrollo de
aplicación en Struts
Desarrollo de aplicación de prueba.
Eduardo Saavedra A.
21/10/2009
Tabla de contenido
1
Introducción al primer Proyecto Struts ................................................................................. 3
1.1
Introducción .................................................................................................................. 3
1.1.1
1.2
2
Requerimientos básicos: ....................................................................................... 3
Nociones de MVC .......................................................................................................... 4
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ón
Se 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 MVC
Modelo 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 Struts
Tomando 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 inicio
Del 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 Config
En 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 Vista
Entonces 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 Controlador
Con 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 respuesta
Falta 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 Pruebas
Si se visita el index.jsp resultará lo siguiente