Org tutorial struts_2010

2010

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

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

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

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

Entendiendo Struts: un enfoque práctico.

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

2


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.

3


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

4


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

5


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).

6


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.

7


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;

8


}

/**
* @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;

9


}

/**
* @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

10


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

11


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

12


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

13


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

14


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

15


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>

16


</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>

17


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.

18


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

19

Org tutorial struts_2010

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Destacado

Destacado (15)

Similar a Org tutorial struts_2010

Similar a Org tutorial struts_2010 (20)

Org tutorial struts_2010