Pontificia Universidad Javeriana Manual de instalación y...

Pontificia Universidad Javeriana Manual de instalación y configuración de WAPP Generator

Página 1

ANEXO 4:

DOCUMENTACIÓN DEL TRANSFORMADOR

DE LA APLICACIÓN WEB GENERATOR (WAPP Generator)

FERNEY SANTOS AGUILLÓN MARTÍNEZ

MARIO ALONSO MATEUS GÓMEZ

PONTIFICIA UNIVERSIDAD JAVERIANA

FACULTAD DE INGENIERÍA

CARREA DE INGENIERÍA DE SISTEMAS

BOGOTÁ D.C.

2014


Página 2

Tabla de contenido

Tabla de Ilustraciones................................................................................................................ 4

1. Introducción ...................................................................................................................... 5

2. Herramientas Utilizadas para la Transformación .............................................................. 5

3. Transformador V1.0 .......................................................................................................... 5

4. Transformador V2.0 .......................................................................................................... 7

5. Transformador V3.0 .......................................................................................................... 8

6. Transformador V4.0 ........................................................................................................ 10

7. Transformador V5.0 ........................................................................................................ 10

8. Transformador V6.0 ........................................................................................................ 12


Página 3


Página 4

Tabla de Ilustraciones

Ilustración 1: Archivos generate.mtl. ............................................................................................ 5

Ilustración 2: Directorio src-gen. .................................................................................................. 6

Ilustración 3: generate.mtl V2.0. ................................................................................................... 7

Ilustración 4: Generación de la aplicación web. ............................................................................ 8

Ilustración 5: Plantilla faces-config.xml. ...................................................................................... 9

Ilustración 6: Plantilla Acceleo Generación Tabla. ..................................................................... 10

Ilustración 7: Invocación método generateRelations. ................................................................. 11

Ilustración 8: Fragmento método generateRelations. .................................................................. 11

Ilustración 9: Plantillas generación CRUD. ................................................................................ 11

Ilustración 10: Fragmento de código web.xml. ........................................................................... 12

Ilustración 11: Carpeta de archivos prexistentes. ........................................................................ 13

Ilustración 12: Fragmento plantilla menú. .................................................................................. 13

Ilustración 13: Plantilla sql. ......................................................................................................... 14


Página 5

1. Introducción

Este documento presenta una documentación sobre el transformador del meta-modelo de la

aplicación web a código en tecnología Java EE 6 utilizando como framework de desarrollo JSF

2.2, utilizando como servidor de aplicación GlassFish 4.0 e IDE Netbeans 7.4.

Al igual que el meta-modelo, el transformador fue desarrollado incrementalmente para ir

transformando este a medida que se hacen cambios incrementales.

2. Herramientas Utilizadas para la Transformación

Para la transformación del metamodelo de la aplicación web se utilizó la herramienta Acceleo,

el cual es una implementación del OMG (Object Management Group) para transformar un

modelo MOF a un lenguaje textual. Esta herramienta es un plugin del IDE Eclipse, lo que la

hace muy útil debido a que la integración con el proyecto Emf también desarrollado por Eclipse

la hace la mejor elección.

3. Transformador V1.0

Para desarrollar la primera versión del transformador, debido a que una aplicación web solo

tenía un conjunto de páginas web, donde estas a su vez solo tienen las siguientes propiedades:

nombre del archivo, título, altura y ancho de la página web.

En la siguiente ilustración se muestra el archivo de generación en Acceleo:

Ilustración 1: Archivos generate.mtl.


Página 6

El archivo generate.mtl es el modulo principal donde tiene como entrada una aplicación web,

este archivo sirve como punto central para utilizar los demás módulos y generar los archivos

necesarios para poder crear una aplicación web en Java EE 6, utilizando como servidor de

aplicación.

Los siguientes son los módulos con los que cuenta el transformador:

El archivo pageGenerate.mtl es el módulo para la generación de las páginas web.

El archivo buildGenerate.mtl es el módulo para la generación del archivo build.xml del

proyecto web.

El archivo webFileGenerate.mtl es el módulo que se encarga de la generación del

archivo web.xml necesario para la configuración del proyecto web en Java EE6.

El archivo manifestGenerate.mtl es el módulo que crea el archivo MANIFEST.MF.

El archivo antDeployGenerate.mtl es el módulo que crea el archivo ant-deploy.xml del

proyecto de la aplicación web, necesario para la construcción y compilación de la

aplicación web.

El archivo build-impl.mtl, módulo que se utiliza para la creación del archivo build-

impl.xml necesario para la compilación del proyecto.

El archivo propertiesFilesGenerate.mtl, genera los archivos de propiedades que son

utilizados en la compilación de la aplicación web.

El archivo projectFileGenerate.mtl, es el encargado de generar el archivo project.xml.

Una vez que el archivo generate.mtl es ejecutado es generado dentro de la carpeta src-gen, la

aplicación web, como se puede observar en la siguiente ilustración:

Ilustración 2: Directorio src-gen.

Para el desarrollo del primer Sprint se desarrolló el meta-modelo que se muestra en la

Ilustración 1.


Página 7


Para el desarrollo del segundo transformador se eliminó la generación de archivos que no eran

estándar y que solamente se utilizaban para poder generar el proyecto directamente a NetBeans,

sin embargo el objetivo del transformador es ser independiente de tecnología, por lo que se

generó los archivos estándar de un proyecto web en Java EE 6.

En la siguiente ilustración se muestra los modulos desarrollados para llevar a cabo la

transformación del modelo ajustándose a los objetivos de generación de páginas web con

formularios web.

Ilustración 3: generate.mtl V2.0.

Como se puede observar al archivo generate.mtl se removieron varios módulos que no eran

estándar en un proyecto Java EE 6. Asimismo se agregaron los siguientes módulos para cumplir

con los objetivos del transformador.

El archivo pageGenerate2.mtl que genera páginas web sin un estilo css y sin una

plantilla.

El archivo FaceletTemplateGenerate.mtl genera un archivo plantilla Facelet que es

utilizado por JSF, para poder ser utilizada si se desea crear otra página, dándole

uniformidad a la presentación del proyecto.

El archivo entitiesGenerate.mtl, genera las entidades modeladas y que serán

utilizadas dentro de los campos de los formularios, estas entidades contienen las

anotaciones necesarias para mapear la entidad con una tabla en una base de datos

relacional.

El archivo cssStyleGenerate.mtl, genera el archivo css que es necesario para poder

generar la plantilla Facelet.


Página 8

Finalmente el archivo managebBeansGenerate.mtl, genera los MangebBean que

son utilizados por las paginas para llevar acabo las solicitudes de las páginas web.

Al igual que en la anterior iteración el proyecto Web generado por el proyecto se encuentra

dentro de la carpeta src-gen, como se puede observar en la siguiente ilustración de la estructura

del proyecto generado:

Ilustración 4: Generación de la aplicación web.

Como ejemplo se modelo una aplicación web con dos entidades llamadas Adress y Customer

son generadas asimismo se generaron los ManagedBean que llevaran a cabo las solicitudes de

las páginas, también son generados los archivos css para los Facelets. Por último se generaron

las páginas web modeladas junto como el Facelet si se desea tener una aplicación con estilo css.


Debido a que en el tercer sprint se modelo la transición entre las páginas web de una aplicación

web, fue necesario transformar esto en elementos que se manejan en Java EE 6, fue necesario


Página 9

generar el faces-config.xml¸ ya que este se encarga de manejar el flujo de navegación de la

aplicación web en Java EE 6. Asimismo por medio de los ManagedBean y los Ejb se generaban

las acciones que debían soportar las transiciones, como si estas transiciones poseían condiciones

para poder llevar a cabo la transición.

Para la generación del faces-config.xml, fue necesario la creación de una plantilla web que

transformara el modelo al código xml. En la siguiente ilustración se muestra esta plantilla:

Ilustración 5: Plantilla faces-config.xml.

Como se observa en esta plantilla, esta recorre todas las páginas, igualmente en cada página se

recorren los botones que son los que tienen una relación con la transición entre la paginas. Por

medio de las etiquetas <navigation-rule>, <navigation-case> y la etiqueta <from-action>.

Dentro de la etiqueta <navigation-rule> se definen la página de origen, asimismo dentro de

cada etiqueta <navigation-case>, se define la página de destino y dentro de esta etiqueta se

utiliza <from-action>, donde se define la acción relacionada con esta transición, igualmente si

dentro de esta transición se existe una condición, esta es definida por medio de la etiqueta <if>,

donde se determina que condición se debe cumplir para poder llevar a cabo la transición entre

las páginas.


Página 10


Para cumplir con la transformación de tablas dentro de las páginas web se agregaron dentro de

las plantillas de Acceleo donde se generan las páginas web, se agregó ciclos que recorriera todas

las tablas que posee una página web. Igualmente como cada tabla tiene un conjunto de

elementos, en la plantilla se recorrieron para generar las columnas de la tabla en particular. En la

siguiente imagen se muestra un fragmento de la plantilla de Acceleo para la generación de

tablas:

Ilustración 6: Plantilla Acceleo Generación Tabla.

Como se observa cada tabla está relacionada con una lista de una entidad en específico,

igualmente cada columna de esta tabla está relacionada con un atributo de una entidad en

específico. Por último se generan los botones que tienen la tabla.

Por otro lado dentro de cada ManagedBean se generó un atributo lista del tipo de entidad en

particular que soportara el caso de uso. Para la generación de este atributo dentro del caso de

uso fue necesario la utilización de servicios java por medio de la clase Utils.java.


Dentro del quinto sprint se definió el módulo de entidades, sin embargo debido a la introducción

temprana de este elemento dentro del meta-modelo, la plantilla de acceleo para la entidad no

tuvo grandes cambios, modificándose únicamente las nuevas restricciones de atributos

agregadas al meta-modelo y el cambio en la definición de relación entre entidades, utilizando un


Página 11

límite inferior y un límite superior en la relación. Por último, para hacer las relaciones

bidireccionales se utilizó servicios java dentro de la clase definida Utils.java. Se puede observar

en la siguiente ilustración el uso de del servicio java para la generación de las relaciones

bidireccionales:

Ilustración 7: Invocación método generateRelations.

Con el método generateRelations(), se invoca el método en llava para generar las relaciones

bidireccionales. En la siguiente ilustración se muestra la definición de este método dentro de la

clase Utils.java:

Ilustración 8: Fragmento método generateRelations.

Este método utiliza un HashMap para determinar las relaciones que tiene una entidad en

particular con otras entidades.

Por otro lado se genere el CRUD de cada entidad, generando páginas web, managedbean y ejbs

para soportar los métodos necesarios para llevar a cabo los ejbs. Estas plantillas se encuentran

dentro del paquete javeriana.edu.co.acceleo.webgenerator.m2t.templates. En la siguiente

ilustración se muestran las plantillas creadas para cada entidad:

Ilustración 9: Plantillas generación CRUD.


Página 12

Asimismo dentro de las plantillas de ManagedBean y Ejb, se agregó que cada una de estas

genera ManagedBean y Ejbs asociados a una entidad en particular.


Dentro del sexto y último sprint estaba propuesto el módulo de seguridad. Para llevar a cabo

esto, se protegieron los ejb haciendo uso de la anotación @RolesAllowed , en la que una lista de

roles que pueden hacer uso de los ejb. Por otro lado para la protección de las páginas web, fue

necesario la creación de un plantilla que creara el web.xml, que es el archivo de configuración

donde se definen las restricciones de seguridad de las páginas web dentro de la aplicación web,

debido a que anteriormente este archivo era prexistente. En la siguiente imagen se muestra un

fragmento de la plantilla web-xml en acceleo:

Ilustración 10: Fragmento de código web.xml.

Como se observa se recorre cada página del meta-modelo y si esta tiene unos roles asociados se

generan las restricciones de acceso. El mismo proceso es utilizado para la protección de las

páginas que hacen parte del CRUD de una entidad, con la diferencia que en este se protegen un

grupo de páginas y no una página en particular.

Por otro lado dentro de la herramienta se incluyen los archivos prexistentes que se muestran en

la siguiente ilustración:


Página 13

Ilustración 11: Carpeta de archivos prexistentes.

Dentro de los nuevos archivos prexistentes se encuentran:

Auth.java: ManagedBean encargada de validar la autenticación y autorización a los

recursos web por parte de un rol.

Error.xhtml: Pagina cuando la autenticación no se pudo llevar a cabo.

Role.java: Entidad que representa la tabla role.

User.java: clase que representa en memoria la tabla User.

UserFacade: Ejb encargado de gestionar los métodos de negocio de la entidad User.

Utils: clase auxiliar que contiene el método para encriptar la contraseña al algoritmo

MD5.

Adicionalmente se creó una página web que tuviera el menú con los enlaces a las páginas web y

las páginas de los CRUD de las entidades, mostrándose únicamente los enlaces si se tienen los

permisos necesarios para acceder a las páginas web. En la siguiente ilustración se muestra la

plantilla acceleo de la página web menú.xhtml:

Ilustración 12: Fragmento plantilla menú.


Página 14

Como se observa se recorren todas las páginas del modelo y se generan los enlaces con sus

correspondientes restricción de seguridad.

Por último la transformación genera un archivo .sql para la inserción de los roles modelados

dentro de la tabla rol. A continuación se puede observar la plantilla Acceleo para la creación de

este script:

Ilustración 13: Plantilla sql.

Adicionalmente se crea el rol admin asociado a un usuario, que podrá acceder a todos los

recursos de la aplicación web. Vale la pena a clarar que si la aplicación no posee seguridad, se

utiliza el archivo web.xml prexistente.

Pontificia Universidad Javeriana Manual de instalación y...

Documents

Transcript of Pontificia Universidad Javeriana Manual de instalación y...