Tutorial Struts 2010

Entendiendo struts Un enfoque práctico Se explica mediante un ejemplo la utilización del framework MVC Struts

2010

RIOX-Lap HP

14/07/2010

Contenido

1. Entendiendo struts ____________________________________________________ 1

2. Creando proyecto web con funcionalidad struts _____________________________ 3

3. Conociendo la estructura de Struts _______________________________________ 5

4. Programando en struts _________________________________________________ 6

Codificando el modelo de Calzado ________________________________________________ 6

Codificiando el Controlador actionForm Bean ______________________________________ 10

Codificando el Controlador ActionForm ___________________________________________ 13

Creando la vista (Página JSP) ____________________________________________________ 15

Ejecutar el proyecto ___________________________________________________________ 18

5. Conclusiones ________________________________________________________ 19

6. Referencias _________________________________________________________ 19

Contenido de figuras

Figura 1 Arquitectura del MVC _____________________________________________________________ 1

Figura 2 Arquitectura de Struts _____________________________________________________________ 2

Figura 3 Crear Proyecto Web _______________________________________________________________ 3

Figura 4 Designación del nombre del proyecto _________________________________________________ 3

Figura 5 Selección del Servidor de aplicaciones _________________________________________________ 4

Figura 6 Seleccionando struts ______________________________________________________________ 4

Figura 7 Estructura de Struts _______________________________________________________________ 5

Figura 8 Creando Paquete Modelo __________________________________________________________ 6

Figura 9 Creando Clase Calzado ____________________________________________________________ 6

Figura 10 Clase Calzado creado _____________________________________________________________ 7

Figura 11 Refactorizando los Campos encapsulados _____________________________________________ 8

Figura 12 Creando actionForm del Modelo Calzado ____________________________________________ 10

Figura 13 ActionForm de Calzado __________________________________________________________ 11

Figura 14 Variables refactorizadas de CalzadoForm ____________________________________________ 11

Figura 15 Agregando etiquetas de error _____________________________________________________ 12

Figura 16 Creando Struts Action ___________________________________________________________ 13

Figura 17 Agregando un Forward __________________________________________________________ 14

Figura 18 CalzadoAction _________________________________________________________________ 15

Figura 19 Formulario para agregar calzados _________________________________________________ 18

Figura 20 Faltan datos ___________________________________________________________________ 18

Figura 21 Registro realizado correctamente. _________________________________________________ 18

MCCC. Omar Ríos González Analyst & Developer EDS HP

1 1

1. Entendiendo struts Struts es un framework para el desarrollo Web basado en el patrón de diseño MVC (modelo, vista,

controlador). Pero algunos se preguntarán ¿Qué es un framework? Pues bien, un frameworks es

una herramienta que se basa en soluciones reutilizables para el desarrollo y/o implementación de

una aplicación que permite acotar tiempos, reducir código y optimizar tareas.

Ahora que ya sabemos lo que es un framework surge la duda ¿Porqué basado en un patrón de

diseño MVC? Porque la escencia de este y muchos patrones consiste en separar una aplicación en

n componentes, en este caso sólo se es necesario separar en tres componentes; Modelo, Vista y

Controlador.

Componente modelo: Consiste en tener bien definidas las reglas de negocio, acceso a los datos y

persistencia (beans, ejb, orm, java).

Componente vista: Este componente administra la interfaz de los datos a los usuarios, es decir, es

la parte visual que pueden ver los usuarios finales (html, jsp, javascript, flex, ajax, etc.).

Componente controlador: Se encarga de administrar los eventos entre el componente modelo y el

componente vista (strutsForm, strutsAction, mapeos en struts-conf).

Aterrizando más la teoría del MVC, se muestra en la siguiente figura cada componente de esta

arquitectura según la definición original de este patrón. El modelo se encarga de la lógica

aplicativa de nuestro sistema, la vista es la interfaz que se muestra al usuario y el controlador es el

mediador entre la vista y el modelo.

Figura 1 Arquitectura del MVC

Struts está construido sobre vairas tecnologías entre ellas, Java Servlets, Java Server Pages, Java

Beans y XML básicamente, puede interactuar con otras herramientas como Enterprrise Java Beans

y JDBC si se requiere manejar datos persistentes.

En general un cliente realiza una petición al Servlet principal llamado ActionServlet, este servlet

busca dentro del archivo de configuración llamado struts-config.xml el Action que corresponde a

Entendiendo Struts: un enfoque práctico.


2

esa petición, el cual puede acceder al modelo y por consiguiente a los datos de forma persistente,

esta Action regresa como resultado la siguiente vista que se muestra al cliente. El ciclo se repite

hasta que el usuario decida cerrar la sesión del sistema.

Figura 2 Arquitectura de Struts



3

2. Creando proyecto web con funcionalidad struts Crear nuevo proyecto Web en Netbeans, File > New Project

Figura 3 Crear Proyecto Web

Designar nombre del proyecto.

Figura 4 Designación del nombre del proyecto

Seleccionar servidor, por default tomcat pero también puede usarse con GlassFish, si deseas

utilizar Glassfish se debe de cambiar la versión del Java EE a J2EE 1.4. Este servidor nos brinda el

soporte de desplegar el proyecto y realizar los test correspondientes antes de salir a producción.



4

Figura 5 Selección del Servidor de aplicaciones

Seleccionar el Framework Struts y si desean modificar la dirección de los recursos a una

personalización adecuada a nosotros lo puede realizar, después de creado el proyecto se pueden

agregar n recursos de aplicación. Finalmente se da clic en Finish.

Figura 6 Seleccionando struts



5

3. Conociendo la estructura de Struts La estructura de un proyecto en el framework struts en Netbeans se define por medio de 4

directorios principales, los cuales son:

Web pages: En esta carpeta se agregan todos los cosméticos de las páginas visuales, es decir los

archivos con formato HTML, JSP, CSS, JS siendo los más utilizados, entre otros.

Source Packages: En este directorio se tienen las clases de los elementos Modelo (Clase Objeto,

Acceso a repositorios, Servicios web, etc.) y elementos del Controlador.

Libraries: Este directorio contiene las librerías *.jar de las api que se vayan a anexar para

desarrollar el modelo y las funcionalidades de struts.

Configuration Files: Es el directorio principal en donde se tiene dos archivos de configuración

indispensables, en el archivo web.xml se especifican los directorios de las path del elemento action

y los parámetros apropiados de struts.

Figura 7 Estructura de Struts



6

4. Programando en struts Vamos a realizar un pequeño desarrollo de un Modelo Básico que es la de agregar un nuevo

Calzado, para ello tenemos los siguientes atributos.

Calzado (clave, modelo, marca, talla, color, precioUnitario, precioMayoreo, precioPromocion,

precioDistribuidor)

Codificando el modelo de Calzado Se crea un nuevo paquete dando clic derecho sobre la carpeta “Source Packages”> New > Java

Package, y escriben el paquete que desean, en mi caso “net.riox.Modelo” y dar clic en “Finish”,

como se muestra en la siguiente figura.

Figura 8 Creando Paquete Modelo

A continuación se crea una clase llamada “Calzado”, para ello dar clic derecho sobre el paquete

“net.riox.Modelo” > New > Java Class… , y se sustituye NewClass por Calzado y dar clic en “Finish”.

Figura 9 Creando Clase Calzado

Se muestra la declaración de la clase “Calzado” en donde se definirán todos los atributos del

modelo (Figura 9).



7

Figura 10 Clase Calzado creado

Se declaran los atributos mencionados al comienzo del subtema y se da clic derecho al último

atributo > Refactor > Encapsulate Fields.



8

Se muestra una ventana en donde debe dar clic en “Select All” y se seleccionan todos los Getter y

Setter que se seleccionan, a continuación dar clic en refactor y se construyen todos los métodos

necesarios del Objeto Modelo.

Figura 11 Refactorizando los Campos encapsulados

El siguiente código es el que resultó de la operación anterior:

package net.riox.Modelo;

/**

*

* @author RIOX-Lap

*/

public class Calzado {

private String clave;

private String modelo;

private String marca;

private String talla;

private String color;

private float precioUnitario;

private float precioMayoreo;

private float precioPromocion;

private float precioDistribuidor;

/**

* @return the clave

*/

public String getClave() {

return clave;

}

/**

* @param clave the clave to set

*/

public void setClave(String clave) {

this.clave = clave;

}

/**

* @return the modelo

*/

public String getModelo() {

return modelo;



9

}

/**

* @param modelo the modelo to set

*/

public void setModelo(String modelo) {

this.modelo = modelo;

}

/**

* @return the marca

*/

public String getMarca() {

return marca;

}

/**

* @param marca the marca to set

*/

public void setMarca(String marca) {

this.marca = marca;

}

/**

* @return the talla

*/

public String getTalla() {

return talla;

}

/**

* @param talla the talla to set

*/

public void setTalla(String talla) {

this.talla = talla;

}

/**

* @return the color

*/

public String getColor() {

return color;

}

/**

* @param color the color to set

*/

public void setColor(String color) {

this.color = color;

}

/**

* @return the precioUnitario

*/

public float getPrecioUnitario() {

return precioUnitario;

}

/**

* @param precioUnitario the precioUnitario to set

*/

public void setPrecioUnitario(float precioUnitario) {

this.precioUnitario = precioUnitario;

}

/**

* @return the precioMayoreo

*/

public float getPrecioMayoreo() {

return precioMayoreo;



10

}

/**

* @param precioMayoreo the precioMayoreo to set

*/

public void setPrecioMayoreo(float precioMayoreo) {

this.precioMayoreo = precioMayoreo;

}

/**

* @return the precioPromocion

*/

public float getPrecioPromocion() {

return precioPromocion;

}

/**

* @param precioPromocion the precioPromocion to set

*/

public void setPrecioPromocion(float precioPromocion) {

this.precioPromocion = precioPromocion;

}

/**

* @return the precioDistribuidor

*/

public float getPrecioDistribuidor() {

return precioDistribuidor;

}

/**

* @param precioDistribuidor the precioDistribuidor to set

*/

public void setPrecioDistribuidor(float precioDistribuidor) {

this.precioDistribuidor = precioDistribuidor;

}

}

Codificiando el Controlador actionForm Bean El actionForm Bean es el que estará vinculado a la parte visual jsp. Lo primero que haremos es

crear un nuevo paquete “net.riox.Controlador.Form”, a continuación dar clic derecho sobre el

paquete creado > New > Other… ; seleccione Struts > Struts ActionForm Bean y dar clic en “Next”.

Modificar “NewStrutsActionForm” por “CalzadoForm”, finalmente dar clic en “Finish”.

Figura 12 Creando actionForm del Modelo Calzado



11

Se muestra el Bean creado en el IDE de Netbeans y proceda a dejar el código como se muestra en

la figura siguiente.

Figura 13 ActionForm de Calzado

Como se muestra en la imagen anterior, se debe de realizar el mismo procedimiento con los

atributos del objeto, declare las mismas variables y proceder a refactorizarlas.

Figura 14 Variables refactorizadas de CalzadoForm



12

Se observa en la Figura 14 que la clase extiende de ActionForm, por lo que estas variables

declaradas son las que estarán ligadas al archivo jsp de visualización.

A continuación en el método “valídate” se localizan las variables que son obligatorias en el

formulario jsp, es decir, son las que se validarán con respecto al flujo de entrada de datos, en caso

de que exista un error se mostrará un error.

1 public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) { 2 ActionErrors errors = new ActionErrors(); 3 if (getClave() == null || getClave().length() < 1) { 4 errors.add("clave", new ActionMessage("error.clave.requerido")); 5 } 6 return errors; 7 }

En el código anterior se describe la validación de la variable clave, en la línea 1 se declara el

método valídate teniendo como parámetros la entrada del request y el mapeo si se desea utilizar

alguno de sus métodos. En la línea 2 se declara una instancia de error, mismo que se utiliza para

añadirlo al objeto que se retorna una vez analizado todas las validaciones. En la línea 4 se muestra

como se agrega un error, el primer parámetro es el identificador que se liga a la vista jsp y el

segundo parámetro es el mapeo que se realiza al archivo de propiedades “AppResource”

localizado en <paquete>.struts en la sección de “Source Packages”.

A continuación se procede a escribir las leyendas que se mostrará en cada validación si ocurre

algún error, se abre el arhivo “AppResource” y se agregan los valores que se agregaron en el

método “validate” de la clase “CalzadoForm”, como se muestra en la siguiente figura.

Figura 15 Agregando etiquetas de error



13

Codificando el Controlador ActionForm El actionForm es el que realizará todas las operaciones con el acceso a datos.

Se crea un nuevo paquete “net.riox.Controlador.Action”, se crea una nueva clase de tipo Action

para ello dar clic sobre el paquete creado > New > Other, seleccione Struts y Struts Action a

continuación dar clic en “Next” mostrándonos una nueva ventana.

En la ventana escribir en el Class Name: “CalzadoAction” y en Action Path: “/Calzado”, dar clic en

“Next”. Posteriormente se muestra otra ventana en donde se modifica el “Input Resource” el cual

es la página que contiene los componentes que se mapean con las variables del ActionForm, se

agrega el directorio en donde se lozaliza el jsp, en este caso lo crearemos en

/calzado/agregarCalzado.jsp

Figura 16 Creando Struts Action



14

Dentro del método execute se crea un objeto form de CalzadoForm con el fin de obtener los datos

del formulario jsp.

CalzadoForm cform = (CalzadoForm) form;

Se guardan en memoria todos los datos que se obtienen del formulario en variables locales.

String clave = cform.getClave(); String modelo = cform.getModelo(); String marca = cform.getMarca(); String talla = cform.getTalla(); String color = cform.getColor(); float precioUnitario = cform.getPrecioUnitario(); float precioMayoreo = cform.getPrecioMayoreo(); float precioPromocion = cform.getPrecioMayoreo(); float precioDistribuidor = cform.getPrecioDistribuidor();

Se genera una clase en la cual se tendrán todas las operaciones que se realizarán hacia los

repositorios (bases de datos, servicios web, etc.). Una vez que se tenga la clase CalzadoDAO se

genera una instancia para realizar una búsqueda por medio del modelo del calzado.

Si el calzado existe en la base de datos se genera un error de que ya existe el calzado y se muestra

una leyenda en la página del formulario el motivo del error.

return mapping.getInputForward();

Si no existe el calzado, se ejecuta el método guardarCalzado de la clase CalzadoDAO y se envía a

una nueva página mostrando que se ha ingresado correctamente los datos del calzado.

return mapping.findForward(SUCCESS);

Cabe señalar que la variable SUCCESS se ha declarado al inicio de la clase, teniendo como valor

“success”, este valor se debe de mapear hacia una página visual. Para mapear la página a

redirigirse se abre el archivo “struts-config.xml” que se encuentra en la carpeta de “Configuration

Files”, dé clic derecho sobre <global-forwards> y seleccione Struts > Add Forward, se muestra una

ventana como la siguiente figura, en donde se agrega el valor de la variable SUCCESS al igual que la

página jsp que muestre el caso de éxito.

Figura 17 Agregando un Forward



15

Figura 18 CalzadoAction

Creando la vista (Página JSP) Por último queda la creación del formulario en una página jsp. Cabe señalar que para utilizar las

etiquetas de struts se deben declarar al inicio las librerías, las librerías más comunes son las

siguientes:

Permiten acceder a los Bean de nuestra aplicacion.

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>

Tags basados en componentes html.

<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>

Iteracion, procesamiento condicional y control de flujo.

<%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %>

Los elementos que utilizaremos en esta página son los siguientes:

<html:form action="Calzado.do"> Elemento principal del formulario, como atributos se le agrega el action mapeado en

<html:errors property="clave"/> Representa el error y se agrega el bean del error específico en el atributo propiedad.

<bean:message key="agregarCalzado.jsp.clave"/> Representa el mapeo de etiquetas localizadas en AppResource

<html:text property="clave" size="20"/> Indica una caja de texto con el valor declarado en el calzadoForm

<html:submit> Envia una petición

<html:reset> Elimina datos del formulario



16

Lo primero que se debe realizar es generar las página que se han definido en los global-forwards y

en los action-mappings.

<global-forwards> <forward name="success" path="/success.jsp"/> <forward name="welcome" path="/Welcome.do"/> </global-forwards> <action-mappings> <action input="/calzado/agregarCalzado.jsp" name="CalzadoForm" path="/Calzado" scope="session" type="net.riox.Controlador.Action.CalzadoAction"/> <action path="/Welcome" forward="/welcomeStruts.jsp"/> </action-mappings>

Tenemos dos archivos nuevos que generar:

1. Success.jsp que debe estar en la raíz de la aplicación web.

2. agregarCalzado.jsp que debe estar en (raíz)/calzado/agregarCalzado.jsp

Se crea el archivo success.jsp, quedando de la siguiente forma:

<%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>AGREGAR CALZADO</title> </head> <body> <h1>Se ha registrado correctamente el calzado en las bases de datos.</h1> </body> </html>

Se crea el archivo agregarCalzado.jsp quedando de la siguiente forma:

<%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %> <%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %> <%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>AGREGAR CALZADO</title> </head> <body> <center> <h2>Agregar calzado</h2>



17

</center> <html:form action="Calzado.do"> <table border="0" align="center"> <thead></thead> <tbody> <tr> <td><bean:message key="agregarCalzado.jsp.clave"/></td> <td><html:text property="clave" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.modelo"/></td> <td><html:text property="modelo" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.marca"/></td> <td><html:text property="marca" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.talla"/></td> <td><html:text property="talla" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.color"/></td> <td><html:text property="color" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.precioUnitario"/></td> <td><html:text property="precioUnitario" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.precioMayoreo"/></td> <td><html:text property="precioMayoreo" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.precioPromocion"/></td> <td><html:text property="precioPromocion" size="20"/></td> </tr> <tr> <td><bean:message key="agregarCalzado.jsp.precioDistribuidor"/></td> <td><html:text property="precioDistribuidor" size="20"/></td> </tr> <tr> <td colspan="2" align="center"> <html:submit><bean:message key="agregarCalzado.jsp.submit"/></html:submit> <html:reset><bean:message key="agregarCalzado.jsp.reset"/></html:reset> </td> </tr> <tr> <td colspan="2"> <html:errors property="clave"/> <html:errors property="modelo"/> <html:errors property="marca"/> <html:errors property="talla"/> <html:errors property="color"/> <html:errors property="precioUnitario"/> <html:errors property="precioMayoreo"/> <html:errors property="precioPromocion"/> <html:errors property="precioDistribuidor"/> </td> </tr> </tbody> </table> </html:form> </body> </html>



18

Ejecutar el proyecto Para ejecutar el proyecto se da clic derecho sobre el proyecto >Run, se espera un momento

mientras el browser predeterminado se abra en la siguiente url:

http://localhost:8084/ShoesTest/

Como hemos creado la pagina jsp en el directorio “/calzado/agregarCalzado.jsp”, la url quedaría

de la siguiente forma:

http://localhost:8084/ShoesTest/calzado/agregarCalzado.jsp

y se muestra el formulario:

Figura 19 Formulario para agregar calzados

A continuación se agregan los datos correspondientes dejando en cero el precio del distribuidor,

se observa en la siguiente figura que se envía una etiqueta haciendo referencia a la falta del dato

Precio Distribuidor.

Figura 20 Faltan datos

Ahora ingrese el valor del precio distribuidor y se redirige a una nueva página indicándole que se

ha ingresado correctamente los datos a la base de datos.

Figura 21 Registro realizado correctamente.

http://localhost:8084/ShoesTest/

http://localhost:8084/ShoesTest/calzado/agregarCalzado.jsp



19

5. Conclusiones Struts es uno de los mejores frameworks que tienen una arquitectura de programación MVC

(Modelo-Vista-Controlador), ya que es sumamente fácil la creación de aplicaciones Web complejas

tales como portales empresariales, tiendas virtuales, administración de negocios, incluso ser

puente de envío de información a otras arquitecturas, entre otras. Lo único que se necesita

entender de Struts es el manejo de las peticiones, la acción que se dispara para dar una respuesta

a la petición y la respuesta misma, mismos que están definidos mediante un fichero XML, de esta

forma se pueden definir las navegaciones en la aplicación desde antes de implementarla. En este

documento hemos aprendido la teoría básica de un framework, patrón de diseño MVC, Struts, así

como la elaboración de un ejemplo como comienzo de un portal que brinde servicio de ventas de

calzado por internet o intranet.

6. Referencias

Introducción a struts. http://asuncionez.iespana.es/documentos/StrutsMVC.pdf Pre-requisitos técnicos de struts. http://struts.apache.org/primer.html Struts. http://es.wikipedia.org/wiki/Jakarta_Struts Guía de usuario. http://struts.apache.org/1.x/userGuide/index.html Tutorial struts. http://courses.coreservlets.com/Course-Materials/struts.html Ajax con Struts. http://today.java.net/pub/a/today/2005/10/27/sprinkle-ajax-magic-into-struts-webapp.html Struts en Eclipse. http://www.mastertheboss.com/en/web-interfaces/190-jboss-struts-tutorial.html Struts vs JavaServer Faces. http://www.ing.unp.edu.ar/wicc2007/trabajos/ISBD/109.pdf

http://asuncionez.iespana.es/documentos/StrutsMVC.pdf

http://struts.apache.org/primer.html

http://es.wikipedia.org/wiki/Jakarta_Struts

http://struts.apache.org/1.x/userGuide/index.html

http://courses.coreservlets.com/Course-Materials/struts.html

http://today.java.net/pub/a/today/2005/10/27/sprinkle-ajax-magic-into-struts-webapp.html

http://www.mastertheboss.com/en/web-interfaces/190-jboss-struts-tutorial.html

http://www.ing.unp.edu.ar/wicc2007/trabajos/ISBD/109.pdf

Tutorial Struts 2010

Documents

Transcript of Tutorial Struts 2010