Código para BBDD Oracle - Archivo Digital UPMoa.upm.es/39878/1/PFC_Javier_Blazquez_Chaves.pdf · Generador de Código para BBDD Oracle Resumen Las empresas tienen programas que acceden

Generador de Código para BBDD Oracle

PROYECTO FIN DE CARRERA

INGENIERÍA TÉCNICA DE GESTIÓN

2014/2015

GENERADOR DE CÓDIGO PARA BBDD ORACLE

Autor: Javier Blázquez Chaves

Director: Fernando Arroyo Montoro

1


2


Índice

Índice ................................................................................................................................................... 3

Índice ilustraciones .............................................................................................................................. 7

Índice Tablas ........................................................................................................................................ 9

Resumen ............................................................................................................................................ 13

Abstract .............................................................................................................................................. 14

Introducción ....................................................................................................................................... 15

Objetivo ............................................................................................................................................. 16

Definición de metodología ................................................................................................................ 17

Metodología ágil ............................................................................................................................ 22

Scrum ............................................................................................................................................. 25

Tecnología aplicada al desarrollo ...................................................................................................... 28

Java ................................................................................................................................................ 28

StringTemplate .............................................................................................................................. 29

Group file ................................................................................................................................... 31

Templates .................................................................................................................................. 32

Definición formal de StringTemplate ......................................................................................... 39

Oracle Database Express Edition ................................................................................................... 40

ALL_TABLES ................................................................................................................................ 42

ALL_TAB_COLUMNS .................................................................................................................. 46

ALL_CONSTRAINTS ..................................................................................................................... 48

ALL_CONS_CONSTRAINT ........................................................................................................... 50

3


Herramientas utilizadas ..................................................................................................................... 51

Google Drive .................................................................................................................................. 51

Draw.io ........................................................................................................................................... 52

Web sequence diagrams................................................................................................................ 53

Eclipse ............................................................................................................................................ 54

Desarrollo........................................................................................................................................... 55

Primera iteración ........................................................................................................................... 55

Reunión de planificación (Sprint Planning) ................................................................................ 55

Pruebas unitarias ....................................................................................................................... 59

T4 Pruebas de integración ......................................................................................................... 60

Segunda iteración .......................................................................................................................... 62



T8 Pruebas de integración ......................................................................................................... 68

Tercera iteración ............................................................................................................................ 71



T11 Pruebas de integración ....................................................................................................... 82

Cuarta iteración ............................................................................................................................. 84



T14 Pruebas de integración ....................................................................................................... 95

4


Sprint Backlog Final ........................................................................................................................ 98

Trabajo Futuro ........................................................................................................................... 100

Conclusiones .................................................................................................................................... 102

Referencias ...................................................................................................................................... 103

5


6


Índice ilustraciones

Ilustración 1 ................................................................................................................................. 18

Ilustración 2 ................................................................................................................................. 18

Ilustración 3 ................................................................................................................................. 19

Ilustración 4 ................................................................................................................................. 20

Ilustración 5 ................................................................................................................................. 21

Ilustración 6 ................................................................................................................................. 41

Ilustración 7 ................................................................................................................................. 52

Ilustración 8 ................................................................................................................................. 53

Ilustración 9 ................................................................................................................................. 57

Ilustración 10 ............................................................................................................................... 58

Ilustración 11 ............................................................................................................................... 66

Ilustración 12 ............................................................................................................................... 73

Ilustración 13 ............................................................................................................................... 78

7


8


Índice Tablas

Tabla 1 ......................................................................................................................................... 30

Tabla 2 ......................................................................................................................................... 30

Tabla 3 ......................................................................................................................................... 31

Tabla 4 ......................................................................................................................................... 31

Tabla 5 ......................................................................................................................................... 31

Tabla 6 ......................................................................................................................................... 32

Tabla 7 ......................................................................................................................................... 33

Tabla 8 ......................................................................................................................................... 33

Tabla 9 ......................................................................................................................................... 34

Tabla 10 ....................................................................................................................................... 35

Tabla 11 ....................................................................................................................................... 35

Tabla 12 ....................................................................................................................................... 35

Tabla 13 ....................................................................................................................................... 35

Tabla 14 ....................................................................................................................................... 36

Tabla 15 ....................................................................................................................................... 36

Tabla 16 ....................................................................................................................................... 38

Tabla 17 ....................................................................................................................................... 39

Tabla 18 ....................................................................................................................................... 45

Tabla 19 ....................................................................................................................................... 47

Tabla 20 ....................................................................................................................................... 49

9


Tabla 21 ....................................................................................................................................... 50

Tabla 22 ....................................................................................................................................... 55

Tabla 23 ....................................................................................................................................... 56

Tabla 24 ....................................................................................................................................... 61

Tabla 25 ....................................................................................................................................... 62

Tabla 26 ....................................................................................................................................... 63

Tabla 27 ....................................................................................................................................... 64

Tabla 28 ....................................................................................................................................... 65

Tabla 29 ....................................................................................................................................... 70

Tabla 30 ....................................................................................................................................... 71

Tabla 31 ....................................................................................................................................... 71

Tabla 32 ....................................................................................................................................... 72

Tabla 33 ....................................................................................................................................... 75

Tabla 34 ....................................................................................................................................... 77

Tabla 35 ....................................................................................................................................... 77

Tabla 36 ....................................................................................................................................... 83

Tabla 37 ....................................................................................................................................... 84

Tabla 38 ....................................................................................................................................... 84

Tabla 39 ....................................................................................................................................... 87

Tabla 40 ....................................................................................................................................... 90

Tabla 41 ....................................................................................................................................... 97

Tabla 42 ....................................................................................................................................... 99

10


11


12


Resumen

Las empresas tienen programas que acceden a sus bases de datos, estos programas pueden

quedarse obsoletos o dejar de serles útiles por alguna razón y deben ser actualizados o

reemplazados. Sin embargo la base de datos se suele mantener, ya que la estructura de la

información no cambia. Llegado el momento de actualizar o migrar ese software que accede a

la base de datos, se puede recurrir a una estructura de clases, las cuales están basadas en la

metainformación de la base de datos, y así facilitar el desarrollo del nuevo software.

La herramienta desarrollada en este proyecto accede a la metainformación de la base de

datos, obtiene la estructura de las tablas y a través de plantillas genera las clases necesarias

para empezar el nuevo software. Al estar la herramienta basada en plantillas, adaptar éstas a

un nuevo lenguaje es sencillo, haciendo la herramienta mucho más polivalente.

En conclusión, una herramienta de este tipo puede facilitar el desarrollo de un nuevo software

siempre que la estructura de la base de datos se mantenga intacta haciendo que el nuevo

proyecto se desarrolle de forma más rápida.

13


Abstract

Companies have software that access their databases, this software can become obsolete or

fail to be useful for some reason and must be upgraded or replaced. However the database is

usually maintained as the information does not change. It is for this reason that when you

migrate the software that accesses the database can use a class structure based on

information in the database to facilitate the development of new software.

The tool developed in this project accesses the metadata of the database to obtain the

structure of the tables and through templates generate the necessary classes to start the new

software. Being template‐based tool, adapt these to a new language is simple, making a more

versatile tool.

In conclusion, a tool of this kind can facilitate the development of a new software provided

that the structure of the database is intact making the new project develops more quickly.

14


Introducción

En los últimos años el avance en las tecnologías de presentación de información al usuario,

front end, ha avanzado de forma muy significativa, sobre todo en las tecnologías web, pasando

de unas páginas web estáticas en las que el usuario apenas podía interactuar con ellas a webs

dinámicas, que se asemejan más a una aplicación de escritorio. Pero en el campo de

almacenamiento de datos esos avances han sido menores. Han existido avances como las

bases de datos orientadas a objetos o las bases de datos orientadas a documentos (mongodb)

pero el sistema más extendido de almacenamiento de datos, las bases de datos relacionales,

ha avanzado muy poco, los cimientos en los que se basa no han cambiado en los últimos 40

años.

Por estas razones muchas empresas se encuentran en la situación de que su modelo de datos

actual le es totalmente válido pero es necesario actualizar las aplicaciones que acceden a él,

bien porque son aplicaciones que están hechas para un sistema operativo concreto y éste debe

ser cambiado, bien porque la empresa quiere que esa aplicación sea accesible desde cualquier

entorno por lo que decide hacer una aplicación web, etc.

En general, las razones por las que se puede decidir el cambio pueden ser muy diversas pero

por norma general el modelo de datos se mantiene igual y únicamente cambia el front end.

Ante esta situación, la solución habitual es empezar de cero, diseñando toda la aplicación

desde el principio pero manteniendo tan sólo el modelo de datos.

15


Objetivo

El objetivo de este proyecto es crear una herramienta que facilite el desarrollo de un nuevo

software que permita facilitar la migración de las aplicaciones de negocio de una empresa

manteniendo la metainformación de sus bases de datos. Para facilitar el desarrollo de ese

nuevo software, la herramienta creará un esqueleto básico de clases, que es el punto de

partida sobre el que comenzar a desarrollar, facilitando así el trabajo al programador.

Para poder crear esa estructura se deberá obtener información de la única parte que aún

permanece del antiguo sistema y es la base de datos. Se accederá a los metadatos de esa base

de datos para poder determinar las tablas, columnas, tipos de datos, constraint… y así crear las

diferentes partes de la estructura que permitirá realizar una migración fácil.

Estas partes serán:

� Bean por cada tabla en él estarán todas las columnas de esa tabla con sus respectivos

tipos de datos.

� Un XSD (XML Schema Definition) en el cual se definirá la estructura de esa tabla con

sus columnas, sus tipo de datos y sus PK.

16


Metodologías

La metodología de desarrollo de software se define como un conjunto de procedimientos,

herramientas y técnicas que se usan para el desarrollo de software. Estas técnicas están

pensadas para que el desarrollo del proyecto esté más estructurado, planeado y controlado y

como consecuencia de esto la calidad del mismo es mayor.

Las metodologías tienen diferentes enfoques para tratar de resolver los problemas a los que se

enfrentan los miembros de un equipo de desarrollo por lo que algunas son adecuadas para un

tipo de proyectos y otras son más adecuadas para otro tipo de proyectos. No hay una norma

que indique cuál es la más adecuada para cada tipo de proyecto ya que hay muchos factores

que pueden influir, experiencia del equipo en esa metodología, tipo de proyecto, tipo de

cliente, etc. por lo que hay que analizar cada caso en particular para poder tomar una decisión.

Los diferentes tipos de enfoque de las metodologías son [1]:

� Modelo en cascada:

El modelo en cascada, es la metodología de desarrollo más clásica. Su forma de

trabajar es secuencial sin que haya ninguna iteración, la primera fase es la toma de

requisitos, para seguir con el diseño, implementación, verificación y por último el

mantenimiento. Con el paso del tiempo se ha demostrado que este tipo de

metodología no es el más adecuado para muchos proyectos ya que los requisitos

pueden cambiar y no está pensada para desde una fase volver a otra anterior, otra de

sus desventajas es que el cliente no ve el producto final hasta que el proyecto está

completamente acabado.

17


Ilustración 1

� Modelo de Procesos Incrementales

El modelo incremental es una variación del modelo en cascada, aplica este modelo

repetidamente y solapa sus ejecuciones, produciendo en cada repetición una entrega

de software. En cada iteración el equipo adquiere más experiencia provocando que en

cada entrega el software tenga mejor calidad. La primera entrega es lo denominado el

núcleo y en el que se basará el resto del software. Este modelo tiene las ventajas del

modelo en cascada y evita uno de sus inconvenientes, el cliente va viendo en cada

iteración como evoluciona el producto.

Ilustración 2

18


� Espiral

El modelo en espiral consta de varias fases que se ejecutan de forma cíclica hasta

obtener un producto terminado. En cada iteración se deben tener en cuenta los

objetivos a conseguir en esa iteración, las diferentes alternativas para conseguir los

objetivos marcados para esa iteración analizando sus posibles riesgos, una

planificación detallada y por último el desarrollo y pruebas del software a entregar.

Éste fue definido por Boehm en 1986 tras escribir su artículo "A Spiral Model of

Software Development and Enhancement" [19].

Ilustración 3

19


� Construcción de Prototipos

El modelo de prototipos consiste en un modelo en el equipo de desarrollo debe

construir pequeños prototipos en poco tiempo para mostrárselos al cliente, éste a su

vez dará su opinión sobre el software entregado y las nuevas características que quiere

para la siguiente entrega. De esta forma, el cliente ve las evoluciones del producto

evitando así que el producto entregado al final del desarrollo no sea lo que el cliente

quiere. Con este modelo también se consigue que los requisitos sean más exactos ya

que si algún requisito no ha sido entendido correctamente el cliente se dará cuenta de

forma rápida y corregirá el error.

Cada entrega de cada prototipo consta de cinco fases:

• Plan rápido

• Modelado de diseño rápido

• Construcción del prototipo

• Desarrollo, entrega y retroalimentación

• Comunicación

Ilustración 4

20


� Metodología ágil

Las metodologías ágiles son un conjunto de buenas prácticas para la gestión de

proyectos que destacan por su rapidez y flexibilidad en la producción [2].

Ilustración 5 [3]

21


Metodología ágil

Como se ha dicho antes, la metodología ágil es un conjunto de buenas prácticas para el

desarrollo de un proyecto software con el que se consigue mejorar la productividad del

equipo, mejorar la calidad del producto final, en caso de que los requisitos del proyecto

cambien la respuesta a estos cambios es rápida y sobre todo se consigue que el cliente esté

satisfecho con el producto [4].

Para conseguir los objetivos descritos se crean pequeños grupos de trabajo que se

autogestionan ellos mismos y así son más ágiles a la hora de tomar decisiones o reaccionar a

cambios drásticos en el producto. También se hacen pequeñas entregas de software de forma

iterativa, cada una de estas iteraciones es de un periodo de tiempo corto, no más de cuatro

semanas, y cada iteración tiene las fases típicas del desarrollo de software. Al ser entregado el

software al cliente de forma constante, se consigue que éste retroalimente al equipo de

desarrollo y observe fallos de concepto en las fases tempranas del proyecto.

Esta metodología es muy válida para proyectos en los que los requisitos son muy volátiles y se

deben hacer cambios en el software de manera constante. La comunicación con el cliente es

fundamental en este tipo de metodologías pero dando mucha más prioridad a la comunicación

cara a cara que a la documentación.

El origen de esta metodología se remonta al año 2001 cuando un grupo de expertos de la

industria del software se reúnen en Utah. Su objetivo fue esbozar los valores y principios que

deberían permitir a los equipos desarrollar software rápidamente y respondiendo a los

cambios que puedan surgir a lo largo del proyecto.

22


Tras esta reunión se creó The Agile Alliance, una organización sin ánimo de lucro, dedicada a

fomentar la utilización de la metodología de desarrollo ágil y a ayudar a las empresas y

organizaciones a que adopten dicha metodología. También se creó tras aquella reunión lo que

se conoce como el manifiesto ágil, cuyos fundamentos son:

� Valorar más a los individuos y su interacción que a los procesos y las herramientas.

Uno de los pilares en los que se apoya una metodología ágil es que las personas son el

factor principal para que un proyecto salga adelante. Hay que anteponer las personas

a las herramientas, primero se debe elegir el equipo y que sea éste el que decide qué

herramientas va a utilizar para realizar el proyecto, y no elegir primero las

herramientas y que sean las personas las que se adaptan a las herramientas.

� Valorar más el software que funciona que la documentación exhaustiva. No se deben

generar documentos a no ser que sean realmente necesarios y éstos deben ser cortos

y concisos, sin añadir información que no es realmente relevante.

� Valorar más la colaboración con el cliente que la negociación contractual. El desarrollo

del proyecto se va a realizar con la colaboración constante del cliente por lo que es

fundamental que la interacción entre las dos partes sea fluida ya que esto marcará

buena marcha del proyecto y asegure su éxito.

� Valorar más la respuesta al cambio que el seguimiento de un plan. El equipo debe

estar preparado para cualquier cambio en el proyecto, ya sea un cambio de requisito o

bien un cambio de tecnología, por lo que la planificación debe ser flexible.

23


Manifiesto [5]

1. Nuestra mayor prioridad es satisfacer al cliente mediante la entrega temprana y

continua de software con valor.

2. Aceptamos que los requisitos cambien, incluso en etapas tardías del desarrollo. Los

procesos Ágiles aprovechan el cambio para proporcionar ventaja competitiva al

cliente.

3. Entregamos software funcional frecuentemente, entre dos semanas y dos meses, con

preferencia al periodo de tiempo más corto posible.

4. Los responsables de negocio y los desarrolladores trabajamos juntos de forma

cotidiana durante todo el proyecto.

5. Los proyectos se desarrollan en torno a individuos motivados. Hay que darles el

entorno y el apoyo que necesitan, y confiarles la ejecución del trabajo.

6. El método más eficiente y efectivo de comunicar información al equipo de desarrollo

y entre sus miembros es la conversación cara a cara.

7. El software funcionando es la medida principal de progreso.

8. Los procesos Ágiles promueven el desarrollo sostenible. Los promotores,

desarrolladores y usuarios debemos ser capaces de mantener un ritmo constante de

forma indefinida.

9. La atención continua a la excelencia técnica y al buen diseño mejora la Agilidad.

10. La simplicidad, o el arte de maximizar la cantidad de trabajo no realizado, es esencial.

11. Las mejores arquitecturas, requisitos y diseños emergen de equipos auto‐

organizados.

12. A intervalos regulares el equipo reflexiona sobre cómo ser más efectivo para, a

continuación, ajustar y perfeccionar su comportamiento en consecuencia.

24


Scrum

El origen de Scrum se remonta a 1986 cuando en el ámbito industrial necesitan sacar al

mercado nuevos productos, cuyos requisitos son muy generales a la vez que innovadores y

deben estar en el mercado en un periodo de tiempo muy corto [6].

¿Qué es Scrum?

Scrum es una metodología de desarrollo software en el que se aplican un conjunto de buenas

prácticas para desarrollar un proyecto de forma colaborativa y conseguir de esta forma el

mejor resultado posible. Estas prácticas se apoyan unas a otras y su selección tiene origen en

un estudio de la manera de trabajar de equipos altamente productivos.

Al igual que en otras metodologías, Scrum hace entregas de software de forma periódica. Las

entregas se priorizan en función de los beneficios que le aportan al cliente, siendo los más

prioritarios los primeros en ser entregados.

Scrum está especialmente indicado para proyectos cuyos requisitos son muy volátiles ya que la

capacidad de reacción es muy alta y se pueden atajar los problemas rápidamente.

25


Fundamentos

� El desarrollo incremental

� Priorización de los requisitos por valor y coste

� El control empírico del proyecto.

● La potenciación del equipo

� Colaboración y comunicación entre el equipo y con el cliente

● El timeboxing

El desarrollo incremental

Scrum está basado en pequeñas entregas de software que se realizan de forma periódica e

iterativa. La ejecución de esta iteración, también llamado sprint, debe realizarse en un corto

periodo de tiempo, entre dos semanas y dos meses, y debe entregar un software al cliente

que sea funcional. Cada iteración debe contener todas las partes de un proyecto, análisis,

diseño, documentación y pruebas pero sólo lo necesario. Con cada sprint el producto va siendo

más complejo consiguiendo que el desarrollo se ejecute de forma incremental.

Priorización de los requisitos por valor y coste

Al inicio del proyecto se crea una lista de tareas (Product Backlog) y se ordenan estableciendo

una prioridad a cada una de ellas, teniendo en cuenta el valor que aportan al proyecto y su

coste en desarrollo. Estas prioridades pueden ir variando según avanza el proyecto, en cada

inicio de sprint se analizan las tareas que quedan por realizar y se restablece su prioridad. En

las reuniones de cada inicio de sprint pueden aparecer nuevas tareas que son añadidas al

Product Backlog.

26


El control empírico del proyecto.

A diferencia de los proyectos tradicionales que se basan en predicciones para controlar las

variables de los proyectos, Scrum basa su control del proyecto en la experiencia, adaptando las

variables del proyecto (tiempos de entrega, valoraciones, coste de cada requisito) en las

experiencias de los sprints anteriores.

La potenciación del equipo

Otro de los fundamentos de Scrum es el equipo. A diferencia de los proyectos tradicionales

donde el jefe de proyecto es el que toma las decisiones importantes, en Scrum las decisiones

las toman todo el equipo. Con esto se consigue que el equipo este más comprometido con el

proyecto y, a la vez, más motivado.

Colaboración y comunicación entre el equipo, y con el cliente

En Scrum, la colaboración con el cliente es fundamental, debe estar presente durante la

creación de la lista de objetivos del producto, en la reunión de planificación de cada iteración

para que el equipo pueda preguntar cualquier duda al cliente y al final de cada iteración para

poder hacerle una demostración de lo realizado en esa iteración.

El timeboxing

Las tareas que se realizan (pueden ser de cualquier tipo, toma de decisiones, una reunión, etc.)

deben tener un tiempo máximo para que sean realizadas. De esta forma se priorizan los

objetivos, se consigue ser más productivo y las personas trabajan más enfocadas en su tarea.

27


Tecnología aplicada al desarrollo

Java

En la actualidad existen gran cantidad de lenguajes de programación, todos con sus ventajas e

inconvenientes. Para este proyecto se decidió utilizar Java por varias razones [7]:

� Alto conocimiento del lenguaje. Como indica la metodología de desarrollo Scrum, el

individuo prevalece sobre las herramientas y en este caso el equipo tenía un gran

conocimiento sobre el lenguaje de desarrollo java por lo que la evolución del proyecto

sería más rápida y ágil, evitando así el cuello de botella que provocaría la curva de

aprendizaje de un nuevo lenguaje de programación.

� Independencia de SO y arquitectura hardware. Al ser un lenguaje interpretado es

independiente, tanto al sistema operativo como a la arquitectura hardware, tan sólo

es necesario que exista una máquina virtual que, bien puede ser la proporcionada por

Oracle, por otra empresa que haya desarrollado su propia máquina virtual

manteniendo los estándares o utilizando la máquina virtual de código abierto

OpenJDK.

� Lenguaje orientado a objetos. Una de las ventajas de la orientación a objetos es que el

código fuente es más fácil de reutilizar, evitando que se tenga que programar la misma

tarea varias veces. Otras de las ventajas son abstracción, encapsulamiento, herencia,

etc.

� Numerosos drivers de conexión a BBDD. Al estar tan extendido este lenguaje, existe

una gran variedad de drivers de conexión a BBDD por lo que, en caso de querer

ampliar el alcance del proyecto y dar cabida a otros de tipos de BBDD, será mucho más

sencillo.

� Garbage collector. Otra de las ventajas consiste en la liberación de memoria. Java tiene

la característica que no es necesario gestionar la memoria, el lenguaje tiene un

mecanismo que se encarga de liberar la memoria que ya no se está utilizando por lo

que para el programador es transparente. Esta característica está presente en la

mayoría de lenguajes de programación modernos.

� IDE. Java dispone de varios entornos de desarrollo integrado, llamado también IDE

(sigla en inglés de Integrated Development Environment). Varios de ellos muy

avanzados que facilitan la labor del desarrollador en gran medida evitando tener que

realizar tareas tediosas.

28


StringTemplate

Los motores de plantillas son programas de software que generan un resultado a partir de

unos datos estáticos y unos datos dinámicos. Los datos estáticos son una estructura que viene

proporcionada por la plantilla, esta estructura carece de sentido y debe ser completada con

datos dinámicos. Los resultados obtenidos pueden ser de todo tipo, páginas web, código

fuente, correos electrónicos, etc [8].

StringTemplate es un motor de plantillas que rompe las plantillas en trozos de texto y en

expresiones, las cuales vienen delimitadas, por defecto, entre los símbolos de mayor y menor.

El motor ignora todo lo que se encuentre fuera de las expresiones y lo escupe sin evaluarlo

tratando sólo las expresiones.

El creador de StringTemplate es Terence Parr, profesor de la universidad de San Francisco y

cofundador de http://www.jguru.com/ [20]. Ante la necesidad de crear una web dinámica,

decidieron crear un motor de plantillas. Este motor de plantillas se desarrolló originalmente en

java pero posteriormente se hizo un fork para c# y python por lo que está presente en varios

de los lenguajes más extendidos de la actualidad.

La última versión del motor sufrió grandes cambios respecto a la anterior, provocando que

fuera aproximadamente dos veces más rápida y el uso de memoria mucho menor. El problema

es que no es compatible con las aplicaciones que hayan usado la versión anterior por lo que es

necesaria una migración.

Una de las principales razones para usar este motor de plantillas es que cambiar los formatos a

los que se quiere exportar los datos de la bbdd es bastante sencillo, tan sólo se debe cambiar

la plantilla sin necesidad de tocar nada de código. Imagínense que una vez terminado el

proyecto, el cliente decide que el código fuente que desea no es java, que han decidido

cambiar de tecnología en la que van a desarrollar el nuevo front‐end y que lo quieren

desarrollar en c#. Para cambiar la sintaxis de las clases resultante y adaptarlas al nuevo

lenguaje sólo se deberían modificar las plantillas y volver a ejecutar el generador de código

dando como resultado una nueva estructura de clases pero en un lenguaje distinto.

29

http://www.jguru.com/


Plantilla para una clase Java:

class(package,entity, sup)::= << package <package>; public class <entity> extends { } >>

Tabla 1

Plantilla para una clase c#:

class(package,entity, sup)::= << namespace <package> {

public class <entity> : { }

} >>

Tabla 2

En este grupo de templates se puede ver que contiene tan sólo un template (class) el cual

tiene tres parámetros de entrada, uno el paquete o namespace en el que se va a ubicar la clase

generada (package), otro, el nombre de la clase (entity) y por último la clase padre (sup). Estos

parámetros sustituyen a las expresiones de igual nombre que vienen delimitadas por los

símbolos de mayor y menor. En este caso, las expresiones simplemente son sustituidas por los

parámetros pero estas expresiones pueden ser otros templates, funciones u otros posibles

valores que serán explicados más adelante.

Como se puede ver, la migración de un lenguaje a otro ha sido bastante sencillo, aunque

evidentemente, éste es un ejemplo bastante básico y los templates pueden ser bastante más

complejos, dificultando mucho más su modificación.

30


Group file

StringTemplate organiza toda su estructura a través de los llamados group file que son un

conjunto de template y de diccionarios que están agrupados en un solo fichero con la

extensión stg. El formato de estos ficheros es el siguiente.

delimitadores imports diccionarios templates

Tabla 3

Delimitadores

Los delimitadores indican el símbolo de inicio y de fin de una expresión, pudiendo ser estos

diferentes. Se definen mediante la palabra reservada delimiters y vienen precedidos por dichos

símbolos entre comillas.

delimiters "<" ">"

Tabla 4

Imports

En esta parte se puede indicar al group file que importe bien otros group files, otros templates

u otros directorios con templates. Al importar estos ficheros se podrá acceder desde este

group file a lo definido en ellos.

import "/template.st" // importa un template

import "/groupfile.stg" // importa un group file import "/test/dir" // importa el directorio dir

Tabla 5

31


Diccionarios

Este apartado contiene la definición de diccionarios de datos. Estos diccionarios de datos son

muy útiles para la traducción de palabras. Por ejemplo, se está generando el código java y se

quiere crear una variable de tipo entero, a la plantilla se le indicará que la variable es de tipo

entero y a través del diccionario de datos, ésta sabrá que las variables de tipo entero deben ser

definidas con la palabra int. La definición de un diccionario de datos se realiza mediante el

nombre del diccionario y posteriormente viene un conjunto de pares de valores en los que el

primero es la clave y el segundo el valor. Por último, tiene que definirse un valor por defecto

que será el usado en caso de no encontrar la clave. Este último par se define mediante la clave

default y el valor que será usado por defecto.

tipoDatos ::= [

"entero":"int", "decimal":"double", "cadena":"String" "default":"String", ]

Tabla 6

Para poder utilizar el diccionario simplemente se deberá escribir su nombre y posteriormente

poner la clave del valor que se quiere obtener, esta clave puede escribirse literalmente o

utilizarse un atributo que contenga la clave del valor a obtener.

Templates

En esta zona del group file se definen los templates que serán explicados más adelante con

mayor profundidad.

Templates

Un template es una secuencia de textos y expresiones que definen la estructura del resultado

que se quiere obtener. Las expresiones son las que son sustituidas por otros valores dando

lugar a diferentes resultados. Estas expresiones pueden ser:

� Atributo.

� Inclusión de otro template.

� Una operación condicional.

� Ejecución de otro template.

32


Expresiones literales

Syntax Discussion

true Tipo de dato lógico de valor verdadero

false Tipo de dato lógico de valor verdadero

char char → space | \n | \r | \t | \uXXXX

\\ Ignora toda la línea hasta que haya un salto de línea

"string" Una cadena de caracteres de salida

{template} Un subtemplate anónimo

{args | template} Un subtemplate anónimo con argumentos

[ ] Una lista vacía

[expr1, expr2, ..., exprN] Una lista con N valores. Se comporta como una matriz o lista

inyectado desde código del controlador.

Tabla 7

Expresiones de atributos

Syntax Discussion

a Busca a y la convierte en una cadena mediante la función de conversión del

lenguaje de implementación tal como toString (), ToString (), o _str (). Si no se

define localmente como un argumento, StringTemplate mira en la plantilla que

invoca la plantilla actual, y así sucesivamente. Evalúa a la cadena vacía si a no

existe.

(expr) Evalúa expr para convertirlo en una cadena. Esto es útil para calcular el nombre

de la plantilla o la propiedad.

exp.p Obtiene la propiedad p de exp. exp típicamente debe ser un atributo. Por

ejemplo, en la expresión <user.name>, exp es usuario y p es nombre. Más

adelante se explicarán las propiedades

expr1.(

expr2)

Evalúa expr2 para convertirlo en una cadena y usa el resultado como una

propiedad de expr1

Tabla 8

33


Funciones

String template tiene integradas una serie de funciones. Estas funciones tienen tan sólo un

argumento y devuelven un sólo valor. Son las siguientes:

Syntax Description

<first(attr)> Devuelve el primer o único elemento de attr.

<length(attr)> Devuelve la longitud del atributo en caso de ser un atributo de varios

valores (listas) o uno si sólo es un solo valor. Si es nulo, devuelve 0.

<strlen(attr)> Devuelve la longitud de la cadena.

<last(attr)> Devuelve el último elemento de attr.

<rest(attr)> Devuelve todos los elementos menos el primer elemento de attr.

<reverse(attr)> Devuelve una lista con los mismos elementos que attr pero en orden

inverso.

<trunc(attr)> Devuelve todos los elementos menos el último

<strip(attr)> Devuelve una nueva lista sin valores nulos.

<trim(attr)> Elimina los espacios en blanco del inicio y final de la cadena.

Tabla 9

Palabras reservadas

StringTemplate hay varias palabras que están reservadas y no pueden ser usadas en los

nombres de los atributos o de los templates, son las siguientes:

true, false, import, default, key, group, implements, first, last, rest, trunc, strip, trim, length,

strlen, reverse, if, else, elseif, endif, delimiters

34


Propiedades

StringTemplate proporciona un mecanismo para que los propios templates tengan acceso a las

propiedades de un objeto que sea pasado al propio template como atributo. Las plantillas

tendrán acceso a los atributos que sean públicos o que tenga un método get en caso de que el

atributo no sea boolean, si es boolean el método deberá ser is o has.

Observemos el siguiente ejemplo de una clase java

public static class User {

public int id; private String name; public String getName() { return name; } public User(int id, String name) { this.id = id; this.name = name;

} public boolean isManager() { return true; } public boolean hasParkingSpot() { return true; } public String toString() { return id+":"+name; } }

Tabla 10

Empezaremos por el atributo id:

public int id;

Tabla 11

Como se puede ver, es público, por lo que la plantilla podrá acceder a él sin ninguna

restricción. Ahora observaremos el atributo name:

private String name; public String getName() { return name; }

Tabla 12

El atributo es privado, por lo que en principio la plantilla no podrá tener acceso a él, pero al

disponer de un método get, si la plantilla intenta acceder al atributo name StringTemplate,

hará una llamada al método get y devolverá su valor.

public boolean isManager() { return true; }

public boolean hasParkingSpot() { return true; }

Tabla 13

35


Estos dos métodos no devuelven ningún atributo de la clase, pero sí siguen la nomenclatura

establecida por StringTemplate para devolver un boolean por lo que, si en la plantilla se

intenta acceder a ellos como si fueran un atributo:

u.manager u.parkingSpot

Tabla 14

éstos devolverán el valor y será tratado como si fuera un atributo. Por último, vemos el

método toString. Este método será llamado cuando se acceda directamente al objeto, en

nuestro ejemplo, cada vez que en la plantilla pongamos u, se ejecutará el método toString en

la plantilla y devolverá el id más el nombre.

public String toString() { return id+":"+name; }

Tabla 15

Definición formal de template

template : element* ; element : INDENT? COMMENT NEWLINE | INDENT singleElement | singleElement | compoundElement ; singleElement : exprTag | TEXT | NEWLINE | COMMENT ; compoundElement : ifstat | region ; exprTag : LDELIM expr ( ';' exprOptions )? RDELIM ; region : INDENT? LDELIM '@' ID RDELIM template INDENT? LDELIM '@end' RDELIM NEWLINE? ; subtemplate : '{' ( ID ( ',' ID )* '|' )? template INDENT? '}' ; ifstat : INDENT? LDELIM 'if' '(' conditional ')' RDELIM template ( INDENT? LDELIM 'elseif' '(' conditional ')' RDELIM template )* ( INDENT? LDELIM 'else' RDELIM template )?

36


INDENT? LDELIM 'endif' RDELIM NEWLINE? ; conditional : andConditional ( '||' andConditional )* ; andConditional : notConditional ( '&&' notConditional )* ; notConditional : '!' notConditional | memberExpr ; notConditionalExpr : ID ( '.' ID | '.' '(' mapExpr ')' )* ; exprOptions : option ( ',' option )* ; option : ID ( '=' exprNoComma )? ; exprNoComma : memberExpr ( ':' mapTemplateRef )? ; expr : mapExpr ; mapExpr : memberExpr ( ( ',' memberExpr )+ ':' mapTemplateRef )? ( ':' mapTemplateRef ( ',' mapTemplateRef )* )* ; mapTemplateRef : ID '(' args ')' | subtemplate | '(' mapExpr ')' '(' argExprList? ')' ; memberExpr : includeExpr ( '.' ID | '.' '(' mapExpr ')' )* ; includeExpr : ID '(' expr? ')' | 'super' '.' ID '(' args ')' | ID '(' args ')' | '@' 'super' '.' ID '(' ')' | '@' ID '(' ')' | primary ; primary : ID | STRING | 'true' | 'false' | subtemplate | list | '(' conditional ')' | '(' expr ')' ( '(' ( argExprList )? ')' )? ; args: argExprList | namedArg ( ',' namedArg )* |

37


; argExprList : arg ( ',' arg )* ; arg : exprNoComma ; namedArg : ID '=' arg ; list: '[' ']' | '[' listElement ( ',' listElement )* ']' ; listElement : exprNoComma | ;

Tabla 16

38


Definición formal de StringTemplate

group : delimiters? ('import' STRING)* ( template | dict )+ ; delimiters : 'delimiters' STRING ',' STRING ; template : ( '@' ID '.' ID '(' ')' | ID '(' formalArgs ')' ) '::'= ( STRING // "..." | BIGSTRING // <<...>> | BIGSTRING_NO_NL // <%...%> ) | ID "::=" ID // alias one template to another ; formalArgs : formalArg ( ',' formalArg )* ( ',' formalArgWithDefaultValue )* | formalArgWithDefaultValue ( ',' formalArgWithDefaultValue )* | ; formalArg : ID ; formalArgWithDefaultValue : ID ( '=' STRING | '=' ANONYMOUS_TEMPLATE | '=' 'true' | '=' 'false' ) ; arg : ID '=' STRING // x="..." | ID '=' ANONYMOUS_TEMPLATE // x={...} | ID ; dict: ID '::=' '[' pairs ']' ; pairs : keyValuePair ( ',' keyValuePair )* ( ',' defaultValuePair )? | defaultValuePair ; keyValuePair : STRING ':' keyValue ; keyValue : BIGSTRING | ANONYMOUS_TEMPLATE | STRING | TRUE | FALSE | 'key' ; defaultValuePair : 'default' ':' keyValue ;

Tabla 17

39


Oracle Database Express Edition

Oracle Database Express Edition es un gestor de base de datos desarrollado por Oracle. Esta

versión, es la versión gratuita dirigida a desarrolladores, estudiantes y pequeñas empresas por

lo que está capada para ordenadores con un sólo procesador y hasta 1 Gb de RAM. A pesar de

las restricciones, el motor es el mismo que las versiones superiores por lo que es

recomendable para desarrollo y uso educativo como es nuestro caso [9].

Oracle fue fundada en 1977 con el nombre Software Development Laboratories, poco después

obtiene un contrato con la CIA para el desarrollo de una base de datos, ese proyecto recibió el

nombre de “Oracle”. Así es como surge el gestor de base de datos.

Oracle ha ido creando un gran número de versiones de su gestor de base de datos añadiendo

características y mejorando su funcionamiento hasta llegar a la última versión que existe en la

actualidad, Oracle 12c.

Como la mayoría de los gestores de base de datos actuales, guarda la información relativa a las

bases de datos que gestiona en la propia base de datos, esas tablas donde está guardada la

información son únicamente accesibles para el administrador o los usuarios a los que haya

dado permisos.

40


El diagrama de las tablas y sus relaciones sería el siguiente (se han omitido varias columnas en

el diagrama dejando sólo los más importantes) [10]:

Ilustración 6

41


ALL_TABLES

Esta tabla contiene todas las tablas de las bases de datos. Sus columnas son:

Columna Tipo dato NULL Descripción

OWNER VARCHAR2(30) NOT

NULL

Propietario de la tabla

TABLE_NAME VARCHAR2(30) NOT

NULL

Nombre de la tabla

TABLESPACE_NAME VARCHAR2(30) Nombre del tablespace que contiene la

tabla

CLUSTER_NAME VARCHAR2(30) Nombre del cluster al que pertenece la

tabla

IOT_NAME VARCHAR2(30) Nombre del index‐organized tables

STATUS VARCHAR2(8) Indica el estado de la tabla, si se ejecutó un

DROP TABLE anteriormente el estado de la

tabla será UNUSABLE, en caso contrario

VALID

PCT_FREE NUMBER Porcentaje de espacio libre

PCT_USED NUMBER Porcentaje de espacio usado

INI_TRANS NUMBER Número inicial de transacciones

MAX_TRANS NUMBER Número máximo de transacciones

INITIAL_EXTENT NUMBER Tamaño inicial de la extensión.

NEXT_EXTENT NUMBER Tamaño de la siguiente extensión

MIN_EXTENTS NUMBER Número mínimo de extensiones

MAX_EXTENTS NUMBER Máximo número de extensiones

PCT_INCREASE NUMBER Porcentaje del incremento del tamaño de

la extensión

42


FREELISTS NUMBER Número de procesos freelist asignados al

segmento

FREELIST_GROUPS NUMBER Número de grupos de freelist asignados al

segmento

LOGGING VARCHAR2(3) Indica si deben ser registrados o no los

cambios de la tabla.

BACKED_UP VARCHAR2(1) Indica si la tabla ha sido respaldada desde

la última modificación

NUM_ROWS NUMBER Número de filas de la tabla

BLOCKS NUMBER Número de bloques de datos usados por la

tabla

EMPTY_BLOCKS NUMBER Número de bloques vacíos

AVG_SPACE NUMBER Media de espacio libre de la tabla

CHAIN_CNT NUMBER Número de filas que se han encadenado de

un bloque a otro.

AVG_ROW_LEN NUMBER Tamaño medio en bytes de las filas

AVG_SPACE_

FREELIST _BLOCKS

NUMBER La media del espacio vacío de todos los

bloques

NUM_FREELIST_

BLOCKS

NUMBER Número de bloques de la freelist

DEGREE VARCHAR2(10) Número de hilos que escanean la tabla

INSTANCES VARCHAR2(10) Número de instancias a través de las cuales

va a ser escaneada la tabla

CACHE VARCHAR2(5) Indica si la tabla va a ser cacheada o no

TABLE_LOCK VARCHAR2(8) Indica si la tabla está bloqueada o no

43


SAMPLE_SIZE NUMBER Tamaño de la muestra utilizado para el

análisis

LAST_ANALYZED DATE Fecha de la última sincronización

PARTITIONED VARCHAR2(3) Indica si la tabla está particionada o no

IOT_TYPE VARCHAR2(12) Si la tabla es un tabla index‐organizated,

esta columna indica el tipo de IOT_TYPE

TEMPORARY VARCHAR2(1) Indica si la tabla es temporal o no

SECONDARY VARCHAR2(1) Indica si la tabla es secundaria o no

NESTED VARCHAR2(3) Indica si la tabla es anidada

BUFFER_POOL VARCHAR2(7) Indica el tipo de buffer:

● DEFAULT

● KEEP

● RECYCLE

● NULL

ROW_MOVEMENT VARCHAR2(8) Indica si el partitioned row movement está

activo

GLOBAL_STATS VARCHAR2(3) Para tablas particionadas indica si las

estadísticas son globales o se estimaron

sobre las particiones y subparticiones

USER_STATS VARCHAR2(3) Indica si las estadísticas son introducidas

por el usuario

DURATION VARCHAR2(15) Indica la duración de la tabla en caso de ser

temporal

SKIP_CORRUPT VARCHAR2(8) Indica si el gestor de base de datos debe

ignorar los bloques corruptos o de generar

un error

MONITORING VARCHAR2(3) Indica si la tabla debe ser monitorizada o

no

CLUSTER_OWNER VARCHAR2(30) Propietario del cluster donde se encuentra

44


alojada la tabla

DEPENDENCIES VARCHAR2(8) Indica si row‐level dependency tracking

está activo

COMPRESSION VARCHAR2(8) Indica si la compresión está activa o no

COMPRESS_FOR VARCHAR2(18) Indica las operaciones sobre las que se

realiza la compresión:

● DIRECT LOAD ONLY

● FOR ALL OPERATIONS

● NULL

DROPPED VARCHAR2(3) Indica si la tabla ha sido borrada

Tabla 18

45


ALL_TAB_COLUMNS

Esta tabla contiene todas las columnas de las tablas de la base de datos:

Column Datatype NULL Description

OWNER VARCHAR2(30) NOT NULL

Dueño de la vista

TABLE_NAME VARCHAR2(30) NOT NULL

Nombre de la tabla

COLUMN_NAME VARCHAR2(30) NOT NULL

Nombre de la columna

DATA_TYPE VARCHAR2(106) Tipo de dato de la columna

DATA_TYPE_MOD VARCHAR2(3) Modificador del tipo de dato de la columna

DATA_TYPE_OWNER VARCHAR2(30) Propietario del tipo de dato de la columna

DATA_LENGTH NUMBER NOT NULL

Tamaño de la columna en bytes

DATA_PRECISION NUMBER Número de dígitos totales que admite la columna cuyo tipo de datos sea NUMBER

DATA_SCALE NUMBER Dígitos a la derecha a partir de la coma

NULLABLE VARCHAR2(1) Indica si la columna puede ser NULL o no

COLUMN_ID NUMBER Identificador de la columna

DEFAULT_LENGTH NUMBER Tamaño del valor por defecto

DATA_DEFAULT LONG Valor por defecto

NUM_DISTINCT NUMBER Número de los posibles diferentes valores

LOW_VALUE RAW(32) Valor mínimo de la columna

HIGH_VALUE RAW(32) Valor máximo de la columna

DENSITY NUMBER Densidad de la columna

NUM_NULLS NUMBER Número de nulos en la columna

NUM_BUCKETS NUMBER Número de buckets de la columna

LAST_ANALYZED DATE Fecha del último analyze

46


SAMPLE_SIZE NUMBER Tamaño de la muestra utilizada para el analyze

CHARACTER_SET_NAME VARCHAR2(44) Nombre del character set: CHAR_CS o NCHAR_CS

CHAR_COL_DECL_LENGTH

NUMBER Longitud

GLOBAL_STATS VARCHAR2(3) Para tablas particionadas indica si las estadísticas de la columna son globales o se estimaron sobre las particiones y subparticiones

USER_STATS VARCHAR2(3) Indica si las estadísticas son introducidas por el usuario

AVG_COL_LEN NUMBER Tamaño medio de la columna

CHAR_LENGTH NUMBER Longitud de la cadena. Este valor sólo es válido para estos tipos de datos:

● CHAR

● VARCHAR2

● NCHAR

● NVARCHAR

CHAR_USED VARCHAR2(1) Indica si la longitud es en bytes o en

carateres

V80_FMT_IMAGE VARCHAR2(3) Indica si la imagen tiene el formato de imagen 8.0

DATA_UPGRADED VARCHAR2(3) Indica si los datos de la columna están actualizados a la última versión del formato.

HISTOGRAM VARCHAR2(15) Indica el tipo de histogram: ● NONE

● FREQUENCY

● HEIGHT BALANCED

Tabla 19

47


ALL_CONSTRAINTS

Tabla que contiene las constraint de la base de datos:



NULL

Propietario de la restricción

CONSTRAINT_NAME VARCHAR2(30) NOT

NULL

Nombre de la restricción

CONSTRAINT_TYPE VARCHAR2(1) Tipo de restricción::

● C (check constraint)

● P (clave primaria)

● U (clave única)

● R (integridad referencial)

● V (con check option, en una

vista)

● O (sólo lectura en una vista)


NULL

Nombre de la tabla a la que hace

referencia la restricción

SEARCH_CONDITION LONG Texto de la condición de búsqueda de la

restricción de check

R_OWNER VARCHAR2(30) Propietario de la tabla a la que hace

referencia la restricción

R_CONSTRAINT_NAME VARCHAR2(30) Nombre de la restricción única que hace

referencia a la tabla

DELETE_RULE VARCHAR2(9) Regla de borrado de la restricción

referencial (CASCADE o NO ACTION)

STATUS VARCHAR2(8) Estado de la restricción (ENABLED o

DISABLED)

DEFERRABLE VARCHAR2(14) Indica si la restricción es diferible

DEFERRED VARCHAR2(9) Indica si la restricción inicialmente está

48


diferida

VALIDATED VARCHAR2(13) Indica si todos los datos cumplen la

restricción (VALIDATED o NOT

VALIDATED)

GENERATED VARCHAR2(14) Indica si la restricción fue creada por el

usuario o por el sistema

BAD VARCHAR2(3) Indica que la restricción está escrita de

forma ambigua

RELY VARCHAR2(4)

LAST_CHANGE DATE Fecha de último cambio de la restricción

INDEX_OWNER VARCHAR2(30) Nombre del dueño del índice

INDEX_NAME VARCHAR2(30) Nombre del índice

INVALID VARCHAR2(7) Indica si la restricción es inválida

VIEW_RELATED VARCHAR2(14) Indica si la restricción depende de una

vista

Tabla 20

49


ALL_CONS_CONSTRAINT

Tabla que contiene las columnas de cada constraint.



NULL

Dueño de la restricción

CONSTRAINT_NAME VARCHAR2(30) NOT

NULL

Nombre de la restricción


NULL Nombre de la tabla

COLUMN_NAME VARCHAR2(4000) Nombre de la columna a la que le afecta la

restricción

POSITION NUMBER Posición de la columna en la restricción

Tabla 21

50


Herramientas utilizadas

Google Drive

Google Drive es un servicio de almacenamiento de archivos en internet, el cual es accesible

desde casi cualquier plataforma (Android, Windows, Mac, Linux…), siendo tan sólo necesario

una conexión a internet [11].

Dentro de esta herramienta desarrollada por Google, se encuentra Google Docs, que es un

procesador de texto online y gratuito, que guarda los documentos generados en el propio

Google Drive siendo posible acceder a ellos al igual que con Google Drive desde cualquier

plataforma. Estos documentos pueden ser compartidos y observar los cambios entre

diferentes versiones.

Para el desarrollo del proyecto se va a utilizar Google Drive, tanto para almacenar el código

fuente de la herramienta a desarrollar, como para guardar y editar los diferentes documentos

necesarios del trabajo fin de carrera, como son la memoria, el sprint backlog, pruebas de

integración, etc.

51


Draw.io

Es un programa de dibujo desarrollado por JGraph que se integra en Google Docs que permite

hacer de diagramas tipo UML, diagramas de flujo, diagramas de entidad relación, etc [12].

Ilustración 7

Debido a su buena integración con Google Drive en el proyecto va a utilizar para realizar los

diferentes diagramas y así integrarlos dentro de los documentos.

52


Web sequence diagrams

Al igual que las anteriores herramientas, esta herramienta también es una herramienta

gratuita y online que se utiliza, como indica su nombre, para la generación de diagramas de

secuencia. La utilización de esta herramienta es sencilla, tan sólo se debe escribir en la parte

izquierda de la pantalla los diferentes pasos del diagrama de secuencia utilizando una

nomenclatura propia y el diagrama se va generando en la parte de la derecha de la pantalla

[13].

Ilustración 8

Se decidió utilizar esta herramienta debido a su facilidad de uso, que se podía utilizar en

cualquier plataforma y que los datos estaban guardados en la nube por lo que se podía utilizar

en cualquier momento.

53


Eclipse

Un entorno de desarrollo integrador o IDE (sigla en inglés de integrated Development

Environment) es un programa compuesto por diferentes herramientas de programación que

las centralizan en el mismo programa facilitando así la programación. Normalmente está

compuesto como mínimo por un editor de texto, un compilador y depurador, aunque en la

actualidad los IDEs han ido añadiendo muchas más funcionalidades desde la generación de un

web service a través de un wsdl como la creación de la interfaz gráfica de una página web [14].

Para este proyecto se ha decidido usar como IDE Eclipse, que es un entorno de desarrollo de

propósito general.

Desarrollado por IBM, en sus orígenes nació como el sucesor de Visual Age, pero al cabo de los

años se creó una organización sin ánimo de lucro para que se encargara de ella y a la vez

promoviera el software libre.

Actualmente está bajo la licencia Eclipse Public License, que es una licencia de software libre

aunque incompatible con GPL.

Posiblemente sea el IDE más extendido en la actualidad, debido a que ya no es sólo un entorno

de desarrollo para Java sino que también existe la posibilidad de desarrollar en otros lenguajes

como C, Ruby, PHP, etc.

Una de sus principales características son los plugins, que son complementos independientes

que se acoplan a Eclipse para darle una funcionalidad extra que antes no tenía. Esto hace que

Eclipse sea muy versátil pudiéndose adaptar a cualquier circunstancia con tan sólo instalar los

plugins necesarios para ese desarrollo.

54


Desarrollo

Como se indicó anteriormente se va a utilizar la metodología de desarrollo Scrum, pero al ser

un trabajo fin de carrera, los diferentes actores que intervienen en esta metodología no están

presentes, por lo que todos serán representados por la misma persona.

Primera iteración

Reunión de planificación (Sprint Planning)

En esta primera reunión el Product Owner define el product backlog que indicará los requisitos

iniciales del producto:

Requisito Descripción Estado

REQ1 Recolección de los metadatos de la BBDD Pendiente

REQ2 Creación de la clase de negocio Pendiente

REQ3 Generación de xsd de una tabla Pendiente

REQ4 Generación de un bean java Pendiente

Tabla 22

� REQ1: Se deberá generar una estructura en memoria que almacene toda la

información de la antigua base de datos, sus tablas, sus columnas, los tipos de éstas,

sus claves primarias y sus claves foráneas.

� REQ2: Se deberá generar una clase de negocio, por cada tabla. Esta clase de negocio

estará vacía de contenido y se generará para que las personas que vayan a utilizar toda

esta estructura de clases metan ahí la lógica de su negocio.

� REQ3: Se deberá generar un xsd por cada tabla que representará a esta. Estos xsd

definirán las columnas con sus tipos de datos y sus claves.

� REQ4: Se deberá de generar una clase java que represente a cada una de las tablas.

Esa clase tendrá como atributos las columnas y claves, y serán del tipo

correspondiente con la Base de datos.

55


Después de definir el product backlog se procede a decidir con el product owner qué requisitos

se realizarán en este primer sprint.

El primer requisito que se debe realizar es la obtención de los metadatos de la base de datos

ya que los demás requisitos dependen de él.

En esta segunda parte de la reunión, el equipo tiene que definir las diferentes tareas que serán

necesarias para poder realizar el requisito antes de finalizar el sprint. Estas tareas quedarán

plasmadas en el sprint backlog.

Tarea Descripción Fecha prevista de fin Fecha de fin Estado

T1

Creación de Máquina

Virtual con una BBDD

Oracle 1/11/2013 1/11/2013 Finalizado

T2

Creación de la estructura

de clases donde van a ser

almacenados los

metadatos 7/11/2013 7/11/2013 Finalizado

T3

Obtención de los datos de

las tablas 15/11/2013 15/11/2013 Finalizado

T4 Pruebas de integración 17/11/2013 18/11/2013

Tabla 23

T1 ‐ Máquina Virtual Windows XP y Oracle Database Express Edition

Debido a que entorno en el que se va a trabajar es un ordenador MAC y no existe para ése

sistema operativo Oracle Database Express Edition, es necesario crear una máquina virtual

para poder virtualizar una máquina con el sistema operativo Windows XP y en él instalado esa

base de datos. El primer paso es instalar el sistema operativo para posteriormente, instalar la

base de datos. Al no necesitar ninguna opción especial la base de datos, ya que su uso va a ser

simplemente para consultar su catálogo de datos, se dejan todas las opciones que vienen por

defecto en el wizard. Una vez instalada, se procede a instalar el SQL Developer y a activar la

base de datos que viene de ejemplo, ya que inicialmente está deshabilitada.

56


T2 ‐ Creación de la estructura de clases donde van a ser almacenados los metadatos

Diagrama de clases donde se almacenarán los metadatos de la base de datos:

Ilustración 9

Table

La clase Table representará a las tablas de la base de datos y tendrá como atributos tanto sus

columnas como sus constraint.

Constraint

Representa a las constraint. Contendrá su nombre, alias y tipo, también el nombre de la

columna a la que pertenece la constraint.

Column

Representa a las columnas. Contiene el nombre de la columna, alias, tipo de dato, precisión del

dato, escala, longitud y si puede ser nulo o no.

57


T3 Obtención de los datos de las tablas

En esta tarea se deberá diseñar y desarrollar el módulo que obtenga los datos de la base de

datos y los guarde en la estructura de clases diseñada en la tarea anterior. El diagrama de

secuencia a alto nivel es el siguiente:

Ilustración 10

58


Los pasos serán los siguientes:

1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos, uno de

ellos será las tablas que se quieren tratar.

2. El generador por cada tabla llamará al GeneradorTablas para obtener todos los datos

de esa tabla.

3. El GeneradorTablas en primer lugar obtendrá las columnas.

4. Éste consultará en la tabla ALL_TAB_COLUMNS, las columnas de la tabla.

5. Devolverá un Resultset con los datos de todas las columnas.

6. Se creará un objeto Column por cada fila del Resulset y se devolverá una lista de

columnas.

7. Ahora el GeneradorTablas obtendrá las constraint.

8. Éste consultará la tabla ALL_CONSTRAINTS para obtener todas las constraint

de esa tabla.

9. Devolverá un Resultset con las constraint.

10. Se creará un objeto Constraint por cada fila del Resulset y se devolverá una

lista de constraint.

11. Devolverá un objeto Table con todos sus datos.

Pruebas unitarias

Para las pruebas unitarias se utilizará el framework junit como se indicó anteriormente,

creando las siguiente pruebas con sus resultados:

� Test de configuración:

� Arrancar la aplicación con unos argumentos de configuración correctos.

� Arrancar la aplicación con unos argumentos de configuración incorrectos.

� Arrancar la aplicación sin argumentos de configuración.

� Test de obtención de datos de una tabla.

� Obtención de datos de una tabla con una columna de tipo numérico.

� Obtención de datos de una tabla con una columna de tipo texto.

� Obtención de datos de una tabla con una columna de tipo fecha.

� Obtención de datos de una tabla con varias columna de tipo numérico, texto y

fecha.

� Obtención de datos de una tabla con una constraint.

� Obtención de datos de una tabla con varias constraints.

59


T4 Pruebas de integración

Para las pruebas de integración se generaron los siguientes test.

ID Titulo Descripción Resultado esperado

1 Configuración correcta

Arrancar la aplicación con la configuración:

‐properties /Users/prueba/Google\\ Drive/TFC/JCelsig/properties/generador.properties ‐fileTables /Users/prueba/Google\\ Drive/TFC/JCelsig/plantillas/ListadoTablas.txt

Siendo los path correctos

La aplicación arranque y se paresin producir ningún error

2 Configuración incorrecta

Arrancar la aplicación con la configuración:

‐propert iuasdiuf

La aplicación al arrancar muestra un error indicando que la configuración es incorrecta y se detiene

3 Configuración vacía

Arrancar la aplicación sin ningún argumento. La aplicación al arrancar muestra un mensaje indicando que es necesaria indicar una configuración y se detiene

4 Obtención de datos de una tabla

Arrancar la aplicación indicando en el fichero de las tablas a exportar que se deben extraer los datos de la tabla COUNTRIES de la base de datos de test.

La aplicación obtendrá los datos de la tabla y mostrará por el log las columnas y sus constraint:

COUNTRY_ID

COUNTRY_NAME

REGION_ID

COUNTRY_C_ID_PK

60


5 Obtención de datos de varias tabla

Arrancar la aplicación indicando en el fichero de las tablas a exportar que se deben extraer los datos de las tablas COUNTRIES y EMPLOYEES de la base de datos de test.

La aplicación obtendrá los datos de las tablas y mostrará por el log las columnas y sus constraint:

COUNTRIES:

COUNTRY_ID

COUNTRY_NAME

REGION_ID

COUNTRY_C_ID_PK

EMPLOYEES:

EMPLOYEE_ID

FIRST_NAME

LAST_NAME

EMAIL

PHONE_NUMBER

HIRE_DATE

JOB_ID

SALARY

COMMISSION_PCT

MANAGER_ID

DEPARTMENT_ID

Tabla 24

61


Segunda iteración


En esta segunda reunión, el Product Owner da por terminado el primer requisito y decide cuál

es el siguiente requisito a realizar según sus prioridades, y como ya todos son independientes y

no dependen unos de otros, no hay ningún tipo de restricción. Se decide que el siguiente

requisito será el REQ2 ya que parece el más sencillo de los tres y así será más fácil comenzar

con la generación de archivos.


REQ1 Recolección de los metadatos de la BBDD Realizado

REQ2 Creación de la clase de negocio Pendiente



Tabla 25

62


En la segunda parte de la reunión el equipo discute cuáles son las tareas a realizar en este

segundo sprint para poder tener terminado el requisito al finalizar el mismo. Estas tareas

quedarán plasmadas en el sprint backlog como se hizo anteriormente.


T5

Búsqueda de una librería

de templates para la

generación de los

diferentes formatos de

salida 12/20/2013 12/20/2103 Finalizado

T6

Utilización de templates en

la generación de las clases

de business object 1/9/2014 1/14/2014 Finalizado

T7

Generación de las

plantillas para las clases

business object 1/15/2014 1/21/2014 Finalizado

T8 Pruebas de integración 1/17/2014 1/31/2014 Finalizado

Tabla 26

63


T5 ‐ Búsqueda de una librería de templates para la generación de los diferentes formatos de

salida

La tarea consiste en elegir una librería java que genere ficheros de texto plano, los cuales serán

la salida de nuestro programa (xsd, java, …). Se tienen diferentes opciones con sus pros y sus

contras que se resumen en la siguiente tabla.

Librería Pros Contras Licencia

Ninguna � Control total sobre el código� No dependencia de ningún

software de terceros.

� Mayor tiempo de desarrollo � Menor estabilidad � Menor testeo del software

Velocity � Proyecto muy estable� Apache está detrás del

proyecto � Motor muy potente

� Lleva años sin ser evolucionado.

� Es algo más lento que los demás templates.

Apache License 2.0

StringTemplate � El equipo de desarrollo ya conoce esta librería

� Ligero � Multiplataforma

� Menor documentación� La comunidad que lo

mantiene es pequeña

BSD

FreeMaker � Motor de propósito general� Proyecto vivo, su última

versión estable es del 2013 � Muy rápido procesando los

templates

� El tamaño del motor es bastante grande para las pretensiones del proyecto

BSD

Tabla 27

Teniendo en cuenta los pros y contras de cada uno de los motores de plantillas se elige

StringTemplate, ya que para el propósito de este proyecto no se necesita un motor muy

potente y el equipo de desarrollo ya conoce ese motor, por lo que no será necesario aprender

el funcionamiento de uno nuevo y será más eficiente.

64


T6 ‐ Utilización de templates en la generación de las clases de business object

Esta plantilla tendrá los siguientes parámetros de entrada:

� package: este parámetro indica en qué paquete se encuentra la clase. Esto sería en

caso de java, pero si el lenguaje que se va a generar es c# por ejemplo, el package sería

su namespace. En caso de que el lenguaje a generar no tuviera package, simplemente

con dejarlo vacío sería suficiente. Este parámetro se proporcionaría a través del fichero

de configuración ya que es decisión de la persona que ejecuta el programa a qué

package quiere que pertenezca.

� entity: este parámetro es el nombre de la clase. Este nombre será el nombre de la

tabla siguiendo las guías de estilo de java, primera letra en mayúsculas, en caso de ser

varias palabras, la primera letra de la siguiente palabra será también en mayúsculas,

etc [15].

� imports: este parámetro es una lista de clases o paquetes a importar. Al igual que el

package, esto también vendrá definido por el fichero de configuración, ya que el

encargado de generar el código sabrá qué clases son necesarias importar en su clase

de negocio. En caso de generar el código para otro lenguaje como c#, en ese

parámetro irán los namespace que se vayan a usar con la directiva using.

� sup: este último parámetro es la clase padre. Al igual que el package y los imports, será

definido en el fichero de configuración.

Plantilla

class(package,entity, imports, sup="Object")::= <<package <package>; <imports:generateImports()> public class <entity> extends { } >> generateImports(paquete)::= "import <paquete>; <\n>"

Tabla 28

Ésta sería la plantilla para generar la clase de negocio. A continuación explico cada una de sus partes:

class(package,entity, imports, sup="Object")::=

En esta parte se define el template y sus parámetros, como particularidad el parámetro sup tiene un valor por defecto que sería “Object”. <<package <package>;

65


<imports:generateImports()> public class <entity> extends { } >>

A continuación se define el template, donde se sustituyen las palabras que vienen entre los

símbolos de < y > por sus parámetros. Este template también tiene una llamada a otro

template, generateImports. La forma de llamar a este template es diferente, es una

operación map, por cada elemento del array se llama al template generateImports

pasando como primer argumento ese elemento del array, formando así los imports de la clase.

generateImports(paquete)::= "import <paquete>; <\n>"

T7 Generación de las plantillas para las clases business object

En esta tarea se deberá diseñar y desarrollar el módulo que generará las clases de negocio de

cada tabla, llamando al motor de templates y posteriormente guardando la clase generada en

un fichero aparte. El diagrama de secuencia a alto nivel es el siguiente:

Ilustración 11

66





2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama de

secuencia anterior).

3. El objeto tabla es devuelto.

4. Se llama al generador de clases para que generé el Business Object.

5. Éste a su vez, llama al GeneradorBusiness para que cree la clase.

6. El GeneradorBusiness rellena el template con los valores obtenidos de la bbdd y llama

al renderizado del motor de templates para que genere la clase.

7. La clase es devuelta.

Pruebas unitarias

� Test del GeneradorBusiness:

� Crear una clase Business Object sin imports ni clase padre.

� Crear una clase Business Object con imports pero sin clase padre.

� Crear una clase Business Object sin imports pero con clase padre.

� Crear una clase Business Object con imports y con clase padre.

67





6 Creación clases Business Object de una tabla

Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:

business.imports=com.tmp.*;org.apache.*

business.package=tmp

business.parent=Object

business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg

pathBusinessObjects=/Users/prueba/tmp/

Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES

La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*

7 Creación clases Business Object de varias tabla







Y en el fichero de las tablas a exportar que se exportarán las tablas COUNTRIES, EMPLOYEES Y DEPARTMENTS

La aplicación creará un fichero Countries.java, otro Employess.java y otro Departments.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*

68


8 Creación clases Business Object de una tabla sin clase padre


business.imports=com.tmp.*


business.parent=




La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, paquete tmp, imports com.tmp.*. La clase padre será Object porque en caso de no venir ninguna clase padre se pone ésa por defecto

9 Creación clases Business Object de una tabla con una clase padre diferente a Object


business.imports=com.tmp.*


business.parent=String




La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, paquete tmp, imports com.tmp.*. La clase padre será String como viene indicado en el fichero de configuración.

10 Creación clases Business Object de una tabla que importar dos paquetes








La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*

69


11 Creación clases Business Object de una tabla que importar varios paquetes


business.imports=com.tmp.*;org.apache.*;java.util.List;java.util.ArrayList






La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*, java.util.List, java.util.ArrayList

12 Creación clases Business Object de varias tablas que importar varios paquetes


business.imports=com.tmp.*;org.apache.*;java.util.List;java.util.ArrayList





Y en el fichero de las tablas a exportar que se exportará las tablas COUNTRIES, EMPLOYEES Y DEPARTMENTS

La aplicación creará un fichero Countries.java, otro Employess.java y otro Departments.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*, java.util.List, java.util.ArrayList

Tabla 29

70


Tercera iteración


En la tercera reunión el Product Owner cierra el segundo requisito. Y propone que se haga en

la siguiente iteración el tercer requisito, la creación del xsd que represente a la tabla.



REQ2 Creación de la clase de negocio Realizado



Tabla 30

En la segunda parte de la reunión se deciden las tareas a realizar para poder completar el

requisito.


T9

Desarrollo de un template

para poder crear el xsd

representativo de la tabla 2/13/2014 2/13/2014 Finalizado

T10

Creación de los xsd a

través de una plantilla 2/20/2014 2/20/2014 Finalizado


Tabla 31

71


T9 ‐ Desarrollo de un template para poder crear el xsd representativo de la tabla

Una de las características de StringTemplate es que se pueden añadir subplantillas dentro de

una plantilla. Para el desarrollo de esta plantilla se ha utilizado esa característica ya que era

mucho más sencillo desarrollarla de esta forma.

Plantilla

xsd(type, namespace)::= <<<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="%nameSpace%" targetNamespace="%nameSpace%" elementFormDefault="qualified" attributeFormDefault="unqualified"> %type% </xs:schema> >> simpleType(name, restriction)::= << <xs:simpleType name="%name%"> %restriction% </xs:simpleType> >> restrictionType(type, condition="")::= << <xs:restriction base="%type%"> %condition; separator={%\n%}% </xs:restriction> >> minLenghCondition(min)::= << <xs:minLength value="%min%"/> >> maxLenghCondition(max)::= << <xs:maxLength value="%max%"/> >> totalDigitsCondition(total)::= << <xs:totalDigits value="%total%"/> >> fractionDigitsCondition(fraction)::= << <xs:fractionDigits value="%fraction%"/> >> complexType(name, elements)::= << <xs:complexType name="%name%"> <xs:sequence> %elements%; separator={%\n%}% </xs:sequence> </xs:complexType> >> elementType(name, type)::= << <xs:element name="%name%" type="%type%" minOccurs="0"/> >>

Tabla 32

72


Para la definición de la plantilla del xsd se ha dividido la plantilla en dos subplantillas al igual que lo hace un xsd, la plantilla de tipos simples y la plantilla de tipos complejos. A su vez el tipo complejo tiene otra subplantilla, que es la plantilla elements en la cual se definen los elementos del tipo complejo. La plantilla de tipos simples se compone de otra plantilla para las restricciones del tipo simple y ésta también tiene otras subplantillas para las condiciones de la restricción.

Ilustración 12

73


Para la generación de los tipos simples se ha hecho una relación entre los tipos de datos de

SQL con los tipos de datos xsd más las restricciones necesarias, la tabla siguiente indica la

correlación entre los tipos [18]:

SQL XSD Facet used

VARCHAR xsd:string xs:minLength o xs:maxLength

VARCHAR2 xsd:string xs:minLength o xs:maxLength

CHAR xsd:string xs:minLength o xs:maxLength

NCHAR xsd:string xs:minLength o xs:maxLength

NVARCHAR2 xsd:string xs:minLength o xs:maxLength

NUMBER (entero) xsd:integer xs:totalDigits

NUMBER (decimal) xsd:decimal xs:totalDigits y xs:fractionDigits

DATE xsd:date

TIMESTAMP

xsd:dateTime

LONG xsd:long

BFILE xsd:base64Binary

BINARY_INTEGER xsd:integer

INTERVAL DAY xsd:string

INTERVAL YEAR xsd:string

LONG RAW xsd:base64Binary

74


Tabla 33

Para la generación de un tipo simple primero se deberán definir sus condiciones, para luego

ser añadidas a la restricción y esa restricción a su vez se añadirá al tipo simple. Esto en caso de

tener alguna condición, porque puede darse el caso que el tipo de dato no tenga ninguna

condición.

Vamos a explicarlo con un ejemplo. Hay que transformar esta columna a un tipo simple xsd. Su

definición en la tabla oracle sería la siguiente:

poblacion NUMBER (9,2)

Al ser un tipo numérico pero con decimal se va a definir como tipo xsd:decimal con dos

condiciones, xs:totalDigits y xs:fractionDigits. En primer lugar se llamará al template:

totalDigitsCondition(total)::= << <xs:totalDigits value="%total%"/> >> Este template definirá la condición del número total de dígitos que tendrá el tipo simple. Se le

pasará como parámetro ese número total de dígitos que puede tener el tipo, en este caso 9.

Posteriormente se llamará al template que creará la condición del número de decimales del

tipo de dato:

fractionDigitsCondition(fraction)::= << <xs:fractionDigits value="%fraction%"/> >> Como parámetro se le pasará el número de decimales que puede tener el tipo, en este caso 2.

Una vez definidas las dos condiciones, se le añadirán al template de la restricción.

restrictionType(type, condition="")::= << <xs:restriction base="%type%"> %condition; separator={%\n%}% </xs:restriction> >> Este template tiene dos parámetros de entrada, uno es el tipo que es obligatorio, en este caso

sería de tipo decimal y las condiciones, que para nuestro ejemplo serían dos, fractionDigits y

totalDigits. En caso de que no se añada ninguna condición, como puede ser para los tipos de

datos DATE, la condición tendrá como valor por defecto una cadena vacía.

Para terminar de definir el tipo simple se deberá llamar al template:

simpleType(name, restriction)::= << <xs:simpleType name="%name%"> %restriction% </xs:simpleType> >>

75


Esta plantilla tiene como parámetros la restricción definida previamente, no tiene valor por

defecto porque es necesaria su inserción, y el nombre del tipo simple, que será el nombre de la

tabla más el nombre del tipo.

Para la generación de un tipo complejo se seguirá la misma técnica que para los tipos simples,

primero se llamará a los templates de los elementos que formarán parte del tipo complejo,

para luego ser añadidos al tipo complejo. La plantilla de los elementos del tipo complejo es la

siguiente:

elementType(name, type)::= << <xs:element name="%name%" type="%type%" minOccurs="0"/> >>

Esta plantilla tiene dos parámetros de entrada, name que es el nombre del elemento del tipo

complejo que en nuestro caso será el nombre de la columna, y el segundo parámetro es el

nombre del tipo. Si el elemento es un tipo simple, el nombre del tipo será el definido en la

plantilla de tipos simples, en caso de que el elemento sea otro tipo complejo, su nombre de

tipo será el de ese tipo complejo. Para terminar, todos los elementos serán añadidos a la

plantilla del tipo complejo:

complexType(name, elements)::= << <xs:complexType name="%name%"> <xs:sequence> %elements%; separator={%\n%}% </xs:sequence> </xs:complexType> >>

Como se ha dicho anteriormente, el parámetro elements será la lista de elementos definida

previamente y el parámetro name el nombre del tipo complejo. En nuestro caso tendremos

dos tipos complejos que serán la PK de la tabla y la definición del tipo de la tabla que

contendrá los tipos simples que no estén definidos en la PK más el tipo complejo PK.

Para terminar, se añadirán tanto los tipos simples como los tipos complejos a la plantilla del

xsd.

xsd(type, namespace)::= << <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="%nameSpace%" targetNamespace="%nameSpace%" elementFormDefault="qualified" attributeFormDefault="unqualified"> %type% </xs:schema> >>

76


La plantilla tendrá como parámetros la lista de tipos, tanto simples como complejos y el

namespace del xsd. Éste será el último paso para la generación del xsd.

A continuación muestro la definición de una tabla en SQL y su resultado en xsd:

CREATE TABLE "COUNTRIES" ( "COUNTRY_ID" CHAR(2 BYTE), "COUNTRY_NAME" VARCHAR2(40 BYTE), "REGION_ID" NUMBER, CONSTRAINT "COUNTRY_C_ID_PK" PRIMARY KEY ("COUNTRY_ID") )

Tabla 34

<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="http://celsig.tme.es/jcelsig/JCELSIG/maestros" targetNamespace="http://celsig.tme.es/jcelsig/JCELSIG/maestros" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:simpleType name="FieldCountries_CountryIdType"> <xs:restriction base="xs:string"> <xs:minLength value="0"/> <xs:maxLength value="2"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="FieldCountries_CountryNameType"> <xs:restriction base="xs:string"> <xs:minLength value="0"/> <xs:maxLength value="40"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="FieldCountries_RegionIdType"> <xs:restriction base="xs:integer"> <xs:totalDigits value="38"/> </xs:restriction> </xs:simpleType> <xs:complexType name="CountriesType"> <xs:sequence> <xs:element name="pk" type="m:CountriesPkType"/> <xs:element name="regionId" type="m:FieldCountries_RegionIdType" minOccurs="0"/> <xs:element name="countryName" type="m:FieldCountries_CountryNameType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="CountriesPkType"> <xs:sequence> <xs:element name="countryId" type="m:FieldCountries_CountryIdType" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:schema>

Tabla 35

77


T10 Creación de los xsd a través de una plantilla

En esta tarea se diseñará y desarrollará el software para la generación de un xsd como

resultado de utilizar la plantilla diseñada en la tarea anterior y los datos obtenidos de cada

tabla. El diagrama de secuencia a alto nivel es el siguiente:

Ilustración 13

78





2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama de la

tarea T3).


4. Se llama al generador del esquema para que generé el xsd.

5. Por cada columna de la tabla se llamará al generador de tipos simples y creará el tipo

simple de esa columna empezando por crear la restricción de ese tipo simple

(template restricciotionType) indicando el tipo de dato de esa columna.

6. En caso de que la columna sea de tipo carácter (VARCHAR2, CHAR, ...) se creará la

condición de caracteres mínimos (template minLenghCondition).

7. Si la columna sigue siendo de tipo carácter y tiene un número máximo de caracteres se

creará la condición de caracteres máximos (template maxLenghCondition).

8. Si la columna es de tipo numérico se creará la condición de cantidad máxima de dígitos

dependiendo del tipo de dato, si en la base de datos la columna está definida como 9

dígitos máximos así será definida en el xsd (template totalDigitsCondition).

9. Si la columna sigue siendo numérica y, además tiene una parte decimal, se creará una

condición para indicar el número de decimales del número (template

fractionDigitsCondition).

10. A la restricción se le añaden las condiciones creadas previamente y se crea el tipo

simple y éste se añade al template padre que va a almacenar todos los datos.

11. Ahora se crea el elemento del tipo complejo independiente de si se trata de una

columna que pertene a la PK o no (template elementType).

12. En caso de que la columna pertenezca a la PK, se añade el elemento al tipo complejo

de la PK.

13. En caso contrario, que no pertenezca a la PK, se añade al elemento complejo que

representará toda la tabla.

14. En este punto ya se han tratado todas las columnas de la tabla por lo que el tipo

complejo que representa la PK está completo, entonces se procede a añadirlo al tipo

complejo que representa a toda la tabla y al template padre. También se añade el tipo

complejo que representa a toda la tabla al template padre.

15. Se llama al renderizado del motor de templates para que genere xsd.

16. El xsd es devuelto.

79


Pruebas unitarias

� Test del GeneradorSimple:

� Generar la condición minLenghCondition.

� Generar la condición maxLenghCondition.

� Generar la condición totalDigitsCondition.

� Generar la condición fractionDigitsCondition.

� Generar un tipo simple para una columna de tipo VARCHAR

� Generar un tipo simple para una columna de tipo VARCHAR2

� Generar un tipo simple para una columna de tipo CHAR

� Generar un tipo simple para una columna de tipo NCHAR

� Generar un tipo simple para una columna de tipo NVARCHAR2

� Generar un tipo simple para una columna de tipo NUMBER (entero)

� Generar un tipo simple para una columna de tipo NUMBER (decimal)

� Generar un tipo simple para una columna de tipo DATE

� Generar un tipo simple para una columna de tipo TIMESTAMP

� Generar un tipo simple para una columna de tipo LONG

� Generar un tipo simple para una columna de tipo BFILE

� Generar un tipo simple para una columna de tipo BINARY_INTEGER

� Generar un tipo simple para una columna de tipo INTERVAL DAY

� Generar un tipo simple para una columna de tipo INTERVAL YEAR

� Generar un tipo simple para una columna de tipo LONG RAW

� Test del GeneradorComplex:

� Generar un elemento.

� Generar un tipo complejo con una tabla de una columna de tipo VARCHAR

� Generar un tipo complejo con una tabla de una columna de tipo VARCHAR2

� Generar un tipo complejo con una tabla de una columna de tipo CHAR

� Generar un tipo complejo con una tabla de una columna de tipo NCHAR

� Generar un tipo complejo con una tabla de una columna de tipo NVARCHAR2

� Generar un tipo complejo con una tabla de una columna de tipo NUMBER

(entero)

� Generar un tipo complejo con una tabla de una columna de tipo NUMBER

(decimal)

� Generar un tipo complejo con una tabla de una columna de tipo DATE

� Generar un tipo complejo con una tabla de una columna de tipo TIMESTAMP

80


� Generar un tipo complejo con una tabla de una columna de tipo LONG

� Generar un tipo complejo con una tabla de una columna de tipo BFILE

� Generar un tipo complejo con una tabla de una columna de tipo

BINARY_INTEGER

� Generar un tipo complejo con una tabla de una columna de tipo INTERVAL DAY

� Generar un tipo complejo con una tabla de una columna de tipo INTERVAL

YEAR

� Generar un tipo complejo con una tabla de una columna de tipo LONG RAW

� Generar un tipo complejo con dos tipos de datos simples

� Generar un tipo complejo con otro tipo complejo

� Generar un tipo complejo con un tipo simple y un tipo complejo

� Test Generador Esquemas:

� Generar un esquema de una tabla con una columna de tipo VARCHAR

� Generar un esquema de una tabla con una columna de tipo VARCHAR2

� Generar un esquema de una tabla con una columna de tipo CHAR

� Generar un esquema de una tabla con una columna de tipo NCHAR

� Generar un esquema de una tabla con una columna de tipo NVARCHAR2

� Generar un esquema de una tabla con una columna de tipo NUMBER (entero)

� Generar un esquema de una tabla con una columna de tipo NUMBER (decimal)

� Generar un esquema de una tabla con una columna de tipo DATE

� Generar un esquema de una tabla con una columna de tipo TIMESTAMP

� Generar un esquema de una tabla con una columna de tipo LONG

� Generar un esquema de una tabla con una columna de tipo BFILE

� Generar un esquema de una tabla con una columna de tipo BINARY_INTEGER

� Generar un esquema de una tabla con una columna de tipo INTERVAL DAY

� Generar un esquema de una tabla con una columna de tipo INTERVAL YEAR

� Generar un esquema de una tabla con una columna de tipo LONG RAW

� Generar un esquema de una tabla con una columna de tipo LONG

� Generar un esquema de una tabla con una PK de una columna

� Generar un esquema de una tabla con una PK de dos columnas

� Generar un esquema de una tabla sin PK.

81





13 Creación de un esquema de una tabla sin PK y una columna

Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:

CREATE TABLE test13

( column1 NUMBER );

Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test13.

La aplicación generará un fichero test13.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest13_Column1Type y un tipo complejo con un solo elemento que será del tipo anterior.

14 Creación de un esquema de una tabla con PK de un solo campo y sin más columnas

Primero se crea una tabla con PK de una y con una columna en la bbdd ejecutando el siguiente comando:

CREATE TABLE TEST14 ( COLUMN1 NUMBER, CONSTRAINT "TEST14_COLUMN_PK" PRIMARY KEY (COLUMN1) );


La aplicación generará un fichero test14.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest14_Column1Type y dos tipos complejos uno será la PK y otro será el tipo de la tabla con un solo elemento que será la PK

15 Creación de un esquema de una tabla con PK de dos campos y sin más columnas


CREATE TABLE TEST15 ( COLUMN1 NUMBER, COLUMN2 NUMBER, CONSTRAINT "TEST15_COLUMN_PK" PRIMARY KEY (COLUMN1, COLUMN2) );


La aplicación generará un fichero test15.xsd en el que habrá dos tipos simples de tipo integer y cuyo nombre será FieldTest15_Column1Type y FieldTest15_Column2Type y dos tipos complejos uno será la PK que estará compuesto de dos elementos, los dos tipos simples y otro será el tipo de la tabla con un solo elemento que será la PK

82


16 Creación de un esquema de una tabla con PK de un solo campo y con más columnas


CREATE TABLE TEST16 ( COLUMN1 NUMBER, COLUMN2 NUMBER, CONSTRAINT "TEST16_COLUMN_PK" PRIMARY KEY (COLUMN1) );


La aplicación generará un fichero test16.xsd en el que habrá dos tipos simples de tipo integer y cuyo nombre será FieldTest16_Column1Type y FieldTest16_Column2Type y dos tipos complejos uno será la PK que estará compuesto de un elemento, el tipo simple FieldTest16_Column1Type y otro será el tipo de la tabla con dos elementos, uno será la PK y otro será FieldTest16_Column2Type.

17 Creación de un esquema de una tabla con PK de dos campos y con más columnas


CREATE TABLE TEST17 ( COLUMN1 NUMBER, COLUMN2 NUMBER, COLUMN3 NUMBER, CONSTRAINT "TEST17_COLUMN_PK" PRIMARY KEY (COLUMN1, COLUMN2) );


La aplicación generará un fichero test17.xsd en el que habrá tres tipos simples de tipo integer y cuyo nombres serán FieldTest17_Column1Type, FieldTest17_Column2Type y FieldTest17_Column3Type y dos tipos complejos uno será la PK que estará compuesto de dos elementos, los tipos simples FieldTest17_Column1Type y FieldTest17_Column2Type y otro será el tipo de la tabla con dos elementos, uno será la PK y otro será FieldTest17_Column3Type.

Tabla 36

83


Cuarta iteración


En la cuarta reunión el Product Owner da por terminado el tercer requisito. Para el siguiente

requisito, no hay ninguna discusión ya que solo queda uno por realizar, por lo tanto se decide

empezarlo.



REQ2 Creación de la clase de negocio Realizado

REQ3 Generación de xsd de una tabla Realizado


Tabla 37

El requisito se divide en tareas similares a los anteriores requisitos ya que sólo cambia el tipo

de fichero que se generará, pero la mecánica será parecida.


T12

Desarrollo de un template

para crear un bean java 3/28/2014 3/30/2014 Finalizado

T13

Creación de los bean java a

través de una plantilla 4/20/2014 4/20/2014 Finalizado


Tabla 38

84


T12 ‐ Desarrollo de un template para crear un bean java

Para el desarrollo de esta plantilla se ha seguido la premisa de que sólo tendrían como

parámetros de entrada, el nombre de la clase, los atributos de ésta y su paquete o localización,

a diferencia de la plantilla anterior que se utilizaban subtemplates para la construcción del xsd.

La razón de hacerlo de esta manera es para que en el código del generador no se integrará con

el lenguaje de programación de la clase a generar. En nuestro caso se va a generar un bean

java, pero si se quisiera generar una clase de este tipo para un lenguaje en el que el acceso a

los atributos fuera directo y no a través de un método, tendríamos un problema, ya que no se

podría resolver a través de la plantilla porque estaría muy integrado en el código. Por esta

razón, la lógica de cómo crear la clase se encuentra en la plantilla y el generador sólo se

encarga de proporcionarle los datos para construirla (nombre, atributos con sus tipos de datos

y paquete).

La plantilla se dividirá en cuatro partes, una para la generación de los atributos de la clase, otra

para el constructor de la clase, otra, los métodos de acceso de los atributos y, por último, la

zona en la que se llamarán a todos los subtemplates anteriores.

85


Plantilla

typeMap ::= [ "BFILE":"oracle.sql.BFILE", "BINARY_INTEGER":"int", "CHAR":"String", "DATE":"java.sql.Timestamp", "INTERVAL DAY":"String", "INTERVAL YEAR":"String", "LONG":"String", "LONG RAW":"byte[]", "NCHAR":"oracle.sql.NString", "NUMBER":"java.math.BigDecimal", "NVARCHAR2":"String", "RAW":"byte[]", "ROWID":"oracle.sql.ROWID", "TIMESTAMP":"java.sql.Timestamp", "UROWID":"oracle.sql.ROWID", "VARCHAR":"String", "VARCHAR2":"String" ] typeInitMap ::= [ "int":"0", "long":"0", "float":"0.0", "double":"0.0", "boolean":"false", "byte":"0", "short":"0", "char":"0", default:"null" ] class(package,nameClass, atributes, sup="Object")::= <<package <package>; public class <nameClass> extends { <atributes:atribute(); separator="\n"> <constructor(nameClass, atributes)> <atributes:generateMethods(); separator="\n"> } >> atribute(parameter)::= << <typeMap.(parameter.type)> <parameter.name> = <typeInitMap.(typeMap.(parameter.type))>; >> generateMethods(parameter)::= << <getMethod(parameter)> <setMethod(parameter)> >>

86


getMethod(parameter)::= << public <typeMap.(parameter.type)> get<parameter.name; format="cap"> (){ return <parameter.name>; } >> setMethod(parameter)::= << public void set<parameter.name;format="cap"> (<typeMap.(parameter.type)> <parameter.name>){ this.<parameter.name> = <parameter.name>; } >> constructor(nameClass, parameters)::= << public <nameClass>(<parameters:generateParameter(); separator=", ">){ <parameters:generateAssign(); separator="\n"> } >> generateParameter(parameter)::= << <typeMap.(parameter.type)> <parameter.name> >> generateAssign(parameter)::= << this.<parameter.name> = <parameter.name>; >>

Tabla 39

Al inicio de la plantilla se definen dos diccionarios de datos. El primero de ellos define la

compatibilidad de tipos de datos entre la BBDD y Java [16]:

typeMap ::= [ "BFILE":"oracle.sql.BFILE", "BINARY_INTEGER":"int", "CHAR":"String", "DATE":"java.sql.Timestamp", "INTERVAL DAY":"String", "INTERVAL YEAR":"String", "LONG":"String", "LONG RAW":"byte[]", "NCHAR":"oracle.sql.NString", "NUMBER":"java.math.BigDecimal", "NVARCHAR2":"String", "RAW":"byte[]", "ROWID":"oracle.sql.ROWID", "TIMESTAMP":"java.sql.Timestamp", "UROWID":"oracle.sql.ROWID", "VARCHAR":"String", "VARCHAR2":"String" ]

87


Como se puede ver, a la izquierda se define el tipo de datos de Oracle y, a la derecha, su

correspondencia con Java. Este diccionario permitirá pasarle al template el tipo de dato

original de la tabla que se quiere exportar y, de forma sencilla, obtener el tipo de datos usado

dentro de la clase.

El segundo diccionario define los datos inicialización de cada tipo de dato.

typeInitMap ::= [ "int":"0", "long":"0", "float":"0.0", "double":"0.0", "boolean":"false", "byte":"0", "short":"0", "char":"0", default:"null" ]

Este diccionario de datos se le pasa como parámetro el tipo del dato y devuelve el valor con el

que se debe inicializar. Todos los tipos primitivos de java son inicializados a 0 o a false y en

caso de ser un objeto se inicializa a null.

La siguiente parte de la plantilla es la plantilla principal, la cual será llamada desde el código del

generador.

class(package,nameClass, atributes, sup="Object")::= << package <package>; public class <nameClass> extends { <atributes:atribute(); separator="\n"> <constructor(nameClass, atributes)> <atributes:generateMethods(); separator="\n"> } >> Esta plantilla será el único punto de comunicación entre el generador de código y las plantillas

por lo que se ha explicado previamente. Por lo tanto debe recibir toda la información necesaria

para la generación de la clase. Sus parámetros son el nombre de la clase, el paquete de la clase

y una lista de atributos. También tiene un atributo más, que es la clase padre de la clase a

generar, pero tiene un valor por defecto que es object, por lo que no se rellena desde el

generador. La primera línea simplemente genera la línea de código que indica el paquete al

que pertenece la clase. La siguiente línea es la definición de la clase con su nombre de clase y

su clase padre.

88


En esta parte de la plantilla es donde se va a definir:

� atributos

� constructor

� getter y setter de los atributos

Cada una de estas partes tiene su propia plantilla para que sea más sencillo el desarrollo y más

modular.

Stringtemplate proporciona un mecanismo para facilitar la llamada a un método n veces,

siendo n el número de elementos de una lista y a su vez se le pasa como argumento ese

elemento de la lista. Para generar los atributos se ha utilizado esa característica, haciendo que

por cada elemento de la lista de atributos sea llamado el subtemplate atribute que recibe

como parámetro ese elemento de la lista. Además Stringtemplate te permite elegir el

separador que se introducirá entre cada una de las llamadas al subtemplate, en nuestro caso

se ha introducido un salto de línea.

Ahora vamos a explicar el subtemplate atribute que es el encargado de generar cada

atributo.

atribute(parameter)::= << <typeMap.(parameter.type)> <parameter.name> =

<typeInitMap.(typeMap.(parameter.type))>;

>>

89


Este subtemplate recibe como parámetro el atributo a generar. Como se explicó previamente

Stringtemplate puede pasar objetos bean a las plantillas y, éstas acceder a los atributos de ese

objeto siempre que tengan un método getter público. En nuestro caso recibe un bean.

package org.generador.services; public class Parameter { private String type; private String name; public Parameter (String name, String type) { this.name = name; this.type = type; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getType() { return type; } public void setType(String type) { this.type = type; } }

Tabla 40

Que como se puede ver tiene dos atributos, uno el tipo Oracle al que pertenece el atributo y

otro su nombre. El tipo de datos de Oracle es pasado al diccionario de datos de la plantilla para

obtener su tipo de dato de java <typeMap.(parameter.type)> y posteriormente, se

obtiene el nombre del atributo <parameter.name>. Para finalizar se debe inicializar el

atributo, por lo que se debe recurrir a los dos diccionarios de datos. En primer lugar se obtiene

el tipo de datos para posteriormente, ir al segundo diccionario de datos y obtener su valor de

inicialización <typeInitMap.(typeMap.(parameter.type))>.

90


El siguiente subtemplate generateMethods genera un método get y set para obtener y

asignar el valor de cada atributo respectivamente.

generateMethods(parameter)::= << <getMethod(parameter)> <setMethod(parameter)> >> getMethod(parameter)::= << public <typeMap.(parameter.type)> get<parameter.name; format="cap"> (){ return <parameter.name>; } >> setMethod(parameter)::= << public void set<parameter.name;format="cap"> (<typeMap.(parameter.type)> <parameter.name>){ this.<parameter.name> = <parameter.name>; } >>

Al igual que el anterior subtemplate, éste es llamado una vez por cada atributo de la clase. El

subtemplate consta de dos otros dos subtemplates que son llamados consecutivamente, uno

para el método get y otro del método set.

El subtemplate getMethod tiene como parámetro de entrada un objeto de la clase

Parameter que representa el atributo que se quiere obtener. El código generado será un

método público que devuelve el tipo de dato del atributo que se obtiene a través del

diccionario de datos typeMap. El siguiente elemento del subtemplate es el nombre del

método. Éste se genera concatenando la palabra get con el nombre del atributo, siendo la

primera letra del atributo una mayúscula. Para conseguir que la primera letra sea mayúscula se

recurre a una característica de StringTemplate format="cap", la cual hace que la primera

letra de la expresión sea mayúscula. Posteriormente van los parámetros del método que al ser

un método get están vacíos. Por último, dentro del cuerpo del método simplemente se

devuelve el atributo.

El subtemplate setMethod al igual que el anterior subtemplate tiene como parámetro de

entrada un objeto de la clase Parameter que representa el atributo que se quiere asignar. Este

subtemplate construye el método set de forma muy similar al anterior, con la diferencia que

no devuelve nada y, por lo tanto, su valor de retorno es void y que sí tiene un parámetro de

entrada, que es el valor a asignar al atributo. Ya en el cuerpo del método se asigna el valor al

atributo de la clase.

91


Por último está el subtemplate que genera el constructor de la clase constructor:

constructor(nameClass, parameters)::= << public <nameClass>(<parameters:generateParameter(); separator=", ">){ <parameters:generateAssign(); separator="\n"> } >> generateParameter(parameter)::= << <typeMap.(parameter.type)> <parameter.name> >> generateAssign(parameter)::= << this.<parameter.name> = <parameter.name>; >>

Este subtemplate recibe como parámetros el nombre de la clase y todos los atributos que la

forman. Al igual que el resto de métodos de la clase el constructor también será público y su

nombre, como obliga el lenguaje Java, será el nombre de la clase. Para la creación de los

parámetros de entrada del constructor se llamará a otro subtemplate generateParameter,

que es llamado una vez por cada parámetro e introduce como separación entre cada uno de

ellos, una coma separator=", ". Este subtemplate simplemente obtiene el tipo del dato del

parámetro a través del diccionario de datos y pone el nombre. El siguiente y último elemento

del subtemplate del constructor es la llamada por cada uno de los parámetros a otro

subtemplate que genera la asignación del parámetro de entrada con el atributo.

92


T13 Creación de los bean java a través de una plantilla

En esta tarea se diseñará y desarrollará el software para la generación del bean como

resultado de utilizar la plantilla diseñada en la tarea anterior y los datos obtenidos de cada

tabla. Este módulo del software será bastante sencillo ya que el peso de la generación del

código fuente recae en su mayoría en la plantilla, el software tan sólo le deberá proporcionar

los datos. El diagrama de secuencia a alto nivel es el siguiente:

Ilustración 14

93



1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos uno

de ellos será las tablas que se quieren tratar.

2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama

de la tarea T3).


4. Se llama al generador de clases java para que genere bean Java.

5. Por cada columna de la tabla se crea un objeto de tipo Parameter con el

nombre de columna y el tipo de dato Oracle.

6. Se llama al renderizado del motor de templates para que genere bean,

pasándole como parámetros el nombre de la tabla, la lista de objetos Parameter

creada anteriormente y el paquete al que va a pertenecer que se obtendrá del fichero

de configuración.

7. El bean es devuelto.

Pruebas unitarias

� Test del GeneradorJavaClass:

� Generar una clase con un atributo cuya columna sea de tipo VARCHAR

� Generar una clase con un atributo cuya columna sea de tipo VARCHAR2

� Generar una clase con un atributo cuya columna sea de tipo CHAR

� Generar una clase con un atributo cuya columna sea de tipo NCHAR

� Generar una clase con un atributo cuya columna sea de tipo NVARCHAR2

� Generar una clase con un atributo cuya columna sea de tipo NUMBER (entero)

� Generar una clase con un atributo cuya columna sea de tipo NUMBER

(decimal)

� Generar una clase con un atributo cuya columna sea de tipo DATE

� Generar una clase con un atributo cuya columna sea de tipo TIMESTAMP

� Generar una clase con un atributo cuya columna sea de tipo LONG

� Generar una clase con un atributo cuya columna sea de tipo BFILE

� Generar una clase con un atributo cuya columna sea de tipo BINARY_INTEGER

� Generar una clase con un atributo cuya columna sea de tipo INTERVAL DAY

� Generar una clase con un atributo cuya columna sea de tipo INTERVAL YEAR

� Generar una clase con un atributo cuya columna sea de tipo LONG RAW

94





18 Creación de un bean java con un atributo


CREATE TABLE TEST18 ( COLUMN1 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test18.

La aplicación generará un fichero Test18.java con un atributo column1 de tipo java.math.BigDecimal y el constructor tendrá solo un parámetro.

A parte del constructor tendrá dos métodos públicos get y set del atributo column1.

19 Creación de un bean java con dos atributo


CREATE TABLE TEST19 ( COLUMN1 NUMBER, COLUMN2 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test19.

La aplicación generará un fichero Test19.java con dos atributos column1 y column2 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.

A parte del constructor tendrá un método público get y otro set por cada atributo.



CREATE TABLE TEST20 ( COLUMN1 VARCHAR, COLUMN2 VARCHAR ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test20.

La aplicación generará un fichero Test20.java con dos atributos column1 y column2 de tipo String y el constructor tendrá dos parámetros.




CREATE TABLE TEST21 ( COLUMN1 VARCHAR, COLUMN2 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test21.

La aplicación generará un fichero Test21.java con dos atributos column1 de tipo String y column2 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.


95


22 Creación de un bean java con varios atributos


CREATE TABLE TEST22 ( COLUMN1 VARCHAR, COLUMN2 NUMBER, COLUMN3 BFILE, COLUMN4 BINARY_INTEGER, COLUMN5 CHAR, COLUMN6 DATE", COLUMN7 INTERVAL DAY, COLUMN8 INTERVAL YEAR, COLUMN9 LONG, COLUMN10 LONG RAW, COLUMN11 NCHAR, COLUMN12 NUMBER, COLUMN13 NVARCHAR2, COLUMN14 RAW, COLUMN15 ROWID, COLUMN16 TIMESTAMP, COLUMN17 UROWID, COLUMN18 VARCHAR2 ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test22.

La aplicación generará un fichero Test22.java con los atributos column1‐18 siendo cada uno del tipo indicado en el diccionario de datos.

"BFILE":"oracle.sql.BFILE"

"BINARY_INTEGER":"int"

"CHAR":"String"

"DATE":"java.sql.Timestamp"

"INTERVAL DAY":"String"

"INTERVAL YEAR":"String"

"LONG":"String"

"LONG RAW":"byte[]"

"NCHAR":"oracle.sql.NString"

"NUMBER":"java.math.BigDecimal"

"NVARCHAR2":"String"

"RAW":"byte[]"

"ROWID":"oracle.sql.ROWID"

"TIMESTAMP":"java.sql.Timestamp"

"UROWID":"oracle.sql.ROWID"

"VARCHAR":"String"

"VARCHAR2":"String"


23 Ejecución completa de la generación de código


CREATE TABLE TEST23 ( COLUMN1 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test23.

La aplicación creará un fichero Test23.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects.

La aplicación generará un fichero test23.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest13_Column1Type y un tipo complejo con un solo elemento que será del tipo anterior.



96


24 Ejecución completa de la generación de código

Primero se crea una tabla con PK y con una columna en la bbdd ejecutando el siguiente comando:

CREATE TABLE TEST24 ( COLUMN1 NUMBER, CONSTRAINT "TEST24_COLUMN_PK" PRIMARY KEY (COLUMN1) ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test24.


La aplicación generará un fichero test24.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest24_Column1Type y dos tipos complejos uno será la PK y otro será el tipo de la tabla con un solo elemento que será la PK





CREATE TABLE TEST25 ( COLUMN1 NUMBER, COLUMN2 VARCHAR ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test25.


La aplicación generará un fichero test25.xsd en el que habrá dos tipos simples, uno de tipo integer y cuyo nombre será FieldTest25_Column2Type y otro de tipo string y cuyo nombre será FieldTest25_Column2Type, y exisitrá un tipo complejo con dos elementos que serán de los tipos anteriores.

La aplicación generará un fichero Test25.java con dos atributos column2 de tipo String y column1 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.


Tabla 41

97


Sprint Backlog Final


T1

Creación de Máquina

Virtual con una BBDD

Oracle 11/1/2013 11/1/2013 Finalizado

T2

Creación de la estructura

de clases donde van a

ser almacenados los

metadatos 11/7/2013 11/7/2013 Finalizado

T3

Obtención de los datos

de las tablas 11/15/2013 11/15/2013 Finalizado

T4

Pruebas de integración 11/17/2013 11/18/2013 Finalizado

Sprint 1 17/11/2013

T5

Búsqueda de una librería

de templates para la

generación de los

diferentes formatos de

salida 12/20/2013 12/20/2103 Finalizado

T6

Utilización de templates

en la generación de las

clases de business object 1/9/2014 1/14/2014 Finalizado

T7

Generación de las

plantillas para las clases

business object 1/15/2014 1/21/2014 Finalizado


Sprint 2 1/20/2014

98


T9

Generación de las

plantillas para los xsd 2/13/2014 2/13/2014 Finalizado

T10

Creación de los xsd a

través de una plantilla

con datos simples sin

añadir restricciones 2/20/2014 2/20/2014 Finalizado


Sprint 3 3/03/2014

T12

Desarrollo de un

template para crear un

bean java 3/28/2014 3/30/2014 Finalizado

T13

Creación de los bean

java a través de una

plantilla 4/20/2014 4/20/2014 Finalizado


Sprint 4 4/30/2014

Tabla 42

99


Trabajo Futuro

En trabajos futuros este proyecto se podría ampliar siguiendo varias líneas de trabajo

diferentes:

� Una opción para seguir el desarrollo sería ampliar los gestores de bases de datos

soportados, ya que en este momento el único gestor que es soportado es Oracle,

pudiendo añadir nuevos gestores como MySQL, Postgresql, SQLServer, etc. ya que

todos guardan en su propia base de datos el catálogo de las tablas que la componen.

Por ejemplo Postgresql guarda la información de las columnas en la tabla pg_attribute,

tan sólo se debería modificar la query que obtenía la información de las columnas

utilizando esta nueva tabla.

� Otra forma de ampliar el proyecto podría ser añadir nuevos lenguajes a los que

exportar la base de datos y no sólo a java. Esto sería más sencillo de realizar, ya que el

software ha sido separado en diferentes capas, separando la parte de obtención de los

datos de la base de datos de la generación del código, dejando la responsabilidad de la

generación del código a las plantillas por lo que, para generar el código en un nuevo

lenguaje, sólo habría que preparar una plantilla nueva para ese lenguaje en concreto.

� Por último, otra opción a seguir para ampliar el proyecto sería crear una interfaz

gráfica para la ejecución de la herramienta ya que su ejecución es a través de línea de

comandos, por lo que es una interfaz poco amigable. También toda su configuración se

basa en ficheros de configuración que hay que modificar manualmente accediendo a

ellos, por lo que sería más recomendable que la modificación de estos ficheros se

realizara a través de la propia interfaz gráfica.

100


� Para esta tarea existen diferentes librerías en java que facilitarían el trabajo de crear la

interfaz, como pueden ser:

� AWT, es la librería en la que se basa Swing, sus componentes son bastante

básicos pero, si la interfaz no va a ser muy elaborada, puede ser válida.

� Swing, como se dijo anteriormente se basa en AWT, tiene componentes para

generar una interfaz gráfica muy compleja aunque en sus inicios era algo lento

y consumía muchos recursos, pero en las últimas actualizaciones eso ha

cambiado, siendo una de las opciones más recomendables ya que es parte del

estándar de Java.

� SWT, creado por IBM para Eclipse. En un principio pensaron que Swing no era

adecuado para Eclipse por cual decidieron crear esta librería que,

posteriormente liberaron bajo una licencia de código abierto.

� QT Jambi, JavaFx, etc., existen multitud de librerías para la construcción de la

interfaz gráfica pero las más utilizadas son las anteriormente mencionadas.

101


Conclusiones

Tras finalizar el proyecto, podemos llegar a la conclusión que la actualización del software que

accede a una base de datos por otro puede ser menos traumática si se utilizan herramientas

como la desarrollada en el proyecto, que facilitan el desarrollo y proporcionan una estructura

para que el desarrollo del nuevo software sea más rápido.

A su vez, también hemos visto cómo un gestor de base de datos tiene una base de datos de sí

mismo, en el cual se almacenan todos los datos de las bases de datos que gestiona, tablas,

columnas, foreign key, constraints, etc. por lo que es fácil acceder a la metainformación de las

bases de datos gestionadas, que servirá como es nuestro caso de generar el código fuente,

para el acceso a ella, pero también puede servir para la migración de la base de datos a otro

gestor distinto, para informes, etc.

También hemos visto las bondades de las plantillas, exactamente StringTemplate, cómo nos

permiten una flexibilidad a la hora de generar nuestro resultado, permitiendo que con tan sólo

cambiar la plantilla se pueda generar una clase de un lenguaje totalmente distinto. Esta

característica puede ser usada en otras situaciones como puede ser el desarrollo web,

generación de informes, etc.

102


Referencias

[1] http://es.wikipedia.org/wiki/Metodolog%C3%ADa_de_desarrollo_de_software

(23/04/2014)

[2] http://es.wikipedia.org/wiki/Desarrollo_%C3%A1gil_de_software (23/04/2014)

[3]

http://commons.wikimedia.org/wiki/File:Esquema_general_de_una_metodologia_agil_para_d

esarrollo_de_software.png, Licencia Creative Commons

[4] http://www.proyectosagiles.org/ (26/03/2014)

[5] http://www.agilemanifesto.org/ (26/03/2014)

[6] http://www.proyectosagiles.org/que‐es‐Scrum (01/04/2014)

[7] https://www.java.com/es/download/whatis_java.jsp (15/09/2014)

[8] http://www.stringtemplate.org/ (10/10/2014)

[9] http://www.oracle.com/technetwork/es/database/express‐edition/overview/index.html

(05/05/2014)

[10] http://docs.oracle.com/cd/B19306_01/server.102/b14237/statviews_2094.htm

(05/05/2014)

[11] https://www.google.com/drive/ (05/05/2014)

[12] https://www.draw.io/ (05/05/21014)

[13] http://www.websequencediagrams.com (05/05/21014)

[14] https://eclipse.org/ (05/05/21014)

[15] http://www.oracle.com/technetwork/java/codeconvtoc‐136057.html (01/06/21014)

[16] http://docs.oracle.com/cd/B28359_01/java.111/b31226/datamap.htm#CHDCAECG

(07/05/2014)

[17] http://www.w3.org/TR/xmlschema‐2/#datatype (17/04/21014)

103

http://es.wikipedia.org/wiki/Metodolog%C3%ADa_de_desarrollo_de_software

http://es.wikipedia.org/wiki/Desarrollo_%C3%A1gil_de_software

http://commons.wikimedia.org/wiki/File:Esquema_general_de_una_metodologia_agil_para_desarrollo_de_software.png

http://commons.wikimedia.org/wiki/File:Esquema_general_de_una_metodologia_agil_para_desarrollo_de_software.png

http://www.proyectosagiles.org/

http://www.agilemanifesto.org/

http://www.proyectosagiles.org/que-es-scrum

https://www.java.com/es/download/whatis_java.jsp

http://www.stringtemplate.org/

http://www.oracle.com/technetwork/es/database/express-edition/overview/index.html

http://docs.oracle.com/cd/B19306_01/server.102/b14237/statviews_2094.htm

https://www.google.com/drive/

https://www.draw.io/

http://www.websequencediagrams.com/

http://www.oracle.com/technetwork/java/codeconvtoc-136057.html

http://docs.oracle.com/cd/B28359_01/java.111/b31226/datamap.htm#CHDCAECG

http://www.w3.org/TR/xmlschema-2/#datatype


104

[18]

http://www.w3.org/2001/sw/rdb2rdf/wiki/Mapping_SQL_datatypes_to_XML_Schema_dataty

pes (17/04/2014)

[19] http://dl.acm.org/citation.cfm?doid=12944.12948 (23/05/2015)

[20] http://www.cs.usfca.edu/parrt.html (23/05/2015)

Documents

Código para BBDD Oracle - Archivo Digital UPMoa.upm.es/39878/1/PFC_Javier_Blazquez_Chaves.pdf · Generador de Código para BBDD Oracle Resumen Las empresas tienen programas que acceden