Introducción a Struts Flow

0
16738

En Autentia trabajamos constantemente con los frameworks mas avanzados para el
diseño de servicios web en
nuestros desarrollos. En esta línea, dedicamos especial interés a la
investigación y utilización de las extensiones de estos frameworks que faciliten y aporten mayor potencia al
diseño de una aplicación web.
Hoy os queremos mostrar una introducción al módulo Struts Flow
del framework Struts de cara al desarrollo de
aplicaciones web.

 

 

1. ¿Qué es Struts
Flow?

 

Struts Flow es un módulo de extensión del framework
Struts
dirigido a definir y gestionar los flujos de páginas dentro de una aplicación web.

 

El flujo de páginas de una
aplicación web consiste en la secuencia de páginas por
las que pasa dicha aplicación en función de la conversación que mantenga con el
usuario. Dependiendo de las opciones que escoja el usuario, resultados de las
operaciones de proceso…etc, la aplicación seguirá una
ruta de páginas especifica u otra.

 

Por ejemplo, el flujo de
páginas de una aplicación web sencilla podría ser el
siguiente:

 

 

 

La aplicación se dedica a
registrar los datos de los usuarios que la acceden. Desde la pagina inicial el
usuario selecciona la opción REGISTRAR para proceder a su registro. Se le
muestra una página donde debe introducir sus datos personales para completar el
registro. Una vez introducidos, la aplicación muestra una página confirmando el
registro si no se produjo ningún error, o bien ofrece al usuario la posibilidad
de volver a introducir sus datos correctamente si se produjo algún error.

 

Como puede observarse, la
forma más intuitiva de representar el flujo de páginas de una aplicación es con
un diagrama de estados. Si bien otros módulos de gestión de flujos similares,
como Spring Web Flow, utilizan
estructuras declarativas basadas en máquinas de estados, Struts Flow realiza una gestión de los flujos
de la aplicación basada en código javascript, es decir, en estructuras de control de flujo de
programación clásica (if, else,
etc).

 

 

Partiendo de este concepto,
los aspectos fundamentales que potencia Struts Flow son:

 

  • Proporcionar un motor capaz de capturar los
    flujos de páginas de una aplicación, integrándolo con algunos frameworks de uso habitual para desarrollo de
    aplicaciones web. 

 

 

  • Encapsulación de la lógica de los flujos de páginas como un
    módulo autónomo que puede reutilizarse en diferentes situaciones. Hay
    aplicaciones web específicas que suelen utilizar
    la misma lógica de flujo de páginas, como por ejemplo, aplicaciones tipo
    “carrito de la compra”, correo web, etc.

 

 

 

2. Instalación y requisitos

 

El ejemplo
sencillo que se estudiará más adelante en este documento, se desarrolló y
ejecutó en un entorno Windows XP que
disponía de la distribución Java j2sdk-1.4.2.
Esta distribución puede obtenerse gratuitamente desde la web
de SUN en el enlace:

 

http://java.sun.com/products/archive/j2se/1.4.2/index.html

 

 

Es necesario
obtener distribuciones del framework Struts, así como
de su módulo Struts Flow. Para
realizar el ejemplo que se comentará más tarde, se utilizó la ditribución strutsflow-0.2.zip, que pueden
obtenerse gratuitamente desde el enlace:

 

http://sourceforge.net/project/showfiles.php?group_id=49385&package_id=120079

 

 

Esta
distribución lleva incluido los archivos .jar para la distribución 1.1 de Struts. En cuanto a la versión de
Struts a
utilizar, una observación importante es que debe utilizarse la 1.1 o superiores
para el correcto funcionamiento con el módulo Struts Flow.

 

Una vez
descomprimido el archivo, será necesario que los siguientes archivos sean
visibles en el classpath:

 

  • struts-flow-0.2\lib\struts\commons-beanutils.jar

  • struts-flow-0.2\lib\struts\commons-collections.jar

  • struts-flow-0.2\lib\struts\commons-digester.jar

  • struts-flow-0.2\lib\struts\commons-lang.jar

  • struts-flow-0.2\lib\struts\commons-logging.jar

  • struts-flow-0.2\lib\struts\commons-validator.jar

  • struts-flow-0.2\lib\struts\jakarta-oro-2.0.6.jar

  • struts-flow-0.2\lib\struts\struts-1.1.jar

  • struts-flow-0.2\dist\struts-flow-0.2.jar

 

 

Se utilizó la
herramienta Ant
para compilar y empaquetar el ejemplo realizado. La distribución utilizada es apache-ant-1.6.5-bin.zip, que puede obtenerse gratuitamente desde el
siguiente enlace:

 

http://ant.apache.org/bindownload.cgi

 

 

Por último, para
deplegar el ejemplo se utilizó el contenedor de
aplicaciones web de Tomcat.
Se utilizó la distribución jakartatomcat-5.0.30.zip, que puede
obtenerse gratuitamente desde el enlace:

 

http://tomcat.apache.org/download-55.cgi

 

 

3. Un ejemplo sencillo

 

3.1. Idea

 

Para ilustrar el funcionamiento
y la forma de trabajar con Struts Flow se realizará una aplicación web
cuya funcionalidad será la siguiente:

 

  • Obtener nombre y apellidos del usuario a través
    de un formulario.

  • Comprobar que se introdujeron
    dichos datos en el formulario. Si no se introdujo alguno de ellos,
    informará al usuario de la situación de error y le ofrecerá la posibilidad
    de volver a introducirlos.

  • Si la captura de los datos
    anteriores se realiza correctamente, la aplicación muestra una página que
    envía un saludo al usuario.

 

 

El flujo de
páginas de la aplicación puede resumirse en el siguiente diagrama de estados:

 

 

 

 

3.2. Implementación del flujo de
páginas

 

Como se comentó
anteriormente, la gestión del flujo de la aplicación a través de Struts Flor se realiza a través de un programa
javascript.

 

En primer lugar, se declaran las variables que
utilizará la aplicación para obtener los datos del usuario y para mostrar
mensajes de error por pantalla.

 

 

var nombre;

var apellidos;

var mensaje=»»;

 

 

A continuación el programa
entra en un bucle infinito en el que gestionará la captura de los datos del
usuario.

 

Dentro de este bucle, en
primer lugar envía un formulario para que el usuario introduzca su nombre y
apellidos. Esto lo realiza a través de la función forwardAndWait. Esta función envía dicho formulario e
indica las variables que almacenarán los datos del usuario y el posible mensaje
de error qué podría mostrar la aplicación. El primer parámetro (“error”)
identifica el estado al que corresponde la página que mostrará la aplicación. Se
comentará más adelante como se enlaza un estado con su recurso de presentación
correspondiente.

 

 

forwardAndWait(«error»,

{ «nombre»     : nombre,

  «apellidos«  : apellidos,

  «mensaje»    : mensaje    } );

 

 

Tras el envío de este
formulario, esta función espera a que el usuario pulse Entrar para que se procese el formulario, y devolver el control de
nuevo al programa principal. El programa entonces verifica los datos del
usuario para decidir la siguiente acción en el flujo de la aplicación: si el
usuario no introdujo alguno de los datos (nombre o apellidos) le advertirá de
la situación de error y le dará la oportunidad de volver a introducirlos. Esto
se traduce en la inserción de un mensaje de error en la variable
correspondiente y una nueva iteración en el bucle principal. Si la inserción de
los datos fue correcta, se sale del bucle principal, es decir, no se vuelve a
enviar al usuario el formulario indicado anteriormente y se pasa al siguiente
estado del flujo de la aplicación.

 

 

nombre = getRequestParams().nombre;

apellidos = getRequestParams().apellidos;

 

if ((nombre==»») ||
(apellidos==»»))

         mensaje =
«Por favor, introduzca su nombre y apellidos»;

else

         break;     

 

           

Fuera del bucle principal se
encuentra el código necesario para que la aplicación pase al estado en que se
envía un saludo al usuario.

 

 

forwardAndWaitok«,

{ «nombre»     : nombre,

  «apellidos«  : apellidos} );

 

 

Puede observarse que en este caso sólo hace falta
enviar la información correspondiente a los datos del usuario (no hay que
mostrar mensaje de error). El estado “ok” tendrá
asociado un recurso de presentación que mostrará un saludo al usuario, cuyos
nombre y apellidos se especifican en las variables pasadas como parámetros a la
función forwardAndWait.

 

 

A modo de resumen, se
muestra a continuación el código completo de este programa javascript.

 

 

function main()
{

 

  var
nombre;

  var
apellidos;

  var
mensaje=»»;

 

  while
(true)

  {

       forwardAndWait(«error»,

       { «nombre»     : nombre,

         «apellidos«  : apellidos,

         «mensaje»    : mensaje } );

 

       nombre = getRequestParams().nombre;

       apellidos = getRequestParams().apellidos;

 

       if
((nombre==»») || (apellidos==»»))

            mensaje =
«Por favor, introduzca su nombre y apellidos»;

       else

            break;     

  }

 

  forwardAndWaitok«,

  { «nombre»     : nombre,

    «apellidos«  : apellidos} );

 

}

 

 

 

 

 

3.3. Integración del flujo de
páginas

 

Una vez implementado el
flujo de páginas, se mostrará a continuación como integrarlo con la aplicación web diseñada como ejemplo.

 

En el fichero strutsconfig.xml
deben definirse los siguientes action mapping y plug-in.

 

 

<struts-config>

 

  <action-mappings>

 

    <action    path=»/hello»

               typeautentia.struts.flow.FlowAction«

          classNameautentia.struts.flow.FlowMapping«>

         

      <set-property
property=»function» value=»main» />

 

      <forward
name=»error»          
path=»/hello.jsp«/>

      <forward
name=»ok»             
path=»/ok.jsp«/>

    </action>

 </action-mappings>  

 

 

 <plug-in classNameautentia.struts.flow.FlowPlugIn«>

    <set-property
property=»scripts» value=»/WEB-INF/hello.js»
/>

    <set-property
property=»debugger» value=»false» />

    <set-property
property=»timeToLive»
value=»600000″ />

 </plug-in>

 

 

</strutsconfig>

 

           

En el action mapping se indica el programa javascript que se
utilizará para la gestión del flujo de la aplicación, declarado en el elemento plug-in situado a continuación. En el action mapping se
indica también el recurso de presentación que se asociará a cada estado del flujo,
a través de los elementos forward. Como puede observarse, en este caso serán sendos
archivos .jsp .

 

 

3.4. Ejecución

 

Una vez compilado, empaquetado y desplegado el proyecto
en un contenedor de aplicaciones web (Tomcat, en este caso), la ejecución del ejemplo produce los
siguientes resultados. Se mostrará la correspondencia entre el flujo de páginas
de la aplicación y el diagrama de estados del mismo que se diseñó al principio.

 

 

1.
Instrucciones de la aplicación

 

 

 

 

 

 

 

2. Relleno
del formulario (error)

 

 

 

 

 

 

           

Se vuelve a la misma página y la lógica de validación
produce un mensaje de error.

 

 

 

 

 

 

3. Relleno
del formulario (ok)

 

 

 

 

 

 

           

La aplicación muestra entonces una página saludando
al usuario.

 

 

 

 

 

4. Fuentes

 

Página de Souceforge sobre Struts Flow:

http://struts.sourceforge.net/struts-flow/

 

Apache Ant:

http://ant.apache.org/

 

Apache Tomcat:

http://tomcat.apache.org/

 

 

 

 

 

 

 

Dejar respuesta

Please enter your comment!
Please enter your name here