Download Lista de Tablas - Pontificia Universidad Javeriana

Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
ANEXO 5:
MANUAL DE ADMINISTRACIÓN Y USUARIO DE LA HERRAMIENTA
APPLICATION 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 1
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Tabla de Contenidos
Lista de ilustraciones ................................................................................................................. 3
Lista de Tablas .......................................................................................................................... 5
1.
Introducción ...................................................................................................................... 6
1.1
Rol Mantenimiento Meta-Modelo ............................................................................. 6
1.2
Rol Modelador de la Aplicación web ........................................................................ 6
1.3
Rol Mantenimiento de los Transformadores de Java EE 6 ....................................... 6
1.4
Rol desarrollador que completa el código generado ................................................. 6
2.
Requisitos previos ............................................................................................................. 6
3.
Rol Mantenimiento Meta-modelo ..................................................................................... 7
4.
5.
3.1
Diseño del Meta-modelo ........................................................................................... 7
3.2
Características herramienta modelado..................................................................... 10
A.
Archivo webApplication.ecore ................................................................................ 10
B.
Archivo webApplication.ecorediag ......................................................................... 12
Rol Modelador de Aplicaciones Web ............................................................................. 15
4.1
Instancia dinámica de la Meta-clase WebApplication ............................................ 15
4.2
Agregar nuevo elementos al modelo jerárquico ...................................................... 16
4.3
Ventana de Propiedades .......................................................................................... 18
4.4
Transformación modelo a la aplicación Java EE 6 ................................................. 18
4.5
Estructura de la aplicación generada ....................................................................... 20
Rol de Mantenimiento de los Transformadores para Java EE 6 ..................................... 20
5.1
Características herramienta de transformación ....................................................... 21
5.2
Diagrama de invocación (Gestión de plantillas) ..................................................... 21
5.2.1
5.3
6.
Plantilla generate.mtl ....................................................................................... 23
Elementos generales dentro de una plantilla común: .......................................... 24
Rol desarrollador que completa la aplicación generada .................................................. 32
6.1
Crear proyecto en Netbeans 7.4 .............................................................................. 32
6.2
Configuración Unidad de Persistencia. ................................................................... 33
6.3
Configuración de seguridad..................................................................................... 33
Página 2
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Lista de ilustraciones
Ilustración 1: Diseño del meta-modelo. ........................................................................................ 7
Ilustración 2: Archivo webApplication.ecore. ............................................................................ 11
Ilustración 3: Archivo webApplication.ecore. ............................................................................ 11
Ilustración 4 Agregar meta-clase................................................................................................. 12
Ilustración 5: Propiedades meta-clase. ........................................................................................ 12
Ilustración 6: Archivo webApplication.ecorediag....................................................................... 13
Ilustración 7: Archivo webApplication.ecorediag....................................................................... 13
Ilustración 8: Propiedades Atributo............................................................................................. 14
Ilustración 9: Propiedades Relación. ........................................................................................... 14
Ilustración 10: Propiedades Atributo booleano. .......................................................................... 14
Ilustración 11: Creación instancia dinámica. .............................................................................. 15
Ilustración 12: Archivo instancia dinámica. ................................................................................ 16
Ilustración 13: Editor jerárquico para la instancia....................................................................... 16
Ilustración 14: Ejemplo agregando un nuevo elemento a WebApplication. ............................... 17
Ilustración 15: Ejemplo agregar nuevo elemento a una entidad.................................................. 17
Ilustración 16: Ventana propiedad WebApplication. .................................................................. 18
Ilustración 17: Ventana propiedades Entity. ............................................................................... 18
Ilustración 18: Ejecución archivo generate.mtl. .......................................................................... 19
Ilustración 19: Ventana de configuración. .................................................................................. 19
Ilustración 20: Estructura proyecto generado. ............................................................................. 20
Ilustración 21: Diagrama de invocación de plantillas. ................................................................ 21
Ilustración 22: Importar la plantilla entitiesGenerate. ................................................................. 24
Ilustración 23: Invocación método generación de las entidades. ................................................ 24
Ilustración 24: Archivo entitiesGenerate..................................................................................... 25
Ilustración 25: Fragmento plantilla entitiesGenerate. ................................................................. 25
Ilustración 26: Etiquetas if dentro de plantilla. ........................................................................... 26
Ilustración 27: Etiqueta for dentro de la plantilla. ....................................................................... 26
Ilustración 28: Ubicación clase Utils.java. .................................................................................. 27
Ilustración 29: Fragmento clase Utils.java. ................................................................................. 28
Ilustración 30: Ubicación utilsGenerate.mtl. ............................................................................... 28
Ilustración 31: Firma método generateRelations......................................................................... 29
Ilustración 32: Invocación de método generateRelations. ........................................................... 29
Ilustración 33: Archivos prexistentes. ......................................................................................... 30
Página 3
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 34: Estructura del proyecto generado. ....................................................................... 31
Ilustración 35: Arquitectura aplicación generada. ....................................................................... 31
Ilustración 36: Ventana creación proyecto. ................................................................................. 32
Ilustración 37: Unidad de persistencia. ....................................................................................... 33
Ilustración 38: Consola de administración GlassFish. ................................................................ 34
Ilustración 39: Dominios de seguridad........................................................................................ 34
Ilustración 40: Configuración dominio de seguridad. ................................................................. 35
Ilustración 41: Archivo glassfish-web.xml. ................................................................................ 36
Ilustración 42: Despliegue aplicación web. ................................................................................. 36
Ilustración 43: Ubicación insert-roles.sql.................................................................................... 37
Ilustración 44: Archivo insert-roles.sql. ...................................................................................... 37
Ilustración 45: Ejecución aplicación web.................................................................................... 38
Ilustración 46: Página modelada en ejecución. ........................................................................... 38
Ilustración 47: Página detalle de una entidad. ............................................................................. 39
Página 4
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Lista de Tablas
Tabla 1: Descripción meta-clases. ............................................................................................... 10
Tabla 2: Descripción diagrama de invocación con seguridad. .................................................... 22
Tabla 3: Descripción diagrama de invocación plantillas............................................................. 23
Página 5
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
1. Introducción
Este manual pretende documentar la administración de la herramienta Wapp Generator. Teniendo
en cuenta los roles que se encargan de la administración, este manual tendrá una sección dedicada
al rol Mantenimiento del Meta-modelo y al rol Mantenimiento de los Transformadores para Java
EE 6.
Los roles que se involucran durante el uso y mantenimiento del ambiente Wapp Generator son
los siguientes:
1.1 Rol Mantenimiento Meta-Modelo
Este rol se encarga de modificar el meta-modelo del ambiente Wapp Generator. Agregando
elementos al meta-modelo o modificando los elementos existentes. Encargándose principalmente
de la administración del meta-modelo.
1.2 Rol Modelador de la Aplicación web
Este rol actúa principalmente como usuario del ambiente Wapp Generator, para modelar una
aplicación web utilizando el meta-modelo definido previamente. Asimismo esta persona debe
tener en cuenta en sus modelos los cambios que sean realizados a la definición del meta-modelo.
1.3 Rol Mantenimiento de los Transformadores de Java EE 6
Esta rol se encarga de modificar y agregar nuevas plantillas cuando quiera hacer un cambio en la
transformación del modelo a la aplicación en tecnología en Java EE 6. Igualmente esta persona
se encarga de que las plantillas del transformador este completamente adaptada al meta-modelo.
Este rol se encarga de la administración del transformador.
1.4 Rol desarrollador que completa el código generado
Este rol actúa como usuario, debido a que es la encargada de configurar la aplicación web
generada para que pueda se desplegada y ejecutada. Dentro de las tareas de este rol se encuentra
la configuración de la base de datos, la configuración del servidor web y agregar las librerías al
proyecto.
2. Requisitos previos
La herramienta WAPP Generator debe estar instalada. Para instalar la herramienta revise el
Manual de Instalación de la herramienta.
Página 6
Manual de administración de WAPP Generator
Pontificia Universidad Javeriana
3. Rol Mantenimiento Meta-modelo
En la presente sección, mostraremos la forma en que la persona encargada podrá hacer el
mantenimiento y definición del meta-modelo, agregando nuevos elementos como meta-clases,
atributos y relaciones entre las meta-clases.
3.1 Diseño del Meta-modelo
Para la definición del meta-modelo de la aplicación web se identificaron los elementos
característicos en todas las aplicaciones web, independiente de la tecnología. A continuación se
muestra el diseño del meta-modelo:
Ilustración 1: Diseño del meta-modelo.
En la siguiente tabla se muestra la descripción de cada meta-clase:
Página 7
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Meta-Clase
Definición
WebApplication
Es el punto de partida para 
NameAplication:
modelar la aplicación web. En
Nombre de la aplicación.
esta meta-clase se definen las 
Banner: condicional para
características básicas de la
definir si la página tiene
aplicación web.
banner.
Atributos

Security:
condicional
para determinar si la
aplicación
tendrá
seguridad.

cssStyle: define si la
página usara un css.
UseCase
Representa un caso de uso 
Name: nombre del caso
dentro de la aplicación, en la
de uso.
cual
la
meta-clase
WebApplication
tiene
conjunto
metaclases
de
un
UseCases. Estos casos de
usos además contienen un
conjunto de acciones, que son
soportados por este.
Action
Meta-clase que representa 
Name: nombre de la
una acción dentro del meta-
acción.
modelo. Esta meta-clase es 
Condition: se define un
usada
nombre de la condición si
por
la
meta-clase
la
UseCase.
acción
tiene
una
nombre
del
condición.
WebPage
Representa dentro del meta- 
Name:
modelo una página web. La
archivo de la página.
meta-clase

WebApplicationWeb tiene un
conjunto de esta meta-clase.
Title: título de la página
web.

Width: ancho de la página
web.

Height:
altura
de
la
página web.
Página 8
Manual de administración de WAPP Generator
Pontificia Universidad Javeriana
Table
Esta clase es utilizada para
modelar una tabla dentro de
una página web. Siguiendo
este orden de ideas la metaclase WebPage tiene una
colección de la meta-clase
Table. Asimismo la metaclase está relacionada con la
meta-clase Entity, ya que este
elemento es el encargado de
mostrar el valor de los
atributos
de
todas
las
entidades.
Text
Meta-clase
utilizado
para 
determinar que campos de la
Header: Titulo que tendrá
cada columna.
entidad serán mostrados en la
tabla, esta meta-clase está
relacionada con los atributos
de la entidad.
Forms
Esta meta-clase es utilizada 
Id: identificación único
cuando se desea modelar un
del formulario.
formulario, asimismo la metaclase
WebPage
tiene
un
conjunto de Forms.
Element
Meta-clase que sirve para 
Id: identificación único
modelar un elemento dentro
del elemento.
de un formulario. Asimismo 
Value: label relacionado a
como esta meta-clase sirve
los campos de entrada
como
padre
para
las
metaclases:

RadioButton.

ComboBox.

TextField.

DateField.

CheckBox.
Página 9
Manual de administración de WAPP Generator
Pontificia Universidad Javeriana
Cada
está
Element
relacionado con un atributo de
la entidad.
ButtonLink
ButtonLink permite modelar 
Id: identificación único
un botón dentro del meta-
del boton.
ButtonLink 
modelo.
asimismo permite definir una
Value:
texto
que
se
mostrara en el botón.
transición de una página a
otra.
Permite
Transition
modelar
una
transición de una página a
otra. Está relacionada con la
meta-clase
ButtonLink,
WebPage y Action.
Action
Permite modelar una acción 
Name: Nombre de la
que es llevada a cabo por un
aplicación.
botón en medio de una 
Condition: nombre de una
transición entre páginas. Esta
condición si la acción
meta-clase
posee alguna condición.
se
encuentra
relacionada con la meta-clase
UseCase, debido a que este
último
tiene
definido un
conjunto de acciones.
Permite modelar un rol dentro 
Role
Name: nombre del rol.
de la aplicación web.
Tabla 1: Descripción meta-clases.
3.2 Características herramienta modelado
La
herramienta
Wapp
Generator
cuenta
con
el
proyecto
javeriana.edu.co.emf.webgenerator.model, en este proyecto se define las reglas del meta-modelo
y se modelan las aplicaciones, por medio Eclipse Modeling Framework (EMF).
A.
Archivo webApplication.ecore
El
proyecto
javeriana.edu.co.emf.webgenerator.model,
cuenta
con
el
archivo
webApplication.ecore. Por medio de este archivo se define los elementos que componen el metamodelo de la aplicación web. En la siguiente imagen se muestra la carpeta model:
Página 10
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 2: Archivo webApplication.ecore.
El archivo webApplication.ecore muestra de forma jerárquica la definición del meta-modelo. En
la siguiente figura se muestra la definición meta-modelo de forma jerárquica:
Ilustración 3: Archivo webApplication.ecore.
Por medio de este archivo se pueden agregar nuevos elementos como meta-clases, nuevos
atributos a una meta-clase, relaciones, etc. Al mostrar el meta-modelo de forma jerárquica al
adicionar se debe posicionar sobre el elemento y elegir el nuevo tipo de hijo que se desea colocar.
En la siguiente imagen se ve un ejemplo cuando se desea agregar una nueva meta-clase al metamodelo:
Página 11
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 4 Agregar meta-clase.
Como se observa para agregar una nueva meta-clase al meta-modelo, se debe posicionar en el
paquete y enseguida se da click derecho, se elige la opción new child, finalmente se elige
EClass.
Uno de las herramientas más importantes durante la definición del meta-modelo es la ventana de
propiedades, ya que aquí podemos modificar y dar valores a las propiedades de una meta-clase.
A continuación se muestra la ventana de propiedades de la meta-clase WebApplication:
Ilustración 5: Propiedades meta-clase.
En la figura anterior se muestra las propiedades de la meta-clase entre las que están: determinar
si es una clase abstracta, determinar si es una interfaz, el nombre de la meta-clase, etc.
B.
Archivo webApplication.ecorediag
El archivo webApplication.ecorediag, este es una representación gráfica del archivo
webApplication.ecore. En este archivo se muestra el diagrama el meta-modelo, haciendo esta vista
Página 12
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
más intuitiva para la definición del meta-modelo. Este archivo se encuentra en la carpeta model
dentro del proyecto javeriana.edu.co.emf.webgenerator.model, esta ubicación se muestra en la
siguiente figura:
Ilustración 6: Archivo webApplication.ecorediag.
Este archivo además cuenta con una paleta que permite arrastrar los elementos como meta-clase,
atributos, relaciones, etc., haciendo más intuitivo y natural el proceso de modelaje. A continuación
se muestra la ilustración del archivo .ecorediag:
Ilustración 7: Archivo webApplication.ecorediag.
Al lado izquierdo se observa la paleta con la que cuenta el editor del diagrama, donde se observa
los elementos comunes cuando se define el meta-modelo. Entre estos se encuentra, EClass,
EAttribute, EReference, EOperation, EEnum, entre otros.
Todos los cambios efectuados dentro del archivo webApplication.ecorediag, se verán reflejados
en el archivo webApplication.ecore.
Página 13
Manual de administración de WAPP Generator
Pontificia Universidad Javeriana
Al igual que en archivo .ecore, la ventana de propiedades es útil para definir los valores a un
elemento en particular. En la siguiente figura se muestra las propiedades de un atributo:
Ilustración 8: Propiedades Atributo.
Para el caso del ejemplo anterior, el atributo es el nombre de la aplicación web, dando el nombre,
la cardinalidad y el tipo del atributo.
A continuación veremos las propiedades de una relación en donde es preciso determinar la
cardinalidad:
Ilustración 9: Propiedades Relación.
Para las propiedades de una relación se encuentra el nombre de la relación, el límite inferior de la
relación, el límite superior de la relación y si la relación es de composición.
Ahora veremos las propiedades de un atributo pero cuyo tipo es un booleano:
Ilustración 10: Propiedades Atributo booleano.
Página 14
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
En este caso se esta definiendo un atributo llamado seguridad dándole como tipo EBoolean,
donde este es la representación del tipo booleano en ecore al igual que EString, EInt, etc.
4. Rol Modelador de Aplicaciones Web
El rol de modelador de aplicaciones web es el encargado de modelar una aplicación web
particular, haciendo uso del meta-modelo definido por el Rol Mantenimiento Meta-modelo.
4.1 Instancia dinámica de la Meta-clase WebApplication
Para modelar una aplicación web, es necesario crear una instancia dinámica de la meta-clase
WebApplication. A continuación se muestra como crear esta instancia dinámica:
Ilustración 11: Creación instancia dinámica.
Una vez se elige esta opción se da un nombre a la instancia dinámica para finalmente se crea un
archivo con el nombre propuesto y con extensión .xmi. En la ilustración 12 se muestra un ejemplo
de una instancia dinámica con nombre WebApplication1.xmi:
Página 15
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 12: Archivo instancia dinámica.
Una vez creada editamos este haciendo uso de un editor jerárquico del modelo de aplicación. En
la ilustración 13 se muestra el editor jerárquico:
Ilustración 13: Editor jerárquico para la instancia.
4.2 Agregar nuevo elementos al modelo jerárquico
Al ser un editor jerárquico, el nodo padre para poder modelar la aplicación web es una instancia
de la meta-clase WebApplication. Para agregar un nuevo elemento a la aplicación se da click
derecho sobre el nodo al que se le quiere agregar un nuevo elemento, para el primer caso se le
agrega un nuevo elemento a la instancia de la meta-clase WebApplication, esta tiene como opción
agregar una nueva instancia de la meta-clase WebPage, Role, Entity o UseCase. En la ilustración
14 se muestra un ejemplo para agregar un nuevo elemento a la instancia de la meta-clase
WebApplication:
Página 16
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 14: Ejemplo agregando un nuevo elemento a WebApplication.
Una vez elegido el nuevo elemento que se desea agregar al modelo de la aplicación este aparecerá
en el modelo jerárquico.
En la ilustración 15 se muestra el ejemplo para agregar un nuevo elemento a una instancia de una
entidad:
Ilustración 15: Ejemplo agregar nuevo elemento a una entidad.
Como se observa debido a que una entidad puede tener por un lado un conjunto de atributos o un
conjunto de relaciones con otras entidades.
Página 17
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
4.3 Ventana de Propiedades
Para modificar los atributos que tendrá cada instancia en particular se utiliza la ventana de las
propiedades donde se observa los atributos que tiene cada meta-clase. Por ejemplo la meta-clase
WebApplication tiene como atributos, NameApplication, Security, Banner, CssStyle, HomePage.
En la ilustración 16 se muestra un ejemplo de la ventana de las propiedades de la meta-clase
WebApplication:
Ilustración 16: Ventana propiedad WebApplication.
Para este caso particular se modela la aplicación teniendo un banner, con estilo css, página de
inicio que es llamada usuario, nombre de la aplicación y la aplicación tiene seguridad.
Ahora se muestra la ventana de propiedades de una entidad:
Ilustración 17: Ventana propiedades Entity.
La meta-clase Entity tiene como atributos NameEntity que para este ejemplo es Customer¸ y la
lista de Roles que tienen permitido utilizar el CRUD de estas Entidades, para este caso son los
roles administrador¸ gerente y empleado.
4.4 Transformación modelo a la aplicación Java EE 6
Una vez modelada la aplicación web, por parte del rol de modelador de la aplicación web a la
aplicación en Java EE 6. Para generar el proyecto se ejecuta el archivo generate.mtl, que se
encuentra en el proyecto javeriana.edu.co.acceleo.webgenerator.m2t, una vez ubicado este
archivo se da click derecho y se elige la opción Run Configuration como se muestra en la
ilustración 18:
Página 18
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 18: Ejecución archivo generate.mtl.
Una vez elegido esta opción aparecerá la venta de configuración de Acceleo. En esta ventana se
elige el modelo que va a ser transformado a una aplicación web en tecnología Java EE 6. En la
ilustración 19 se muestra la ventana de configuración:
Ilustración 19: Ventana de configuración.
Página 19
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
En la parte subrayada con color anaranjado se elige el modelo de la aplicación web que se desea
generar.
4.5 Estructura de la aplicación generada
Una vez transformado el modelo a la aplicación Java EE 6, este es generado dentro de la carpeta
src-gen en el proyecto javeriana.edu.co.acceleo.webgenerator.m2t, la estructura del proyecto
generado se muestra en la ilustración 20:
Ilustración 20: Estructura proyecto generado.
El nombre que toma la aplicación es el nombre que se le dio a la meta-clase WebApplication,
dentro de la src/ejb se encuentran los ejbs de la aplicación, que son tomados de los casos de uso
modelados y de los CRUD de las entidades. Por otro lado dentro de la carpeta jpa/entities se
encuentra las entidades modeladas de la aplicación web. Dentro de la carpeta web se encuentran
las páginas modeladas y en la carpeta Pages se encuentran las carpetas de cada entidad modelada,
que contienen las páginas necesarias para poder llevar a cabo el CRUD de estas. Por ultimo en la
carpeta WEB-INF se encuentra el archivo web.xml y el archivo faces-config.xml.
5. Rol de Mantenimiento de los Transformadores para Java EE 6
En la presente sección, mostraremos la forma en que la persona encargada del mantenimiento de
las plantillas en Acceleo para la transformación del modelo de la aplicación web a la aplicación
en Java EE 6. Teniendo la opción de crear nuevas plantillas, agregar nuevas características a las
Página 20
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
plantillas y por otro lado transformar los nuevos elementos que sean adicionados al actual metamodelo.
El proyecto que transforma el modelo a una aplicación web en Java EE 6, en la herramienta Wapp
Generator es llamado javeriana.edu.co.acceleo.webgenerator.m2t. A continuación se muestran
las principales características de este proyecto.
5.1 Características herramienta de transformación
En esta sección nombraremos los elementos más relevantes para la transformación del modelo a
la aplicación en tecnología Java EE 6:
5.2 Diagrama de invocación (Gestión de plantillas)
En la ilustración 21 se muestra en el diagrama de invocación de plantillas iniciando con la plantilla
generate.mtl, que actúa como main de la herramienta Wapp Generator:
Ilustración 21: Diagrama de invocación de plantillas.
Página 21
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Como se observa en la anterior imagen, el flujo inicia con el modulo generate.mtl, el cual
comienza consultando el atributo security del modelo de la aplicación, si este atributo se encuentra
en verdadero se invocaran las siguientes plantillas que serán necesarias para la creación de una
aplicación web con seguridad en Java EE 6:
Plantilla
Descripción
Generate Menu
Página web que contiene los enlaces a las
distintas páginas teniendo en cuenta las
restricciones de acceso de cada página.
Página web para el ingreso a la aplicación y
Generate Security Files
página de error, entidades Role y User, y por
ultimo managed bean Auth.java.
Generación del archivo web.xml, teniendo en
Generate web file
cuenta
las
restricciones
de
seguridad
modeladas.
Generación de script para la inserción de los
Generate SQL file
roles en la tabla Role.
Generate page with template:
Generación de las páginas web modeladas con
un template.
Generate template
Generación del Facelet que será utilizada por
las páginas web.
Tabla 2: Descripción diagrama de invocación con seguridad.
Si por el contrario, la aplicación web modelada no cuenta con módulo de seguridad, el archivo
web.xml no es generado si no es copiado al proyecto generado. Enseguida el módulo generate.mtl
verifica si el valor del atributo cssStyle del modelo de la aplicación web es verdadero, para generar
las paginas utilizando un template y asimismo generar el facelet que utilizaran estas páginas web.
Si por el contrario el atributo cssStyle es falso se generan páginas que no utilizan un template.
Una vez verificados estos atributos del modelo, el archivo generate.mtl, prosigue a invocar las
siguientes plantillas:
Página 22
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Plantillas
Descripción
Generate entities
Se encarga de generar los archivos .java
asociados a la entidad modelada.
Generate managedBeans
Encargada de generar los managed bean para
soportar los casos de uso.
Generate ejbs
Encargada de generar los ejbs asociados a los
casos de uso, cabe aclarar que la generación
de estos métodos no es completa y por lo tanto
deben
ser
implementados
por
los
desarrolladores.
Generate New Page CRUD
Genera las páginas web para la creación de las
entidades modeladas.
Generate View Page CRUD
Genera las páginas web para ver los detalles
de las entidades modeladas.
Generate Edit Page CRUD
Genera las páginas que permite la edición de
las entidades modeladas.
Generate List Page CRUD
Genera la lista
que permite ver las
colecciones instanciadas de las entidades
modeladas.
Tabla 3: Descripción diagrama de invocación plantillas.
5.2.1
Plantilla generate.mtl
El archivo generate.mtl, es el encargado de llamar a las otras plantillas que serán utilizadas
durante la transformación. Dentro de este archivo se agregaran las invocaciones a las nuevas
plantillas que sean agregadas. Para agregar una nueva plantilla se debe importar la plantilla, por
ejemplo a continuación se muestra la instrucción para importar la plantilla que genera las
entidades modeladas:
Página 23
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 22: Importar la plantilla entitiesGenerate.
Una vez importada la plantilla se invoca el método para la generación del archivo. Siguiendo con
el ejemplo anterior, las entidades se generan en tecnología Java EE 6 invocando el método. En la
siguiente imagen se muestra la invocación del método:
Ilustración 23: Invocación método generación de las entidades.
Este método recibe como parámetro el modelo de una aplicación web en particular para generar
todas las entidades modeladas dentro de esta entidad.
5.3 Elementos generales dentro de una plantilla común:
A continuación veremos la plantilla entitiesGenerate.mtl, utilizada para la generación de
entidades. Describiremos los elementos utilizados para transformar el meta-modelo en la
aplicación Java EE 6.
Página 24
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 24: Archivo entitiesGenerate.
A.
Instrucciones module y template
Dos de las etiquetas con la que es necesario empezar una plantilla en Acceleo serán mostradas
utilizando como ejemplo la plantilla entitiesGenerate.mtl.
Ilustración 25: Fragmento plantilla entitiesGenerate.
Con la etiqueta [module], se definen el nombre de la plantilla, así como el meta-modelo con el
cual trabajara la plantilla por medio de la instrucción 'http://javeriana.edu.co/webApplication'
Por otro lado la etiqueta [template] define el nombre del método de la plantilla
entitiesGenerate.mtl, estableciendo el nombre del método de la plantilla y el parámetro para llevar
a cabo el método, en este caso el parámetro es una instancia de la meta-clase webApplication.
B.
Instrucciones for, if y else
Acceleo posee una implementación del lenguaje OCL para utilizar las diferentes instrucciones de
control para poder transformar el modelo de una aplicación web a código en tecnología Java EE
6, cuenta con las etiquetas [for], utilizada al igual que lo hace un ciclo para iterar sobre una
colección, la etiqueta [if], representa una instrucción típica de if, en donde se eligen entre dos
Página 25
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
caminos posibles y por último la etiqueta [else], utilizada para definir el camino alternativo a una
etiqueta [if].
Comenzaremos con la etiqueta [if] analizándola mediante la plantilla de Acceleo
entitesGenerate.mtl. En la siguiente imagen veremos cómo se utiliza esta etiqueta dentro de la
plantilla:
Ilustración 26: Etiquetas if dentro de plantilla.
En el anterior fragmento anterior se utiliza la etiqueta para evaluar si las restricciones de tamaño
de un atributo de una entidad son mayor a 0. Por otro lado si no se cumple esta condición por
medio de la etiqueta [elseif], se evalúa si se cumple otra condición, en este caso se evalúa si la
restricción mínima de tamaño es mayor a 0. Esta etiqueta es finalizada con la etiqueta [/if].
Ahora entraremos a analizar la etiqueta [for] dentro de una plantilla de Acceleo, para recorrer las
colecciones que posee el modelo. A continuación se muestra una figura ilustrando el uso de la
etiqueta [for]:
Ilustración 27: Etiqueta for dentro de la plantilla.
En la anterior figura la etiqueta [for] es utilizada para recorrer todas las entidades modeladas
dentro de la aplicación web. Esta etiqueta está compuesta por el tipo de iterador y por otro lado
la colección que será recorrida, para este caso el tipo del iterador es Entity y la colección son las
entidades modeladas, accediendo por medio de la instrucción aWebApplication.entities. La
etiqueta [for] es delimitada por la etiqueta [/for].
C.
Instrucción file
La etiqueta [file], es utilizada para la creación de un nuevo archivo. Como se puede observar en
la ilustración 27, la etiqueta [file] toma como primer parámetro la ubicación y el nombre del
Página 26
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
nuevo archivo que va a ser generado, en el ejemplo anterior cada vez que se itera dentro de la
colección se crea un nuevo archivo con el nombre de la entidad modelada, accediendo a este por
medio de la instrucción aEntity.nameEntity y con extensión .java. Finalmente esta etiqueta está
delimitada por la etiqueta [/file], cuyo cuerpo representa el contenido que tendrá las entidades
generadas.
D.
Utilización servicios Java
Debido a que el lenguaje OCL no permite definir estructuras de datos y algoritmos complejos, es
necesario utilizar un lenguaje más completo. Para poder llevar a cabo esto, Acceleo permite
integrar OCL con servicios Java.
Para poder tener la integración con servicios Java en primer lugar se define la clase en Java que
se llevara a cabo los algoritmos complejos. Para la herramienta Wapp Generator se utilizó la clase
Utils.java, ubicada en el paquete javeriana.edu.co.acceleo.util, como se ve en la ilustración 28:
Ilustración 28: Ubicación clase Utils.java.
Dentro de la clase Utils.java se encuentran definidos estructuras de datos como mapas que serán
necesarios para la generación de código. En la ilustración 29 se muestra el fragmento del código
de la clase Utils.java:
Página 27
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 29: Fragmento clase Utils.java.
En la Ilustración 29 se muestra el algoritmo para generar las relaciones bidireccionales de una
entidad particular. Dentro de este método se utilización una HashMap para generar las relaciones
entre entidades, el texto Java define todos los atributos de relación de la entidad incluyendo para
cada atributo de relación la anotación @ManyToOne o @OneToOne según corresponda.
Finalmente este método retorna un String que contiene las relaciones que deben ser generadas.
Una vez definido los métodos necesarios se crea una archivo .mtl. La herramienta Wapp
Generator posee el utilsGenerate.mtl, que es el encargado de la integración entre OCL y los
servicios Java. En la Ilustración 30 se muestra la ubicación de esta clase:
Ilustración 30: Ubicación utilsGenerate.mtl.
En este archivo se definen los métodos que serán invocados desde cualquier plantilla. Dentro de
la definición se encuentra el nombre del método, los parámetros y el tipo de retorno. En la
Ilustración 31 se muestra la firma del método generateRelations:
Página 28
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 31: Firma método generateRelations.
Una vez importado el archivo utilsGenerate.mtl en la plantilla que se desea utilizar los métodos,
y se invocan teniendo en cuenta la firma y los parámetros necesarios para la invocación. En la
Ilustración 32 se muestra la invocación del método generateRelations, que recibe como parámetro
el nombre de la entidad y retorna las relaciones que tiene esa Entidad con las otras entidades,
dentro de la plantilla entitiesGenerate.mtl:
Ilustración 32: Invocación de método generateRelations.
Invocando este método se genera las relaciones para una entidad determinada.
E.
Uso de archivos prexistentes en el transformador
Debido a que algunos archivos no cambian y son estándar para todas las aplicaciones web en Java
EE 6, no era necesario su generación, por lo que se definieron como archivos prexistentes o de
soporte y son incluidos dentro del proyecto de transformación. La ilustración 33 muestra los
archivos prexistentes del ambiente Wapp Generator:
Página 29
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 33: Archivos prexistentes.
A continuación se describe estos archivos prexistentes son:

Auth.java: ManagedBean utilizado cuando la aplicación web tienen seguridad.

cssLayout.css: Pagina de estilo para poder definir el template cuando la aplicación
web tiene el atributo cssStyle en verdadero.

Erro.xhtml: página de error cuando la autenticación no se llevó a cabo correctamente.

Login.xhtml: Pagina de autenticación cuando la aplicación web tiene seguridad.

Role.java: Entidad para persistir los roles que tendrá la aplicación web.

User.java: Entidad para persistir los usuarios que podrán autenticarse en la aplicación
web.

UserFacade: Ejb de la entidad User para poder llevar a cabo los métodos de negocio
de la entidad.

Utils.java: Clase de soporte que contiene para encriptar la contraseña durante la
autenticación.
F.
Estructura de la aplicación Java EE 6 generada
Una vez transformado el modelo a la aplicación Java EE 6, este es generado dentro de la carpeta
src-gen en el proyecto javeriana.edu.co.acceleo.webgenerator.m2t, la estructura del proyecto
generado se muestra en la ilustración 34:
Página 30
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 34: Estructura del proyecto generado.
El nombre que toma la aplicación es el nombre que se le dio a la meta-clase WebApplication,
dentro de la src/ejb se encuentran los ejbs de la aplicación, que son tomados de los casos de uso
modelados y de los CRUD de las entidades. Por otro lado dentro de la carpeta jpa/entities se
encuentra las entidades modeladas de la aplicación web. Dentro de la carpeta web se encuentran
las páginas modeladas y en la carpeta Pages se encuentran las carpetas de cada entidad modelada,
que contienen las páginas necesarias para poder llevar a cabo el CRUD de estas. Por ultimo en la
carpeta WEB-INF se encuentra el archivo web.xml y el archivo faces-config.xml.
5.3.1.6.1
Arquitectura aplicación web generada
En la ilustración 35 se muestra la arquitectura de la aplicación generada por el ambiente Wapp
Generator:
Ilustración 35: Arquitectura aplicación generada.
Página 31
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Por un lado se encuentra el contenedor web, en donde se encuentra las páginas web con tecnología
JSF. En la capa de negocio se encuentra los Enterprise Java Beans, que contienen la lógica de
negocio de la aplicación, que será utilizada por la capa Web, para poder llevar a cabo las
solicitudes del cliente. Por último la capa de negocio se comunica con la capa de datos, donde
estará la base de datos que almacena la información de la aplicación web.
6. Rol desarrollador que completa la aplicación generada
Una vez generada la aplicación web el desarrollador debe completar los siguientes pasos para
poder desplegar la aplicación y ejecutarla:
6.1 Crear proyecto en Netbeans 7.4
El IDE elegido para el despliegue de la aplicación fue Netbeans en la versión 7.4. Para utilizar el
código generado se da la opción de crear nuevo proyecto web con recursos existentes. Una vez
elegida esta opción se coloca la ubicación del archivo generado, la ubicación del nuevo proyecto,
se elige el servidor de aplicación, para efectos de este manual se utilizó GlassFish en la versión
4.0 y la versión Java EE 6. En la ilustración 33 se muestra la opción para crear un archivo con
recursos existentes:
Ilustración 36: Ventana creación proyecto.
Una vez creada la aplicación el IDE se encarga de crear los archivos de configuración para ser
utilizado en Netbeans.
Página 32
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Debido a que la aplicación utiliza etiquetas PrimeFaces en los elementos de la aplicación por lo
que es necesario agregar la librería de PrimeFaces en el proyecto antes de desplegar este, debido
a que aparecerán errores ya que estas etiquetas no son reconocidas hasta que la librería sea
importada.
6.2 Configuración Unidad de Persistencia.
Por otro lado cuando se hace uso de la capa de acceso a datos, se debe ser configurada la unidad
de persistencia, especificando la conexión a la base de datos, dejando como nombre de la unidad
de persistencia el nombre de la aplicación modelada más las letras PU.
En la ilustración 37 se muestra una unidad de persistencia de una aplicación web con nombre
Sprint61:
Ilustración 37: Unidad de persistencia.
6.3 Configuración de seguridad
Para la parte de seguridad se debe configurar el dominio de seguridad del servidor de aplicaciones.
En este caso se muestra la configuración para el servidor Glassfish 4.0, para la configuración de
otro servidor revise el manual del servidor. En primer lugar entramos a la consola de
administración y se elige configuración de servidor como se muestra en la ilustración 38:
Página 33
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 38: Consola de administración GlassFish.
Elegimos la pestaña de seguridad y elegimos la carpeta dominios como se muestra en la
ilustración 39:
Ilustración 39: Dominios de seguridad.
Una vez acá observaremos los dominios de seguridad por defecto de la aplicación y los dominios
de seguridad que se hayan definido anteriormente. Debemos crear un nuevo dominio de seguridad
por lo elegimos la opción nuevo dominio.
Elegida esta opción aparecerá la siguiente ventana donde se configura el nuevo dominio de
seguridad:
Página 34
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 40: Configuración dominio de seguridad.
Como nombre del nuevo dominio se le da el nombre de la aplicación web modelada, enseguida
como nombre de clase se elige JDBCRealm, en contexto JAAS se le da un nombre, en JNDI le
damos el JNDI de la fuente de la base de datos.
Por otro lado en tabla de usuarios se da el nombre USERS, en columna de nombres de usuario
colocamos LOGIN, en columna de contraseñas colocamos PASSWORD, en tabla de grupos
colocamos ROLE_USERS, en columna de nombres de usuario de la tabla de grupos colocamos
USERS_LOGIN, en columna de nombres de grupo se coloca ROLES_NAME, en algoritmo de
cifrado y algoritmo de resumen se coloca MD5 y finalmente en juego de caracteres se coloca
UTF-8 y guardamos el dominio.
Una vez configurado el nuevo dominio de seguridad se crea el archivo de configuración para el
servidor, en este caso particular se crea el archivo de configuración para GlassFish, una vez creado
este se mostraran los roles que se crearon durante la etapa de diseño de la aplicación web. En la
ilustración 38 se muestra el ejemplo de un archivo de configuración para GlassFish:
Página 35
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 41: Archivo glassfish-web.xml.
Como se observa, en la pestaña Security del archivo glassfish-web-xml, se ven los roles que fueron
modelados en la aplicación web.
Por ultimo desplegamos la aplicación en el servidor, para este caso es GlassFish versión 4.0, como
se muestra en la siguiente imagen:
Ilustración 42: Despliegue aplicación web.
Página 36
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Por otro lado el ambiente Wapp Generator crea un script para almacenar la base de datos los roles
que fueron modelados, ingresando en la tabla Role de la base de datos, igualmente para probar la
todos los recursos de la aplicación web se crea un rol llamado admin, que tiene permisos para
trabajar sobre todos los recursos de la aplicación web que se encuentran protegidos, asimismo se
crea un usuario con login y password useradmin al que se le es asignado el rol de admin. Este
archivo se encuentra en la carpeta resources de la aplicación web generada con el nombre insertroles.sql. En la ilustración 43 se muestra la ubicación de este archivo:
Ilustración 43: Ubicación insert-roles.sql.
Dentro del archivo sql se encuentra la sentencias para la inserción en la tabla Role. A continuación
se muestra el contenido del archivo insert-roles.sql:
Ilustración 44: Archivo insert-roles.sql.
Este script es ejecutado sobre la base de datos de la aplicación para poder insertar los roles.
Una vez desplegada la aplicación y ejecutado el script de inserción en la base de datos,
procedemos a ejecutar la aplicación como se muestra en la siguiente ilustración:
Página 37
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Ilustración 45: Ejecución aplicación web.
En la siguiente imagen se ve una página web modelada en ejecución:
Ilustración 46: Página modelada en ejecución.
Página 38
Pontificia Universidad Javeriana
Manual de administración de WAPP Generator
Esta página en particular fue modelada dentro de una aplicación web con estilo y banner y está
compuesta por un formulario con campos y una tabla.
Por otro lado en la imagen se observa una página generada a partir del CRUD de una entidad:
Ilustración 47: Página detalle de una entidad.
Esta entidad llamada Customer tiene un conjunto de atributos que describe a un cliente, asimismo
tiene una relación uno a uno con la entidad Adress y una relación uno a muchos con la entidad
Car, que es vista en la ilustración como una lista.
Página 39