Mi primera Web con Struts

2
233454

1       
Introducción

 

En este manual vemos cómo crear el embrión de
un portal web con Struts, utilizando Tomcat 5 y Eclipse 3.1

 



 

 

2       
Introducción a Tomcat y Struts

La primera vez que te enfrentas al framework de Struts para
realizar aplicaciones Web, aparece todo un conjunto de nuevos conceptos ligados
a este framework que te pueden hacer perder la visión de conjunto.

 

En este tutorial vamos a a aprender lo siguiente:

§   
Instalar el Tomcat y el framework de Struts

§   
Crear el esqueleto de una aplicación web en Eclipse

§   
Trabajar con CVS y Eclipse para compartir nuestro proyecto

§   
Compilar la aplicación y ejecutarla en el Tomcat

§   
Crear un formulario web con Struts

§   
Crear una página para subir ficheros con Struts

 

Para tener la aplicación completa ya
sólo quedaría crearnos un modelo de datos, una conexión a la base de datos e
implementar la lógica del negocio en las acciones de Struts (casi nada…), pero
“La montaña hay que escalarla paso a paso”.

 

2.1     
Introducción al desarrollo Web con Java + Struts

Para la creación y desarrollo de una
aplicación web en Java se puede utilizar el framework de Struts, que es un
framework que implementa la arquitectura MVC (modelo-vista-controlador) de tipo
2 (así se define en la literatura).

 

En la arquitectura MVC de tipo 2 las
diferentes páginas que el usuario ve lanzan acciones utilizando un único
controlador, que despacha las diferentes peticiones a un conjunto de acciones
previamente registradas en el controlador.  Un único servlet es llamado desde
el cliente, quedando visible un único punto de entrada al controlador.

 

Esta arquitectura contrasta con el tipo 1, en
la que la lógica de control de la aplicación (acciones que hay que llamar,
vistas que se deben generar y control de navegación entre páginas) va integrada
en la capa de presentación. Esta arquitectura es la utilzada en ASP.NET y en
JSF (Java Server Faces). En este caso el usuario genera eventos que son
tratados en el controlador, asociando acciones a los diferentes eventos.

 

En el framework de Struts, el fichero
struts-config.xml define la lógica de presentación y navegación de la
aplicación. En este fichero van registrados:

§   
Beans de formulario, que son los datos que envía
cada acción del usuario al controlador.

§   
Acciones de formulario, que son las acciones que
pueden ser llamadas desde las páginas del cliente. Cada acción recibe
información mediante los beans del formulario y otros beans definidos en la
aplicación y responde al usuario generando diferentes vistas mediante JSP. Es
en las acciones donde se escribe la lógica del negocio y la gestión del modelo
de datos y su persistencia.

§   
Reglas de navegación por las diferentes páginas,
mediante los los mapeos de acciones (action mappings)

§   
Reglas de validación de datos de los formularios,
que permiten tanto validación en cliente como en el servidor.

§   
Reglas de filtrado de las peticiones mediante
cadenas de filtros.

 

Dado que todo el framework es bastante
complejo, vamos a ver con un ejemplo el desarrollo de una aplicación sencilla,
paso a paso.

 

3       
Instalación del entorno de desarrollo sobre Windows

 

3.1     
Software necesario

  • j2eesdk-1_4_02_2005Q2-windows.exe. JDK 5.0 + J2EE 1.4 + Sun AppServer.
  • apache-tomcat-5.5.12.exe. Apache Tomcat 5.5.
  • Eclipse-wtp-all-in-one-0.7.1-win32.zip. Eclipse completo, con herramientas de desarrollo web.
  • apache-ant-1.6.5-bin.zip: ANT 1.6.5 para construir el proyecto sin necesidad de Eclipse.
  • Struts-1.2.8-bin.zip. Distribución de Apache Struts, que contiene binarios (en formato
    JAR), archivos auxiliares y WAR de documentación y ejemplos.
  • Datos del repositorio. Para conectarse con el repositorio CVS hace falta el protocolo,
    servidor, usuario, nombre del repositorio, puerto y módulo. Si no
    disponemos de un repositorio CVS, el tutorial de “Instalación y
    administración de un repositorio CVS en Windows” nos ayudará.

 

4       
Instalación del SDK de Java

Ejecutar el archivo j2eesdk-1_4_02_2005Q2-windows.exe,
que nos instalara el JDK, el JRE y el Servidor de Aplicaciones de Sun (que no
usaremos).

 

 

 

 

Aceptamos todas las opciones con los valores ofrecidos por
defecto salvo la contraseña de administrador, que introduciremos en el campo
correspondiente. Anotaremos dicha contraseña para el futuro (aunque nosotros no
vamos a usar el Servidor de Aplicaciones puede que algún día haga falta y ese
día necesitaremos la contraseña).

 

 

 

 

 

Configurar la variable de entorno del sistema JAVA_HOME apuntando a C:\sun\appserver\jdk

 

 

 

Y añadimos al path
C:\Sun\AppServer\bin;C:\Sun\AppServer\jdk\jre\bin

 

 

 

5       
Instalación del servidor Tomcat local

Ejecutar el archivo apache-tomcat-5.5.12.exe.
Aceptar todas las opciones por defecto y, cuando nos pida la ruta hasta el
“J2SE 5.0 JRE” (ver segunda figura) indicarle el subdirectorio “jdk\jre” dentro
del directorio de instalacion del “J2EE 1.4 SDK” (ver paso anterior).

 

 

 

 

La instalación de apache es prácticamente de
pulsar “Next” y seguir.

 

 

 

Al apache hay que indicarle la ruta a la
máquina virtual de java. Si hemos instalado el JDK de Sun en c:\Sun, la ruta es:
c:\Sun\AppServer\jdk\jre

6       
Instalación del entorno de desarrollo Eclipse

 

 

Descomprimir el fichero
ecplipse-wtp-all-in-one-0.7.1–win32 en la carpeta C:\

Se crea la carpeta c:\Eclipse

 

 

 

 

Una vez instalado en el directorio que le
hemos indicado, pasamos a configurar el eclipse:

 

Ejecutamos el programa eclipse y nos pide una
ruta de trabajo. Definir como ruta de trabajo “c:\workspace”.

 

 

 

 

Una vez introducida la ruta de trabajo pulsar
“OK” y nos muestra la pantalla de bienvenida de eclipse.

También hay que definir por defecto  JRE del
5.0 como runtime por defecto. Pulsamos en Windows\Preferences

 

 

 

En la pestaña de “Installed JREs” pulsamos en
“Add”

 

 

 

Como nombre de JRE le ponemos “jre5.0”

 

Como home directory buscamos el jre del Sun
Java SDK c:\sun\appserver\jdk\jre

 

Nos encontrará sus bibliotecas asociadas.
Pulsamos OK

 

 

 

 

Marcamos el jre5.0 recién creado como runtime
por defecto y aceptamos.

 

 

Ahora nos vamos a la pestaña Servers->Installed
runtime envirorments y pulsamos en
”Add”

 

 

 

 

Elegimos Apache Tomcat 5.5 y seguimos pulsando
“Next”

 

 

 

El nombre por defecto nos vale. Si no aparece,
seleccionamos la ruta del Tomcat 5.5 a mano.

Como jre elegimos el que definimos del JDK en pasos
anteriores. Pulsamos “finish”

 

 

 

Ahora solo falta seleccionar el nuevo servidor
para que lo tome por defecto en los nuevos desarrollos.

 

6.1     
Crear un nuevo proyecto web en Eclipse

 

Nuestro primer paso con Eclipse será crear nuestro proyecto
Web. Vamos a crear una aplicación de ejemplo, con una página feb de inicio que
llevará un formulario de búsqueda y uno de entrada de datos. Vamos a utilizar
para ello un tipo muy sencillo de aplicación Web de Eclipse.

 

 

 

 

Pulsamos con el botón derecho la ventana del navigator y
seleccionamos “New->Web->Dynamic web project”

 

 

 

Le ponemos como nombre “Agenda”. Este será el nombre  de
nuestro proyecto y también del módulo CVS.

Por último pulsamos “Finish”

 

 

 

Cuando Eclipse crea el módulo se crean una serie de carpetas
y ficheros.

 

Contenido de las carpetas:

 

§ .deployables. Esta carpeta contiene los ficheros que debemos empaquetar para subir
al  servidor Web. Los vamos a empaquetar todos juntos en un WAR.

§JavaSource. Esta
carpeta contiene las clases Java que vamos a usar
. Cuando
despleguemos la aplicación estas clases irán a la carpeta WEB-INF\Classes de la
aplicación web “Agenda”.

§WebContent. Esta
es la carpeta principal de la aplicación Web. En esta carpeta se han creado una
serie de subcarpetas:

§WEB-INF. Es
la carpeta que contiene la información interna del servidor web. Esta carpeta
tiene una gestión especial dentro del Tomcat, por lo que vamos a crear en ella
nuevas carpetas. También contiene la carpeta Classes, en las que irá el código
Java de nuestra aplicación.

§META-INF

 

7       
Conectar Eclipse con el repositorio CVS

 

Para este paso debemos tener un repositorio CVS ya
instalado. Si no lo tenemos consulta el tutorial para crear un repositorio CVS
en Windows. Una buena idea es reservar un PC sólo para hacer de servidor de
ficheros. En este PC podemos instalar el repositorio. Así en caso de catástrofe
tendremos dos copias del código fuente…

 

Al arrancar Eclipse tendremos la ventana de
proyectos vacia. Para traer los proyectos desde el CVS debemos importarlos.

 

Para importar los proyectos hacemos
File->Import…->Checkout projects from CVS

 

 

Esta pantalla es la que configura la conexión con el
repositorio

 

Rellenamos los datos de las siguientes
opciones:

Dentro de la opción “Location” rellenamos los
siguientes datos:

En la opción “Host” Hay que introducir el
nombre de la máquina en la que se encuentra el repositorio.

En la opción  “Repository Path”  introducimos
la ruta en la que se encuentra el  proyecto dentro del repositorio, que es
/RepositorioCVS.

 

A continuación en la opción “Authentication”
introducimos usuario y password con los que nos vamos a identificar para
acceder al repositorio.

 

En la opción Connection, introducimos el
protocolo con el que se va a conectar el eclipse con el repositorio CVS. Esto
se hace en la opción “Connection Type” y se selecciona la opción pserver.

 

Una vez rellenos estos datos pulsar la opción
“Next”

 

 

Seleccionamos “Use an existing module (…)” y marcamos todos
los modulos existentes en el CVS para descargar.

 

Pulsamos “Next>”

 

Seleccionamos “Check out into the workspace
as projects” y pulsamos Next.

 

 

 

Pulsamos Next.

 

 

Pulsamos Finish.

 

8       
Funciones habituales que usaremos en el trabajo con CVS

 

Las funciones de CVS que eclipse puede realizar son:

§ 
Sincrhonize with Repository : realiza una sincronización
con los ficheros del repositorio para actualizar los cambios de los ficheros.
Esto nos abre la perspectiva de sincronización.

§ 
Commit: Permite subir los cambios realizados en eclipse al
repositorio de CVS.

§ 
Update: Permite a un usuario bloquear el fichero para
modificarlo.

§ 
Create Patch. Crea un archivo de parche (patch).

§ 
Apply Patch. Aplica un archivo de parche a nuestro
proyecto.

§ 
Tag as Version: Permite poner una etiqueta a la versión
del proyecto.

§ 
Branch. Crea una rama del desarrollo.

§ 
Merge: Permite comparar dos ficheros.del repositorio.

§ 
Switch to Another Branch or Version. Permite cambiar ramas de desarrollo.

§ 
Show Annotation: Muestra los comentarios que tiene en CVS
el fichero seleccionado.

§ 
Show Resource history: Muestra un histórico del fichero.

§ 
Add to Version Control: Permite añadir ficheros y
directorios al repositorio.

§ 
Add to .cvsignore: Permite añadir ficheros y directorios
al repositorio ignorando los ficheros que se le indique.

§ 
Change ASCII/Binary Property: Marca el fichero en CVS como
binario o texto. Normalmente las herramientas de Merge/Diff sólo trabajan con
ficheros de texto.

§ 
Restore from Repository: Restaura el fichero con el
fichero que hay en el repositorio.

§ 
Show Editors: Muestra el editor de CVS

§ 
Unedit: Para indicar que el fichero no se puede editar.

§ 
Edit: para marcar el fichero para edición. Por defecto se
marcan todos.

 

8.1     
Tareas habituales con el CVS desde Eclipse

 

Las tareas habituales que hay que hacer con el CVS desde
eclipse son:

§ 
Partir con un workspace limpio. Para ello se borra el
workspace completo, con eclipse cerrado. Al abrirlo, ya que se ha borrado la
carpeta .metadata, hay que importar todos los proyectos necesarios mediante el
comando File -> Import del Eclipse.

§ 
Actualizar el workspace. Para actualizar el código de los
módulos, se hace un “Team\update”. Esto reemplaza el código por el más actual y
señala los posibles conflictos.

§ 
Crear un nuevo módulo. Si estamos creando un proyecto,
para subirlo al repositorio usamos la opción “Team\share project …”. Esto nos
abre el asistente para subir el proyecto al CVS.

§ 
Subir cambios al repositorio CVS. Una vez modificados y
probados las nuevas versiones del código, se hace un “Team\update” , luego un
“Team\Add to version control” (para ficheros nuevos) y luego el “Team\commit”.

§ 
Añadir un fichero a nuestro proyecto. Una vez creado un
nuevo fichero en alguna de las carpetas del proyecto, Eclipse lo marca con una
interrogación. Esto quiere decir que no lo hemos subido al CVS. Hay dos
opciones: añadirlo al CVS ignore, para indicarle a Eclipse que no debe subir
los cambios al CVS, o añadirlo al control de versiones, para que se incorpore
al conjunto de ficheros gestionados por el CVS. Para ello señalamos el fichero
con el botón derecho y elegimos una de las opciones: “Team\Add to version
control” o “Team\Add to CVS ignore”. Una vez añadido el fichero al CVS hay que
hacer el correspondiente “Commit” del cambio.

§ 
Añadir una carpeta al CVS. CVS sólo añade carpetas que
contengan ficheros. Si queremos que una carpeta se suba al CVS, le añadimos un
fichero en blanco. Al subir el fichero se crea automáticamente la carpeta en el
CVS.

§ 
Borrar el fichero. Para borrar el fichero
hay que borrarlo del proyecto y luego hay que hacer el commit. Hay que tener en
cuenta que los ficheros borrados no aparecen en la perspectiva de Java, por lo
que tenemos que abrir la perspectiva “Team\Sinchronize with the repository”,
seleccionando la carpeta donde estaba el fichero borrado. Al abrir esta
perspectiva nos aparecerán los ficheros que hemos borrado, y ya podremos hacer
el commit de ellos.

§ 
Crear una rama. Esto permite crear una rama dentro del
desarrollo, para su desarrollo por separado. Al crear una rama con
“Team\Branch”, el CVS lo primero que hace es crear una etiqueta, que marca la
versión actual de los ficheros. Además hay que proporcionar el nombre de la
rama. Cuando se vaya a importar un módulo que tiene ramas, hay que especificar
durante la importación el nombre de la rama. Si no se hace se trabaja por
defecto sobre la rama “HEAD”. Cuando se importa la rama, el eclipse muestra el
nombre de la rama junto al nombre del módulo.. Todas las operaciones (commit,
update, etc) se hacen sobre la rama.

§ 
Unir la rama a la rama principal. El comando “Team\merge”
nos permite unir el desarrollo que tenemos en una rama con la rama principal.

 

8.2     
Manejo de la perspectiva de sincronización

Con el botón derecho seleccionamos
en una carpeta o módulo “Sinchronize with repository”. Esto nos abre la
perspectiva de sincronización.

 

8.3     
Crear un proyecto nuevo en el repositorio con Eclipse

Desde Eclipse es muy fácil crear un nuevo proyecto y
añadirlo al repositorio. Como ejemplo vamos a llevar a nuestro repositorio el
proyecto Agenda que hemos creado.

Supondremos que tenemos un repositorio CVS en nuestra
máquina, que hemos llamado CVSRoot, y que estamos usando el CVSNT con el
protocolo pserver. Este es el método más sencillo.

 

 

 

 

Abrimos el Eclipse y nos vamos a la ventana “Navigator”.
Señalamos con el botón derecho el nombre del proyecto y pulsamos “Team ->
Share Project…”.

 

 

Nos abrirá el nuevo cuadro de diálogo

Ahora hay que completar las opciones.

Como nombre de usuario escribimos nuestro nombre de inicio
de sesión en el servidor que tiene el CVSNT.

Como repositorio ponemos la ruta, comenzando con una barra,
en nuestro caso /RootCVS. (cuidado con las mayúsculas).

Como servidor el nombre del servidor, en nuestro caso
localhost.

Como protocolo usamos pserver, que para CVSNT en local o en
otro PC de nuestra red va muy bien

Como nombre de usuario y contraseña, hay que poner uno
válido dentro del servidor de destino. Si no ponemos la contraseña, la pedirá
luego.

Pulsamos Next.

 

 

 

Tecleamos la contraseña y pulsamos OK

 

Eclipse nos mostrará la lista de módulos en el repositorio.
Ya que estamos creando un módulo nuevo, lo normal es crear el módulo con el
mismo nombre que el proyecto.

Nota: para CVS conviene utilizar nombres de proyecto,
ficheros y carpetas estilo UNIX, sin espacios en blanco.

Elegimos la opción “Use project name as
module name” y pulsamos Next

 

 

Eclipse detecta los ficheros que hay que subir al
respositorio y nos los muestra. Tras revisarlos, pulsamos Next, lo que abrirá
el asistente para hacer la confirmación “Commit”. Esta opción Eclipse la marca
por defecto, en la casilla “Launch the commit wizard”. Pulsamos Next

 

 

 

En nuestro caso ha detectado un fichero sobre el que tiene
dudas. Tras abrirlo fuera del Eclipse vemos que es un fichero de texto, por lo
que cambiamos su tipo de binario a ASCII.

 

 

Por último nos queda crear el comentario del “commit”. Todos
los commit llevan un comentario, que se utiliza para luego crear los ficheros
de log de cambios “changelog”.

 

 

 

Tras añadir el módulo al repositorio CVS, ahora Eclipse
indica al lado del nombre del módulo el servidor CVS con el que se está
conectado.

 

8.4     
Subir cambios al repositorio CVS

Otra de las tareas más habituales va a ser subir nuestras
modificaciones al repositorio CVS. Suponemos que modificamos uno de los
ficheros, por ejemplo en nuestro caso el build.xml actualizado.

 

 

Desde el navigator, pulsamos con el botón derecho en el
proyecto y elegimos “New -> File”.

Se abre el cuadro de diálogo de fichero y escribimos como
nombre “build.xml”

Pulsamos Finish

 

 

El Eclipse crea nuestro nuevo fichero. Lo editamos y lo
guardamos.

Ahora pulsamos con el botón derecho sobre el nombre del
fichero y elegimos “Team -> Add to version control”

 

 

 

Nos muestra el cuadro de confirmación y pulsamos OK.

 

 

 

Eclipse marca con un “>” el nombre de fichero para
indicar que ha cambiado, y justo detrás del nombre hay una indicación del tipo
de fichero (ASCII).

Volvemos a pulsar con el botón derecho en “Team ->Commit”

 

Le damos el comentario y pulsamos Finís.

 

 

Ahora Eclipse muestra la versión del fichero junto al nombre
del fichero.

 

8.5     
Importación de un módulo desde el repositorio al Eclipse

Otra tarea habitual con CVS en Eclipse es traernos a nuestro
espacio de trabajo un módulo (proyecto) ya existente en el repositorio. Es muy
sencillo de hacer desde nuestro Eclipse:

 

 

Desde el navigator pulsamos en “File -> Import”

En el cuadro de diálogo elegimos “Checkout Project from CVS”
y pulsamos Next.

 

Ahora podemos o bien elegir uno de los repositorios que esté
utilizando el Eclipse o bien crear una nueva conexión con otro repositorio. En
nuestro caso, como ya estamos conectados al repositorio pulsamos Next.

 

Elegimos la opción “Use an existing module”.

Eclipse se conecta con el repositorio CVS y obtiene la lista
de módulos que hay en el repositorio.

Elegimos el módulo y pulsamos Next (que nos mostrará más
opciones, como utilizar versiones o ramas del módulo) o Next, que coge la
última versión de la rama principal.

 

 

Tras importar el módulo, el navigator se actualiza con el
nuevo proyecto.

9       
Configuración de Tomcat para ejecutar nuestra aplicación en local

Existen dos opciones para ejecutar nuestra aplicación en
local:

  1. Utilizar el directorio .deployables que genera el Eclipse
  2. Utilizar un directorio dentro del webapps de Tomcat

 

La primera opción permite utilizar la compilación de Eclipse
para actualizar la aplicación web. Lo que se hace es apuntar un contexto de
Tomcat al directorio .deployables y marcarlo como “reloadable”. De esta forma,
cada vez que cambiamos un fichero de código, Eclipse lo compila, lo pone en
.deployables, Tomcat detecta el cambio, y lo recarga.

 

La segunda opción es más “manual”. Primero deberemos crear
las tareas adecuadas en el build.xml de nuestro proyecto para lanzar la
compilación e incluso el despliegue de nuestra aplicación web. Dentro de este
fichero crearemos una tarea de nombre “deploy” que se encargue  de compilar y
desplegar nuestro proyecto. Cada vez que hagamos cambios, hay que ejecutar el
target “deploy” del fichero ANT “build.xml” del proyecto y este se encarga de
compilar y copiar los ficheros necesarios al directorio que le indiquemos en la
propiedad de ejecución del ANT “webapp.dir”.

 

9.1     
Opción A: Usar .deployables

Para configurar esta opción, editar el fichero server.xml
del directorio conf de Tomcat y añadir la siguiente linea al final, antes de la
etiqueta </Host>:

 

 

 

donde “mi_proyecto” es el nombre de nuestro
proyecto, y también de la carpeta donde se almacena dentro del workspace. En
nuestro caso quedaría:

 

 

9.2     
Opción B: Usar un contexto en webapps

Para configurar esta opción, no
hay que tocar nada en Tomcat. Lo mejor es compilar el proyecto y generar el
fichero de despliegue .WAR mediante el uso de un build.xml. Cuando tengamos el
WAR sólo hay que desplegarlo en el servidor, bien manualmente o bien usando las
tareas de despliegue del ANT. En general si el servidor está en producción se
prefiere el despliegue manual, ya que suele ser necesario parar otros servicios
y hacer comprobaciones después del despliegue.

 

9.3     
Creación del fichero de despliegue .WAR

Para crear el fichero de
despliegue de WAR Eclipse dispone de un asistente de exportación a WAR. Pero
dado que es una tarea muy habitual y que demás deseamos automatizar, lo mejor
es crear una tarea que compile nuestro proyecto.

 

Un ejemplo de fichero de creación
del WAR podría ser:

 

 

Este fichero realiza las
siguientes tareas:

§   
Iniciar los directorios

§   
Copiar los ficheros JAR externos a la carpeta lib de WEB-INF

§   
Copiar los ficheros JAR externos a la carpeta deplorables

§   
Copiar el contenido estático (WebContent)

§   
Compilar los ficheros java

§   
Desplegar la aplicación en local

§   
Crear el WAR de despliegue

§   
Crear la documentación del proyecto con javadoc

§   
Copiar la documentación del proyecto a una carpeta central

 

Aunque hemos creado un fichero
build.xml demasiado complicado, hay tareas que nos servirán más adelante, como
por ejemplo la creación de la documentación del proyecto, por lo que las hemos
avanzado ya.

 

9.4     
Creación del fichero Web.xml

Además la aplicación web debe tener un fichero de
descripción web.xml. Por defecto Eclipse nos genera uno:

 

En nuestro caso vamos a usar el siguiente:

Hemos añadido:

§   
El servlet de Struts y su servlet-mapping. Por defecto las
acciones se suelen

§   
La página de inicio de la aplicación (index.jsp)

§   
Las diferentes bibliotecas de etiquetas que vamos a poder usar
(beans, html, logia, nested y tiles. En realidad en nuestro ejemplo sólo vamos
a usar struts-beans y strut-html, y si acaso, struts-logic.

 

9.5     
Añadir definiciones de bibliotecas de etiquetas

Además del web.xml y del struts-config.xml, Struts necesita
otros ficheros para funcionar. Los siguientes ficheros de definiciones vienen
en el paquete de Struts:

§   
struts-html.tld

§   
struts-bean.tld

§   
struts-logic.tld

§   
struts-nested.tld

§   
struts-tiles.tld

Además hay que añadir otros ficheros de
configuración:

§   
tiles.def

§   
validation.xml

§   
validation-rules.xml

 

Podemos ver ejemplos de estos archivos
en nuestra distribución de Struts, en formato WAR. Para usar estos ejemplos basta
desplegar (copiar a la carpeta webapps del Tomcat) los archivos WAR y usar el
navegador para conectarnos a ellos. En nuestro caso disponemos de las
siguientes ayudas:

 

§   
http://localhost:8080/struts-documentation

§   
http://localhost:8080/struts-blank

§   
http://localhost:8080/struts-examples

§   
http://localhost:8080/tiles-documentacion

§   
http://localhost:8080/struts-mailreader

 

 

 

10    Crear un módulo
para bibliotecas externas

Puede ser buena idea tener un módulo común a los proyectos
web en el que metamos las bibliotecas más habituales que vamos a usar. De este
modo cuando se actualizan las bibliotecas se actualizan todos los proyectos.
Para crear este módulo creamos un nuevo proyecto, que para este caso puede ser
un proyecto simple de Eclipse,  y le añadimos algunas bibliotecas. Por ejemplo
vamos a añadir en la carpeta struts-1.2.8/lib todas las bibliotecas del Struts,
así como las de log4j y las de j2ee. Quedará algo así:

 

 

10.1 Enlazar
nuestro proyecto con los JARs de las bibliotecas externas

Ahora hay que enlazar nuestro proyecto con estas
bibliotecas. Para ello nos vamos a las propiedades del proyecto Agenda, y nos
situamos en la pestaña “Libraries” de la opción “Java build path”

 

 

Pulsamos el botón de “Add JARs” y nos muestra la ventana de
selección de JARs, en la que aparece sólo el módulo “3party”. Desplegamos las
carpetas del módulo y señalamos todos los JARs:

 

Pulsamos OK y se nos añaden todos los JARs como bibliotecas
externas:

 

Si nos fijamos hemos utilizado tres fuentes para los JAR, que
podemos ver en las rutas de los JAR:

§   
La distribución de struts (la 1.2.8 en nuestro caso)

§   
La distribución de log4j (la 1.2.12 en nuestro caso)

§   
La disribución de J2EE (la 1.4 que instalamos del JDK)

 

 

11   
Creando la página inicial

La página inicial va a ser un formulario de búsqueda muy
sencillo, que muestra un campo de texto para introducir un nombre y un botón de
buscar en la agenda.

 

 

El código html de esta página puede ser algo así:

Este código lo primero que hay que hacer es adaptarlo a
Struts. Vamos a crear nuestro primer jsp en Eclipse. Creamos en la carpeta
Agenda\WebContent el fichero index.jsp y copiamos el código fuente de la página
html.

 

El nuevo código ha quedado así:

El entorno de desarrollo reconoce que es una página jsp y
dispone de nuevas herramientas para ello. Podemos:

§   
Insertar nuevas etiquetas html y de struts.

§   
Insertar atributos a las etiquetas

§   
Formatear visualmente nuestra página jsp.

§   
Autocompletar atributos, valores, e incluso el código java
insertado dentro de la página.

 

Dentro de nuestro jsp de ejemplo vemos:

§   
Una sección inicial que carga las diferentes bibliotecas de
etiquetas (taglibs)

§   
Una etiqueta <html:html> que indica a Struts que es una
página html.

§   
Una etiqueta <html:form> para indicar a Struts que esa
página contiene un formuilario html. En esta etiqueta además indicamos la
acción Struts que se va a disparar cuando se envíen los datos del formulario y
la validación en cliente que se va a realizar antes de enviar los datos. Todo
esto lo definiremos luego en el struts-config.xml

§   
Una etiqueta <html:text> para insertar un botón en el
formulario. En la etiqueta vemos que se va a utilizar una propiedad. Esta
propiedad es un atributo de un bean que Struts asocia a nuestro formulario.

§   
También hay una etiqueta <html:submit> que muestra el botón
de enviar y lo asocia al formulario Stuts.

 

¿Qué hemos modificado en la página html?

§   
En primer lugar hemos indicado en la primera línea que es una
página jsp en Java.

§   
Luego hemos insertado las tres bibliotecas de etiquetas: bean
para manejar los beans desde Struts, html para incluir etiquetas html en Struts
y logia para utilizar las etiquetas de lógica de presentación de Struts.

§   
La etiqueta html se ha sustituido por html:html, que es la
etiqueta equivalente en Struts para declarar una página html.

§   
La etiqueta form se ha sustituido por html:form, que indica a
Struts que la página contiene un formulario Struts. (Sólo uno por página). Esto
identifica el formulario dentro del controlador de acciones de Struts.

§   
Los controles del formulario html (text y submit) se han
sustituido por los correspondientes en Struts. Así Struts sabe manejar la
información que va en ellos, realizar validaciones en cliente y servidor, e
insertar la información en el bean del formulario.

 

11.1 Creación
del bean del formulario

Ya tenemos nuestro formulario. Ahora
necesitamos un bean para guardar la información del formulario dentro de Struts
y una acción de Struts que sea disparada por el formulario.

Normalmente cada formulario que vamos a
utilizar en Struts lleva asociado un bean, en el que Struts guarda la
información de los parámetros del formulario, para que las acciones puedan
acceder a dicha información.

Para ello vamos a añadir a nuestro
proyecto

 

 

 

Dentro de la carpeta JavaSource creamos
la carpeta agenda, y dentro de ella formularios

y acciones. Dentro de la carpeta
JavaSource\agenda\formularios creamos el fichero busqueda.java con el siguiente
contenido:

Para generar los getters y setters
Eclipse dispone una opción en Source->Generate setter/setter, por lo que no
sólo hay que escribir el nombre de la clase y las variables privadas.

 

11.2 Crear
el struts-config inicial

 

El siguiente ejemplo de fichero struts-config contiene la
estructura básica más algunos añadidos que más adelante comentaremos:

 

11.3 Añadir
el bean de formulario al struts-config

Para añadir el bean de formulario añadimos un nuevo elemento
a la clave form-beans

Esto le indica a Struts el tipo de los datos del bean de
formulario busqueda.

 

11.4 Crear
la acción asociada al formulario

 

Ahora hay que crear la acción. En la carpeta
JavaScript\acciones vamos a crear el fichero busqueda.java con el siguiente
código:

Aquí ejecutamos el código de la acción.
La clase acción tiene un método execute que es el que lanza Struts para
procesar la acción. Recibe cuatro parámetros:

§   
Mapping. Son los mapeos que utilizará Struts para indicarle a la
acción hacia dónde debe ir. Nosotros asociaremos estas acciones a páginas jsp
que generarán la vista que se presenta al usuario tras ejecutar la acción.

§   
Request. Datos de la request enviada por el usuario.

§   
Form. Bean del formulario, en el que Struts guarda los datos
enviados por el formulario.

§   
Response. Es la respuesta del usuario.

 

Ahora nos falta meter el código de la
acción en el lugar señalado.

 

11.5 Añadir
la acción al struts-config

 

Para que Struts sepa qué acción se debe ejecutar cuando se
envíe el formulario de búsqueda, debemos dar de alta la acción creada en el
paso anterior en el struts-config.xml. El siguiente código l meteremos en la
clave <ActionMapping> del Struts-config.xml.

 

12   
Añadiendo una página para subir ficheros

Una de las tareas típicas de nuestra
página web será dar al usuario la posibilidad de subir ficheros a la
página.Para nuestra pequeña aplicación de ejemplo vamos a crear una página que
sube un fichero (por ejemplo una imagen).

 

Comenzamos por crear la página de
subida, con un texto como el siguiente:

Ahora necesitamos guarda la información
en un bean de formulario para que las acciones puedan recibir los datos del
fichero. Struts dispone del bean adecuado, de tipo FileForm, por lo que sólo
tenemos que crearnos el bean adecuado heredando del FileForm:

12.1 Añadir
el bean del formulario al struts-config

Os dejamos como deberes para casa añadir el
bean del formulario al struts.config, aunque es muy fácil (ya lo hemos hecho
antes)

 

12.2 Añadir
la acción en el struts-config

13   
Conclusión

Struts es una buena implementación de la
arquitectura de programción MVC (Model-View-Controller) o
Modelo-Vista-Controlador. Con Struts es fácil construir complejas aplicaciones
Web como portales empresariales, tiendas virtuales y todo tipo de aplicaciones
Web. Ya que Struts es un proyecto de la fundación Apache, se combina perfectamente
con otros módulos creados dentro de los diversos proyectos de la fundación,
como son las colas de conexión a base de datos, y otros muchos.

En Struts es importante entender el
manejo de la petición, la acción disparada y la respuesta, que están definidas
mediante un fichero XML. Así podemos definir la navegación en nuestra
aplicación incluso antes de implementarla, y el módulo de Struts se encargará
de gestionarla.

En este tutorial hemos aprendido a montar
una primera página web con Struts, que puede servir como comienzo para un
proyecto de un portal Web o quizás otro tipo de aplicación.

 

 

2 Comentarios

  1. Hola soy nueva en esto de la programacion web java… y quisiera saber si tiene un tuto completo de inicio. Yo instale glassfish y eclipse y los configure. Lo que quisiera es un tutorial que me diga paso a paso asi sea con print screen como crear una app sencilla desde cero, pero que contenga lo necesario donde use struts. Agradeceria su ayuda!!!

Dejar respuesta

Please enter your comment!
Please enter your name here