UNIVERSIDAD PRIVADA TELESUP

FACULTAD DE INGENIERÍA Y ARQUITECTURA

CARRERA PROFESIONAL DE INGENIERÍA DE SISTEMAS E INFORMÁTICA

VII CICLO

MONOGRAFÍA:

STRUTS FRAMEWORK

AUTORES:

Marquez Romero, Renzo

Rodriguez Tume, Bruce Arnold Alex

Roman Casahuaman, Florencio

Salazar Almestar, Jardel Eduardo

Suarez Ramos, Renzo

DOCENTE:

Atunga Vergara Jose Timoteo

LIMA - PERÚ

2018

1
Dedicatoria

A Dios por la sabiduría e

inteligencia que nos da día a día. A
nuestros padres por el apoyo
incondicional que nos brindan. A
todas aquellas personas con sed
de conocimiento y deseos de
superación, que leen hoy estas
páginas y premian el esfuerzo de
este trabajo.

2
Agradecimientos

Agradecemos en primer lugar a

Dios por permitirnos finalizarlo con
éxito nuestro trabajo de
investigación; y en segundo lugar,
pero no menos importante, a
nuestros queridos padres, por su
respaldo emocional, moral y
económico. En ésta oportunidad,
nuestro reconocimiento y
agradecimiento a nuestro profesor
Atunga Vergara Jose Timoteo, por
su instruida orientación.

3
ÍNDICE
CAPÍTULO I INTRODUCCIÓN ...................................................................................................... 5
OBJETIVOS ...................................................................................................................................... 6
CAPÍTULO II ..................................................................................................................................... 7
2.1. Framework ............................................................................................................................. 7
2.2. Struts....................................................................................................................................... 7
2.3. Por qué usar Struts. Alternativas........................................................................................ 8
2.4. Requerimientos ..................................................................................................................... 9
2.5 Instalación ............................................................................................................................... 9
2.6 Creación de una aplicación Framework Struts ............................................................... 11
2.7. Fundamentos....................................................................................................................... 13
2.7.1. Funcionamiento Clásico de una Aplicación Web ................................................... 13
2.7.2. Modelo vista controlador (MVC) ................................................................................ 14
2.7.3. Cronología .................................................................................................................... 17
2.7.4. TagLibs .......................................................................................................................... 18
2.7.5. Validación ..................................................................................................................... 19
2.7.6. Interceptores ................................................................................................................ 21
2.7.7. OGNL y value stack .................................................................................................... 22
2.7.8. Ventajas de usar Struts .............................................................................................. 22
2.8.8. Desventajas de usar Struts ........................................................................................ 23
2.9. Creación de crud framework struts2 ................................................................................ 24
2.9.1. configuracion de web.xml ........................................................................................... 24
2.9.2. Conexión con la base de datos ................................................................................. 25
2.9.3. Creación de paquete model ....................................................................................... 27
2.9.4. CREACION PAQUETE DAO ..................................................................................... 28
2.9.5. CREACIÓN DE CRUD.JSP ....................................................................................... 32
2.9.6. Creación de paquete action ............................................................................................ 34
CONCLUSIONES ........................................................................................................................... 38
RECOMENDACIONES.................................................................................................................. 38
Bibliografía ....................................................................................................................................... 39

4
 CAPÍTULO I
INTRODUCCIÓN

Muchos de los que se dedican al desarrollo de software utilizan, conocen o, como

mínimo, se han tropezado con el concepto de framework (cuya traducción
aproximada sería “marco de trabajo”).
Sin embargo, el concepto de framework no es sencillo de definir, a pesar de que
cualquiera con experiencia programando captará su sentido de manera casi
intuitiva, y es muy posible que esté utilizando su propio framework (aunque no lo
llame así).

En este trabajo se presentará uno de los Frameworks más usados para el desarrollo
web, Struts Framework es un framework java basado en componentes de alta
performance para desarrollar aplicaciones Web de gran escala.

Apache Struts es un framework MVC gratuito y de código abierto para la creación

de aplicaciones web Java elegantes y modernas. Favorece la convención sobre la
configuración, es extensible usando una arquitectura de complemento y se envía
con complementos para admitir REST, AJAX y JSON.

En esta monografía daremos a conocer como trabaja el Framwork struts usando la

estructura MVC (modelo, vista, controlador). Mostraremos el código fuente de un
sistema desarrollado con este framework y explicaremos paso a paso como se llegó
a realizar.

5
OBJETIVOS

1) Desarrollo de un CRUD (Create, Read, Update, Delete) con una base de

datos con el Framework Struts.

2) Conocer las diferentes funciones que ofrece Struts.

3) Aprender a usar Struts Framework para desarrollo web.

6
 CAPÍTULO II

2.1. Framework
1Struts es un framework para construir aplicaciones web Java basadas en la
filosofía MVC. Veremos en este módulo en qué consiste la arquitectura MVC y cómo
la implementa Struts.

Struts es un marco de código abierto que amplía la API de Java Servlet y emplea
una arquitectura de Modelo, Vista y Controlador (MVC). Le permite crear
aplicaciones web mantenibles, extensibles y flexibles basadas en tecnologías
estándar, como páginas JSP, JavaBeans, paquetes de recursos y XML.

2.2. Struts
Antes de entrar en detalles sobre el funcionamiento de Struts vamos a ver
primero la filosofía general de funcionamiento. Veremos también por qué usar Struts
y las posibles alternativas. Hay dos "generaciones" de Struts: la 1.x y la 2. El cambio
de la generación 1 a la 2 no significa únicamente que se hayan añadido nuevas
características. Es un cambio completo, tanto a nivel interno como externo. Cuando
surgió Struts 1 era el único framework existente de este tipo y en su diseño original
había deficiencias en cuanto a flexibilidad y simplicidad de uso. Todo esto se ha
solucionado en la versión 2. No obstante, y de manera paradójica, Struts 2, aun
siendo mucho más potente, flexible y fácil de usar, no ha tenido ni de lejos tanta
difusión como la versión 1, simplemente porque ahora ya tiene la competencia de
otros frameworks como Spring o JSF. Struts 1.x es por tanto, un framework básico
en JavaEE si se considera la gran cantidad de aplicaciones en producción que lo
usan y que habrá que mantener todavía durante unos años. Por eso vamos a ver
sobre todo esta versión. No obstante, para nuevos proyectos la versión
recomendada es la 2.

1
Ciencia de la Computación (2010-2011).

7
2.3. Por qué usar Struts. Alternativas
Antes de hablar de las supuestas bondades de Struts, conviene detenerse
un momento a recalcar la diferencia entre framework y librería. Struts es un
framework, lo cual significa que no solo nos proporciona un API con el que trabajar
(esto ya lo haría una librería) sino también una filosofía de desarrollo, una "forma de
2 hacer las cosas". Por tanto, el primer beneficio de usar un framework es que
estamos haciendo las cosas de una forma ya probada, la misma idea que constituye
la base de los patrones de diseño software. Por supuesto Struts no es el único
framework MVC existente en el mundo J2EE.Aunque existen muchos otros, Struts
es el más extendido con mucha diferencia, hasta el punto de haberse convertirdo
en un estándar "de facto" en el mundo J2EE. Por tanto, usando Struts estamos
seguros de que dispondremos de una gran cantidad de recursos: documentación
(tutoriales, artículos, libros,...) interacción con otros usuarios del framework a través
de foros y similares y una amplia base de desarrolladores expertos a los que
podremos acudir si necesitamos personal para un proyecto.

Hay varios frameworks "alternativos" a Struts. Spring, que veremos en uno de los
módulos siguientes, incorpora también su parte MVC. Webwork, que hasta hace
poco era un framework competidor de Struts se ha unificado con éste dando lugar
a Struts 2. Esta breve discusión sobre otros frameworks "alternativos" no quedaría
completa sin nombrar a JavaServer Faces (JSF), que también se aborda en el
curso. JSF se solapa en algunos aspectos con Struts, ya que también implementa
MVC (aunque de modo distinto). No obstante, la aportación principal de JSF no es
MVC sino los componentes gráficos de usuario (GUI) de "alto nivel" para la web.

2
Ciencia de la Computación (2010-2011).

8
2.4. Requerimientos
Para desarrolladores que deseen utilizar Struts, el entendimiento de
Programación Orientada a Objetos (OOP) será de gran ayuda y el entendimiento
del patrón de arquitectura (MVC).

2.5 Instalación
Para instalar Struts solo debe seguir los siguientes 2 pasos:

1. Descargar el Struts de la página oficial del programa NetBeans IDE y nos

dirigimos a la sección de plugins para descargar el Framewok Struts
http://plugins.netbeans.org/PluginPortal/

Ilustración 1: Pagina de descarga Struts

2. Una vez descargado, descomprimimos el archivo que nos genera y

procedemos a abrir el programa NetBeans.

3. Luego nos dirigiremos a la barra de menú del programa y daremos clic en

Tools y luego damos clic en la opción plugins.

9
 Ilustración 2 Instalacion de Plugins

4. Luego instalamos los paquetes descargados de Struts

Ilustración 3 Selección de Paquetes descargados

5. Luego le damos en instalar y el programa NetBeans se reiniciará

automáticamente y de esa forma ya estaría instalado el Framework Struts.

10
2.6 Creación de una aplicación Framework Struts
Para crear una aplicación aremos los siguientes pasos

1. Le daremos en crear nuevo proyecto

Ilustración 4 Creación de un proyecto

2. Luego le damos le damos en web aplicación

Ilustración 5 Creación de una aplicación web

11
3. Ingresamos el nombre del proyecto

Ilustración 6 Ingresamos nombre para el proyecto

4. Seleccionamos el Framework Struts2 y le damos clic en Finish

Ilustración 7 Seleccionamos Framework Struts

12
2.7. Fundamentos

2.7.1. 3Funcionamiento Clásico de una Aplicación Web

- Jsp. Código incrustado en HTML

- Serlvet. Sentencias println() enormes, se mezcla código con formato
HTML

Se tienen problemas de control de flujo y la capa del negocio se encuentra

incrustada en la programación y el diseño HTML.

Ilustración 8 Funcionamiento Clásico de una Aplicación

2.7.1.1 4Desventajas

 En los servlets se escribe sentencias estilo println(“<html>”);

println(“<head>”).
 Los estilos (css) se encuentran inmersos en la programación.

3
Ing. Israel Ortega Cuevas (2017)
4
Ing. Israel Ortega Cuevas (2017)

13
  En los jsp se mezcla código HTML con código java (llamadas a bases de
datos, generación de ciclos, etc).
 Para un diseñador gráfico puede resultar imposible determinar la apariencia
de la aplicación.
 La lógica del negocio se encuentra insertada junto con la visualización de los
datos.
 El control de flujo de las páginas de la aplicación se encuentra inmerso en la
programación.
 Al no contar con persistencia, se consultan una y otra vez a las tablas de
catálogos.

2.7.2. Modelo vista controlador (MVC)

5 Struts implementa el diseño de patrón modelo-vista controlador

(model-view-controller MVC) el cual es adoptado ampliamente en la
programación Web. El Controlador delega solicitudes en nuestro caso,
solicitudes HTTP (protocolo de transferencia de hipertextos) a un manejador
apropiado. Los manejadores están unidos a un Modelo, y cada manejador
actúa como un adaptador entre la solicitud y el Modelo. El Modelo representa,
o encapsula, un estado o lógica de negocio de la aplicación. Luego el control
normalmente es devuelto a través del Controlador hacia la Vista apropiada.
El reenvío puede determinarse consultando los conjuntos de mapeos,
normalmente cargados desde archivo de configuración. Esto proporciona un
acoplamiento cercano entre la Vista y el Modelo, que puede hacer las
aplicaciones significativamente más fáciles de crear y de mantener.

5
Ing. Israel Ortega Cuevas (2017)

14
 Ilustración 9 Ilustración 10 Ciclo de Proceso de MVC en Struts

2.7.2.1. MVC y Struts

6 Veamos cómo implementa Struts los componentes del patrón Modelo-Vista-
Controlador:

 El controlador es un servlet (servlet es una clase Java que se ejecuta en un

servidor web, es capaz de recepcionar datos, procesar los datos y devolver
respuestas al cliente.), de una clase proporcionada por Struts. Será necesario
configurar la aplicación web (a través del fichero web.xml) para que todas las
peticiones del usuario se redirijan a este servlet.

• El controlador despacha las peticiones del usuario a la clase adecuada para

ejecutar la acción. En struts, las clases que ejecuten las acciones deben
heredar de la clase Action.

• La vista se implementará normalmente mediante páginas JSP. Struts ofrece

dos herramientas para ayudar en la presentación de datos: los ActionForms
son clases que capturan los datos introducidos en formularios y permiten su

6
Ciencia de la Computación (2010-2011).

15
 validación. Las librerías de etiquetas permiten mostrar errores y facilitar el
trabajo con formularios.

• La implementación del modelo corre enteramente a cargo del desarrollador,

ya que es propio de la capa de negocio y no está dentro del ámbito de Struts.

Ilustración 10 ¿Cómo funciona esto en aplicaciones Web?

El navegador genera una solicitud que es atendida por el Controller (un Servlet
especializado). 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. 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.

16
 2.7.3. 7Cronología
 2000 Craig R. McClanahan proporciono un marco de trabajo MVC estándar
a la comunidad Java.
 2000 Donado a la comunidad Apache en mayo.
 2001 julio publico la versión 1.0.
 2003 se separa el framework webwork de Struts, que se funciona con Struts
en 2005 que su versión 2.2 es ahora Struts 2.X febrero de 2007.
 2.2.7 es la última versión de webwork.
 2.1.8.1 16 de noviembre de 2009.
 2.3.1 12 de diciembre de 2011.
 2.3.34 7 de septiembre de 2017.
 2.5.14 23 de noviembre de 2017.
 2.5.14.1 30 de noviembre de 2017.
 2.5.16 16 de marzo de 2018

Ilustración 11 Cronología de Struts

7
Ing. Israel Ortega Cuevas (2017)

17
2.7.4. 8TagLibs
Al igual que Struts 1.x, la versión 2 incluye varias taglibs propias. Además de
haberse mejorado, sobre todo se ha simplificado su uso. Por ejemplo, supongamos
que queremos generar el siguiente formulario y asociar sus campos a un vean de
tipo usuario. Además, queremos mostrar los errores de validación, si los hay.

Ilustración 12 Ejemplo de Aplicación

<%@taglib prefix="s2" uri="/struts-tags" %>

<html>
<head>
<title>Ejemplo de taglib HTML en Struts 2</title>
</head>
<body>
Entrar en la aplicación:<br/>
<s2:form action="login">
<s2:textfield label="usuario" name="usuario.login"/>
<s2:password label="contraseña" name="usuario.password"/>
<s2:submit value="login"/>
</s2:form>
</body>
</html>

8
Universidad Alicante (2014)

18
 • A partir del ejemplo, podemos ver que ha habido varios cambios con respecto
a Struts 1.x:

• Algunas etiquetas han cambiado: por ejemplo, textfield era text en

Struts 1.x

• Los campos de formulario generan también un rótulo con texto

precediéndolos ("Usuario" y "Contraseña"). En Struts 1.x había que ponerlos
manualmente. Tampoco hay que formatear explícitamente los campos para
que aparezcan uno debajo del otro.

• Podemos asociar un campo a una propiedad de un bean sin más que

poner nombre_bean.nombre_propiedad. Las taglibs de Struts 2 usan un
lenguaje de expresiones similar al EL de JSP denominado OGNL.

• No es necesario poner etiquetas para mostrar los errores de forma explícita.

Si activamos la validación (veremos posteriormente cómo hacerlo), al lado
de cada campo aparecerá el mensaje de error correspondiente.

2.7.5. 9Validación

La práctica recomendada en Struts 2 es definir la validación de cada acción

en un XML separado. Por convención el fichero debe tener el mismo nombre que la
clase que define la acción, con el sufijo validation. Es decir, para la clase
LoginAccion debe ser LoginAccion-validation.xml, en el mismo paquete

9
Universidad Alicante (2014)

19
java que la clase de la acción. Veamos un ejemplo, suponiendo que queremos que
login sea obligatorio.

<!DOCTYPE validators PUBLIC

"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-
1.0.2.dtd">
<validators>
<field name="usuario.login">
<field-validator type="requiredstring">
<message>Login no puede estar vacío</message>
</field-validator>
</field>
</validators>

Como se ve, la sintaxis se simplifica bastante con respecto a Struts 1.x. Aunque en
el ejemplo el mensaje de error está fijo en el XML, para simplificar, por supuesto se
puede externalizar a un properties.

Para que nuestra acción soporte validación, debe implementar el

interfaz ValidationAware. Dicho interfaz define varios métodos, para gestionar

Modelo de Error

los errores producidos. Afortunadamente no es necesario implementarlos si nuestra

acción hereda de ActionSupport.

En el XML de configuración un error de validación se asocia con un resultado "input"

(por "herencia" de la palabra clave usada en Struts 1.x). Así, el action del struts.xml
quedaría:

20
<action name="login"
class="es.ua.jtech.struts2.prueba.acciones.LoginAccion">
<result name="ok">/usuario.jsp</result>
<result name="input">/index.jsp</result>
</action>

En ActionSupport se define la constante INPUT con el valor "input", de modo que

en el código java de la acción haríamos un return INPUT si tuviéramos que validar
alguna condición manualmente en el execute() de la acción.

2.7.6. 10Interceptores

Los interceptores son elementos que interceptan la petición antes de que se

ejecute la acción de destino. De este modo se pueden realizar tareas sin tener que
modificar el código de la acción. Podemos decir que desempeñan un papel muy
similar al de los filtros de servlets pero con relación a las acciones. La configuración
por defecto de Struts incluye una pila completa de interceptores activos para todas
las peticiones. De hecho, la inyección de dependencias que veíamos en el ejemplo
de acción es responsabilidad de un interceptor. Y también la validación de campos,
entre otras muchas tareas.

Pese a su importancia, es raro que el desarrollador de Struts tenga que "vérselas"

directamente con los interceptores. Como mucho, tendremos que hacer que
nuestras acciones implementen algún interfaz o hereden de alguna clase para
interactuar con el interceptor. De hecho, recordemos que para la validación
debíamos implementar el interfaz ValidationAware (o heredar de
ActionSupport).

10
Universidad Alicante (2014)

21
2.7.7. 11OGNL y value stack

El value stack, como su nombre sugiere, es una pila donde se colocan objetos
a los que podemos necesitar acceso en un momento dado. Struts coloca en esta
pila, entre otros, la acción a ejecutar y los ámbitos de aplicación, sesión, petición,
etc.

OGNL es un lenguaje de expresiones que se usa para referenciar elementos en

esta pila. Su sintaxis es similar a la del EL de JSP, aunque bastante más potente.
En una aplicación Struts, es en las tags propias del framework donde se usa
habitualmente OGNL. Cuando en un ejemplo anterior poníamos la expresión OGNL
usuario.login, la estábamos buscando en la pila de valores. Como hemos dicho,
la acción se coloca automáticamente en esta pila. OGNL nos permite ir navegando
por objetos relacionados entre sí (Object Graph Navigation Language). De este
modo podemos acceder a la propiedad usuario de la acción y dentro de ella a la
propiedad login. Al igual que en EL, cuando ponemos objeto.propiedad, se
asume que accedemos a ésta a través de métodos get/set.

2.7.8. 12Ventajas de usar Struts

• Implementa el patrón de arquitectura MVC (Model-View-Controller) cuyo

propósito principal es separar el código de la capa de presentación del código
de la capa de negocio facilitando la asignación de roles y la especialización
defunciones dentro del marco de un proyecto.

• El controlador ya se encuentra implementado por Struts: Las acciones que

se ejecutarán sobre el modelo de objetos de negocio se implementan

11
Universidad Alicante (2014)
12
Scribd (2018)

22
 basándose en clases predefinidas por el framework, siguiendo el patrón
Facade.La generación de interfaz se soporta mediante un conjunto de Tags
predefinidos por Struts cuyo objetivo es evitar el uso de Scriptlets (trozos de
código Java entre "<%" y "%>"), lo cual genera ventajas de mantenimiento
del código y de performance de la aplicación en desarrollo.

• Potencia la reutilización de código y soporta múltiples interfaces de usuario

(Html, sHtml, Wml, Desktop applications, etc.).

• Struts implementa varios patrones de diseño de la arquitectura J2EE tales

como:
- Service to worker
- Dispatcher View
- Front Controller
- View Helper
- Synchronize (Déjà vu) Token
- Ya que Struts está basado en tecnologías estándares como Java
Servlets, JavaBeans, XML, hereda el ambiente de estos estándares y
puede operar con cualquier tecnología basada en JSP o Servlet.
- Beneficio en términos de costo por licencia: Struts es un Open
SourceSoftware (OSS), lo que significa que su uso es libre.

2.8.8. 13Desventajas de usar Struts

• Se requiere por parte de los desarrolladores un conocimiento profundo y

detallado de Servlets y JSPs lo que representa una curva de aprendizaje,
quede requerirse no se recomienda en proyectos cortos.

13
Scribd (2018)

23
 • En comparación con la tecnología de Servlets y JSPs, los desarrolladores
principiantes encuentran que la documentación en línea de
www.Apache.orges confusa y pobremente organizada. Existen menos libros
de Struts que de Servlets y JSPs.

• Existen opiniones encontradas en cuanto al tema de la implementación que

hace Struts del patrón de arquitectura MVC. Para muchos, este “código
escondido” le quita transparencia a las aplicaciones construidas con Struts y
las hace más difícil de entender.

2.9. Creación de crud framework struts2

2.9.1. configuracion de web.xml

Paso 1:

Configuración el archivo web.xml que se encuentra en Web Pages en el folder de

WEB-INF y archivo web.xml

24
Paso 2:

Luego creamos un jsp llamado index.jsp en la carpeta Web Pages Y realizamos los
siguientes pasos en Index.jsp.

2.9.2. Conexión con la base de datos

Paso 1:

Creamos un paquete llamado database en la carpeta Source Packages luego

creamos una clase llamado BDConnect

25
Paso 2:

Creamos variables username,pass y url, el username y pass debe ser el nombre de

usuario de tu apache , el url se coloca la ruta de servidor y que tipo de Gestor de
base de datos vamos a utilizar en este caso es mysql y también ponemos la base
de datos a utilizar en ese caso es eurekabank y la variable conn es para la variable
conexión

Paso3:

Creamos un método getConnection , luego ponemos la ruta del driver mysql y luego
ponemos DRIVERMANAGER.getconnection y ponemos el url, username y pass
luego retornamos con la conexión y créalos una clase close para cerrar la conexión

Declaración de variables

Método de conexión

Cerrar conexión

26
2.9.3. Creación de paquete model

Paso 1:

Creamos un paquete llamado model y dentro del paquete creamos clase llamado
surcursal

Paso 2:

Creamos variables dentro de la clase sucursal chr_sucucodigo, String

vch_sucunombre, String vch_sucuciudad y String vch_sucudireccion luego creamos
los getters y los setters de cada variable luego creamos métodos constructor uno
sin parámetros para crear instancia de objetos y otro método constructor con todos
los parámetros para llenarlos en la clase CRUD que esta en el paquete action

27
2.9.4. CREACION PAQUETE DAO

Paso 1:

Crear el paquete DAO con un Interface SucursalDAO ese sucursalDAO y una clase
SucursalDAOIml:

Paso 2:

En sucursalDAO creamos métodos:

28
PASO 3:

Luego creamos la clase SucarlDAOImpl extends al interface SucursalDAO y

automáticamente SucursalDAOlimp hereda todos los métodos de SucursalDAO

Paso 4:

En el método getallsucursal() realizamos los siguientes proceso:

29
Paso 5:

En el método insert realizamos los siguientes pasos:

Paso 6:

El método update realizamos los siguientes pasos:

30
Paso 7:

El método delete realizamos los siguientes procesos:

Paso 8:

El método getsucursalById ese método nos servirá para mostrar datos antes de
actualizar

31
2.9.5. CREACIÓN DE CRUD.JSP

Paso 1:

Creamos un jsp llamado CRUD en el folder WebPages

PASO 2:

Creamos una tabla con los siguientes pasos:

32
PASO 3:

Luego creamos un formulario con los siguientes pasos:

CONFIGURACION STRUTS.XML

PASO 1:

Entramos al paquete source package luego entramos al paquete <default package>

Y entramos a struts.xml

33
PASO 2:

Realizamos los siguientes pasos dento de struts.xml

2.9.6. Creación de paquete action

Paso 1:

Creamos paquete action y dentro del paquete action creamos una clase llamado
CRUD

34
PASO 2:

El CRUD crearemos los siguientes pasos:

35
VistaSISTEMA

36
37
 CONCLUSIONES

1) Se llegó a crear el CRUD con el Framework Struts.

2) Se llegó a conocer todas las funcionalidades que ofrece struts.

3) Se logró aprender el funcionamiento de Struts para la construcción de

aplicaciones web.

RECOMENDACIONES

1) Recomendamos leer bien el manual de Struts para un mejor uso.

2) Si van a trabajar con NetBeans, Descargar el Framework Struts en la

página oficial de netbeans en la sección Pluglins.

3) Es importante tener conocimiento de POO (Programación Orientado a

Objetos).

4) Es importante tener conocimientos del patrón de arquitectura de software

(MVC) ya que este framework está basado en esa estructura

38
BIBLIOGRAFÍA
Ing. Israel Ortega Cuevas (2017). Funcionamiento Clásico de una aplicación.
Recuperado de: https://www.redisybd.unam.mx/rss/ponencias/DGPEStruts2.pdf.

Ing. Israel Ortega Cuevas (2017). Modelo Vista Controlador. Recuperado de:
https://www.redisybd.unam.mx/rss/ponencias/DGPEStruts2.pdf.

Ing. Israel Ortega Cuevas (2017). Cronología. Recuperado de:

https://www.redisybd.unam.mx/rss/ponencias/DGPEStruts2.pdf.

Universidad Alicante (2014). TagLibs. Recuperado de:

http://www.jtech.ua.es/j2ee/publico/struts-2010-11/sesion04-struts-
apuntes.html#Validaci%C3%B3n

Universidad Alicante (2014). Validación. Recuperado de:

http://www.jtech.ua.es/j2ee/publico/struts-2010-11/sesion04-struts-
apuntes.html#Validaci%C3%B3n

Universidad Alicante (2014). OGNL y value stack. Recuperado de:

http://www.jtech.ua.es/j2ee/publico/struts-2010-11/sesion04-struts-
apuntes.html#Validaci%C3%B3n

Scribd (2018). Ventas de usar Struts. Recuperado de:

https://es.scribd.com/doc/112443456/Ventajas-y-Desventajas-de-Usar-Struts

39
Scribd (2018). Desventajas de usar Struts. Recuperado de:
https://es.scribd.com/doc/112443456/Ventajas-y-Desventajas-de-Usar-Struts

Ciencia de la Computación (2010-2011). Framework Struts. Recuperado de:

http://www.jtech.ua.es/j2ee/publico/struts-2010-11/sesion04-struts-apuntes.pdf

Netbeans (2018).Introduction al Struts Web Framework. Recopilado de:

https://netbeans.org/kb/docs/web/quickstart-webapps-struts.html

Programacion en castellano. (2017). Manual Básico de Struts. Recuperado de:

https://programacion.net/articulo/manual_basico_de_struts_156

40