diseÑo de componente para el framework zathura … · transformación de bloques de datos de...
TRANSCRIPT
DISEÑO DE COMPONENTE PARA EL FRAMEWORK ZATHURA CODE QUE
PERMITA LA MIGRACIÓN DE CÓDIGO FUENTE DE FORMULARIOS CON
TECNOLOGÍA ORACLE FORMS 6I A COMPONENTES CON TECNOLOGÍA
JAVA ENTERPRISE EDITION
ALEX YAMIL MADERA VILLADA
JUAN CARLOS TORRES BALAGUERA
UNIVERSIDAD DE SAN BUENAVENTURA
FACULTAD DE INGENIERÍA
PROGRAMA DE INGENIERÍA DE SISTEMAS
SANTIAGO DE CALI, 2012
DISEÑO DE COMPONENTE PARA EL FRAMEWORK ZATHURA CODE QUE
PERMITA LA MIGRACIÓN DE CÓDIGO FUENTE DE FORMULARIOS CON
TECNOLOGÍA ORACLE FORMS 6I A COMPONENTES CON TECNOLOGÍA
JAVA ENTERPRISE EDITION
ALEX YAMIL MADERA VILLADA
JUAN CARLOS TORRES BALAGUERA
Informe de Investigación presentado
Para optar por el Titulo de
Ingeniero de Sistemas
Director
JOHAN BEJARANO
Ingeniero de Sistemas
UNIVERSIDAD DE SAN BUENAVENTURA
FACULTAD DE INGENIERÍA
PROGRAMA DE INGENIERÍA DE SISTEMAS
SANTIAGO DE CALI, 2012
AGRADECIMIENTOS
Primero que todo queremos agradecer a Dios por las oportunidades que nos ha
dado a lo largo de nuestras vidas. A nuestra familia, padres, hermanos los cuales
nos han brindado todo el apoyo necesario para realizar este proyecto de grado. A
nuestro director Johan Bejarano que dedicó gran parte de su tiempo en
asesorarnos y a la Universidad de San Buenaventura por la educación que nos
impartió.
TABLA DE CONTENIDO
1. INTRODUCCIÓN. ..................................................................................................................... 6
2. DEFINICIÓN DEL PROBLEMA. ............................................................................................ 7
3. OBJETIVO GENERAL. ............................................................................................................ 8
3.1. OBJETIVOS ESPECÍFICOS. ......................................................................................... 8
4. ALCANCE DEL PROYECTO. ................................................................................................ 9
5. MARCO TEÓRICO................................................................................................................. 10
5.1. ¿QUÉ ES UN LENGUAJE DE PROGRAMACIÓN? ..................................................... 10
5.2. LENGUAJE JAVA........................................................................................................... 11
5.3. LENGUAJE PL/SQL....................................................................................................... 12
5.4. FORMS 6i ........................................................................................................................ 13
5.4.1. FORM BUILDER (diseñador). .................................................................................. 14
5.4.2. FORM COMPILER (generador) ............................................................................... 14
5.4.3. FORM RUNTIME (ejecutor) ...................................................................................... 15
5.5. BLOQUE DE DATOS ..................................................................................................... 15
5.6. AST (Abstract Syntax Tree – Árbol de sintaxis abstracta) ....................................... 15
5.7. MIGRADOR DE CÓDIGO FUENTE. ........................................................................... 16
6. ESTADO DEL ARTE. ......................................................................................................... 17
6.1. MIGRADORES DE CÓDIGO FUENTE. ..................................................................... 17
6.1.1. PLSQL WIZARD. ........................................................................................................ 17
6.1.2. SWISSQL-ORACLE TO JAVA. ................................................................................ 18
6.1.3. ORINDABUILD™. ...................................................................................................... 19
6.1.4. In2j. ............................................................................................................................... 20
6.2. DESCRIPCIÓN DEL PROCESO DE MIGRACIÓN. ................................................. 22
6.3. DISEÑO ARQUITECTONICO DE LAS APLICACIONES GENERADAS CON
POR ZATHURA JAVA EE FORMS. ........................................................................................ 30
6.4. COMPONENTES DE LA ARQUITECTURA DEL MIGRADOR .............................. 31
7. RESULTADOS. ................................................................................................................... 36
8. CONCLUSIONES. .............................................................................................................. 38
10. BIBLIOGRAFÍA. .............................................................................................................. 40
TABLA DE ILUSTRACIONES.
Ilustración 1. Ventana de migración PL/SQL WIZARD. ........................................................... 17
Ilustración 2. Ventana de migración SWISSQL-ORACLE TO JAVA. .................................... 18
Ilustración 3. Ventana de migración ORINDABUILD™ ............................................................ 19
Ilustración 4. Ventana de migración INJ2 ................................................................................... 20
Ilustración 5. Ventana de migración IN2J. .................................................................................. 21
Ilustración 6. Forma en Oracle Form 6i. ..................................................................................... 24
Ilustración 7. Pantalla de la herramienta de Oracle Forms 6i ................................................. 25
Ilustración 8. Composición de la Forma en Oracle Forms 6i. ................................................ 26
Ilustración 9 Código Java donde se ubica la forma y se llama al generador. ...................... 27
Ilustración 10. Vista del método generate. ................................................................................. 27
Ilustración 11 Template para una clase en Java. ...................................................................... 28
Ilustración 12. Clase de Zathura que genera código a partir del modelo de datos .............. 29
Ilustración 13. Arquitectura de las aplicaciones generadas por Zathura Code. ................... 31
Ilustración 14. Diagrama de clases del migrador de código de bloque de datos de formas a
JAVA. ................................................................................................................................................ 33
Ilustración 15. Proyecto Zathura ................................................................................................. 36
Ilustración 16. Zathura Oracle Forms to Java Generator ......................................................... 37
1. INTRODUCCIÓN.
Debido al constante avance de la tecnología, las compañías deben ir
modernizando sus sistemas (software y hardware), es por eso que se hace
necesario realizar integraciones entre aplicaciones y así tener un sistema central y
robusto entre las herramientas que apoyan los procesos internos y externos de
negocio los cuales pueden ser fundamentales para que estas sean competitivas.
Este proyecto se basa en la idea del ingeniero Johan Bejarano, la cual nace a
partir de observar la necesidad de algunas empresas en realizar migraciones de
algunas aplicaciones desarrolladas en Oracle Forms 6i a una tecnología con
mayor capacidad de integración con otros sistemas, generando así la posibilidad
de agregar un nuevo modulo al proyecto zathura-code, desarrollado por la
Universidad de San Buenaventura, lo cual permitirá tener a las aplicaciones
generadas a partir del proceso de migración una arquitectura definida.
Existen diversas herramientas para la migración de código fuente Oracle Forms 6i
a Java, de las cuales se escogieron las herramientas ya investigadas en el
proyecto de grado Diseño de una arquitectura para la migración de código fuente
entre lenguajes de programación, realizado en la Universidad de San
Buenaventura Cali en el año 2004.
2. DEFINICIÓN DEL PROBLEMA.
En los últimos años el surgimiento de nuevos lenguajes de programación
orientados a objetos, como por ejemplo JAVA o .Net, que por su versatilidad,
eficiencia y portabilidad, han hecho que las empresas migren sus aplicaciones a
estos entornos, este proceso de migración de código fuente, en otras palabras es,
la traducción de código fuente de un lenguaje de programación a otro, es por eso
que uno de los retos que afrontan los desarrolladores al realizar un migrador es el
de mantener al máximo su funcionalidad inicial y tener en cuenta la equivalencia
entre los lenguajes de programación.
La problemática fue detectada por el Ingeniero Johan Bejarano que se ha
enfrentado en algunas empresas del sector las cuales tiene la necesidad de migrar
aplicaciones que se encuentran implementadas en Oracle Forms 6i a otro lenguaje
de programación, con el fin de agregar otras funcionalidades y permitir la
integración con otros sistemas y teniendo el inconveniente que en el mercado
existen algunas herramientas que podrían tener este fin pero surgen algunos
problemas como se describen a continuación: generación de código basura; No
se define una arquitectura y no se utilizan patrones en e código generado; además
para estas herramientas es necesario pagar su uso (licenciamiento). Entonces se
ha planteado implementar un sistema que permita la transformación de formularios
de Oracle Forms 6i de base de datos a la tecnología J2EE con el fin de suplir esta
necesidad.
3. OBJETIVO GENERAL.
Diseñar el prototipo de una herramienta que permita la migración de código fuente
ubicado en los bloques de datos de formas Oracle Forms, a código fuente con
tecnología Java Enterprise Edition, enmarcada dentro del proyecto Zathura
desarrollado por el LIDIS – Universidad de San Buenaventura Cali.
3.1. OBJETIVOS ESPECÍFICOS.
Diseñar un componente de software que se encargue de realizar la
transformación de bloques de datos de formas desarrolladas en Oracle
Forms 6i a la tecnología Java Enterprise Edition.
Implementar un componente que permita la transformación de una
formas de Oracle Forms 6i a una Java Server Page.
Diseñar un componente que permita realizar CRUD hacia la base de
datos implementados en un formulario de Oracle Forms 6i en la
tecnología Java Enterprise Edition
4. ALCANCE DEL PROYECTO.
En el alcance del proyecto se han definido los puntos que se considera son
relevantes y deben estar implementados y algunos que aunque son importantes
no fueron considerados como parte del alcance del proyecto debido a que se
pueden considerar muy complejos y fueron planteados como proyectos futuros a
implementar, los siguientes son los ítems que contemplara el proyecto:
Generará los CRUDs o gestión de mantenimiento de las tablas de una Base
de datos.
Generará artefactos de software cuyo diseño detallado aplica un conjunto
de patrones.
Generará una arquitectura de tres capas basada en la tecnología Web que
se maneja actualmente. (tomados del doc de zathura).
Se considera como funcionalidad principal la transformación de formularios
desarrollados en Oracle forms 6i a la tecnología Java Enterprise Edition.
De acuerdo a los objetivos definidos y al tiempo definido para la implementación
de la herramienta, los siguientes ítems hacen referencia a las cosas que no
contemplará el proyecto:
No se considera la implementación de un plugin para el IDE eclipse.
No esta considerado la transformación de formularios que no estén
relacionados con una base de datos Oracle, ya que estos realizan una
consulta estructurada e implementan lógica en PL/SQL, lo que hace parte
de proyectos definidos como futuros.
No hace parte del proyecto la migración de lógica de los formularios o de
funciones que se encuentren implementadas dentro de este, debido a que
esta funcionalidad se considera como un futuro proyecto a implementar.
5. MARCO TEÓRICO.
5.1. ¿QUÉ ES UN LENGUAJE DE PROGRAMACIÓN?
Un lenguaje de programación es un sistema notacional para describir
computaciones en una forma legible tanto para la maquina como para el ser
humano. Estos se componen de un conjunto de reglas sintácticas y semánticas
que permiten expresar instrucciones que luego serán interpretadas, los lenguajes
de programación se clasifican de forma amplia en tres niveles: lenguaje maquina,
lenguaje ensamblador y lenguaje de alto nivel1.
Un lenguaje maquina es el único que lenguaje de programación que entiende la
CPU, y cada tipo de CPU tiene su propio lenguaje maquina las instrucciones de
lenguaje maquina están codificadas en binario y son de muy bajo nivel.
En un nivel por encima del lenguaje maquina se encuentra el lenguaje
ensamblador, que permite la programación simbólica de más alto nivel. Este
lenguaje permite al programador escribir programas utilizando códigos simbólicos
de operación y no en secuencia de bits como el lenguaje anterior. Puesto que los
programas escritos en lenguaje ensamblador no son reconocidos por la CPU, es
necesario usar un ensamblador para traducir los programas escritos en lenguaje
ensamblador a sus equivalentes en lenguaje maquina.
Los lenguajes de alto nivel se desarrollan para permitir a los programadores
escribir los programas más rápido que cuando usan ensamblador. Puesto que los
programas escritos en lenguajes de alto nivel no son reconocidos por la CPU, es
necesario usar un compilador para traducirlos en sus equivalentes de lenguaje
ensamblador.
1 LOUDEN, Kenneth C. Lenguajes de Programación principios y práctica. Editorial THOMSON. Segunda
edición.2004. 635p.
5.2. LENGUAJE JAVA.
Es un lenguaje de programación orientado a objetos, desarrollado por James
Gosling y su equipo de Sun Microsystems California.
Java fue diseñado como un lenguaje orientado a objetos desde el principio. Los
objetos agrupan en estructuras encapsuladas tanto sus datos como los métodos
(o funciones) que manipulan esos datos. Java proporciona una colección de
clases para su uso en aplicaciones de red, que permiten abrir sockets y establecer
y aceptar conexiones con servidores o clientes remotos, facilitando así la creación
de aplicaciones distribuidas. Java es compilado, en la medida en que su código
fuente se transforma en una especie de código máquina, los bytecodes,
semejantes a las instrucciones de ensamblador.2
Por otra parte, es interpretado, ya que los bytecodes se pueden ejecutar
directamente sobre cualquier máquina a la cual se hayan portado el intérprete y el
sistema de ejecución en tiempo real (run-time). Java está diseñado para soportar
aplicaciones que serán ejecutadas en los más variados entornos de red, desde
Unix a Windows Nt, pasando por Mac y estaciones de trabajo, sobre arquitecturas
distintas y con sistemas operativos diversos. Para acomodar requisitos de
ejecución tan variopintos, el compilador de Java genera bytecodes: un formato
intermedio indiferente a la arquitectura diseñada para transportar el código
eficientemente a múltiples plataformas hardware y software. La indiferencia a la
arquitectura representa sólo una parte de su portabilidad. Además, Java especifica
los tamaños de sus tipos de datos básicos y el comportamiento de sus operadores
aritméticos, de manera que los programas son iguales en todas las plataformas.
Estas dos últimas características se conocen como la Máquina Virtual Java (JVM).
Java puede ser usado para crear dos tipos de programas: aplicaciones
independientes y applets.
2 DEITEL, Harvey M y DEITEL, Paul J. Cómo programar en Java. Editorial Pearson Prentice Hall. Quinta
edición. México 2004. 1268p
Las aplicaciones independientes se comportan como cualquier otro programa
escrito en cualquier lenguaje, como por ejemplo el navegador de Web HotJava,
escrito íntegramente en Java. Por su parte, las applets son pequeños programas
que aparecen embebidos en las páginas Web, como aparecen los gráficos o el
texto, pero con la capacidad de ejecutar acciones muy complejas, como animar
imágenes, establecer conexiones de red, presentar menús y cuadros de diálogo
para luego emprender acciones, etc.
5.3. LENGUAJE PL/SQL.
PL/SQL (Procedural Language/SQL) es un lenguaje de programación para
acceder a base de datos Oracle desde varios entornos. Está integrado con el
servidor de datos por lo que el código es procesado rápida y eficientemente.3
PL/SQL es un lenguaje procedimental que está incorporado en Oracle para
solventar las grandes limitaciones que se tienen con los editores SQL4, este
soporta todos los comandos de consulta y manipulación de datos, aportando al
lenguaje SQL estructuras de control y otros elementos propios de los lenguajes
procedimentales de tercera generación como por ejemplo:
Variables y tipos.
Estructuras de control.
Procedimientos y funciones.
Tipos de objetos y métodos.
Por esto se creó PL/SQL, puesto que combina la flexibilidad de SQL con la
potencia y configurabilidad de los 3 GL.
La mayor parte de las aplicaciones de BBDD utilizan un modelo cliente-servidor.
En la máquina cliente está el programa PL/SQL y envía peticiones de información
3 GABILLAUD, Jérome. Colección recursos informáticos Oracle 9i SQL, PL/SQL, SQL*Plus. Ediciones ENI. Mayo
2003. 435p. 4 PL/SQL es un lenguaje de cuarta generación, es decir el lenguaje describe lo que debe hacerse pero no
cómo hacerse. Los 4GL (lenguajes de cuarta generación) son bastante simples y tienen menos órdenes que
los de 3GL (como C ó Pascal).Sin embargo tienen limitaciones en cuanto al control de la secuencia de
ejecución de instrucciones, el uso de variables, la modularidad, gestión de errores
a un servidor de base de datos. Las peticiones se llevan a cabo mediante SQL. Se
enviaría una petición por la red por cada orden SQL. Para evitar esta congestión
de tráfico se empaquetan varias órdenes SQL en un bloque PL/SQL.
Con esto aumenta la velocidad de la aplicación. PL/SQL no es un lenguaje creado
para interactuar con el usuario, sino para trabajar con la base de datos, por lo que
no dispone de sentencias para capturar datos por el teclado o visualizar en
pantalla.
La unidad básica en PL/SQL es el bloque. Todos los programas PL/SQL están
compuestos por bloques que pueden estar situados de manera secuencial (uno
tras otro) o anidados. Cada bloque realiza una unidad lógica de trabajo en el
programa, estando así separadas unas tareas de otras. Está constituido por un
conjunto de declaraciones, instrucciones y mecanismos de gestión de errores y
excepciones.
Una vez visto las principales definiciones de los lenguajes de programación como
JAVA y PL/SQL pasamos a definir las herramientas del cual se basa este
proyecto.
.
5.4. FORMS 6i
Forms es un componente que forma parte del conjunto de productos Developer
2000 y es lo que Oracle utiliza en el campo de las GUI (Interfaces Gráficas de
Usuario) para diseñar pantallas las cuales permiten crear, borrar y modificar datos
de la Base de Datos mediante el lenguaje PL/SQL, de una forma rápida y
eficiente.5
Esta es una herramienta de desarrollo que permite construir aplicaciones tipo
cliente-servidor6, y que usa la base de datos de Oracle. Algunas de las
5 Oracle FORMS. Disponible en: http://www.oracle.com/technetwork/developer-
tools/forms/overview/index.html. [Fecha de consulta: mayo 22 de 2011.] 6 Se refiere a un modelo de diseño que se puede pensar como aplicaciones que se ejecutan en una red de
área local (LAN). En términos muy básicos, puede describir que el cliente solicita y que el servidor ejecuta o de alguna forma realiza las solicitudes de trabajo.
características que podemos encontrar en las aplicaciones con Oracle Forms son
las siguientes:
Introducir, actualizar, borrar y consultar datos almacenados en la base de
datos.
Presentar datos utilizando texto, imágenes y controles VBX (Visual Basic
Extensión).
Controlar formularios a través de varias ventanas.
Realizar transacciones en la Base de Datos.
Acceder a menús integrados.
Enviar datos directamente a Oracle Reports.
Forms se compone básicamente de tres partes.
5.4.1. FORM BUILDER (diseñador).
Es la que se encarga del diseño y la definición de los formularios, menús y
librerías de las aplicaciones. Se compone de:
FORMULARIO: Está formado por objetos y líneas de código. En él se
diseñan las pantallas y ventanas para trabajar con los datos de la Base de
Datos. Están los objetos y los datos de la Base de Datos que un usuario
puede visualizar y utilizar.
MENÚ: El menú puede estar compuesto por una jerarquía de menús que
forman parte de la aplicación.
LIBRERÍA: Colección de procedimientos y funciones, unidades de
programa PL/SQL, que se pueden utilizar dentro de la aplicación o ser
llamadas desde otro módulo.
5.4.2. FORM COMPILER (generador)
Se generan las aplicaciones construidas en el Form Builder, convirtiéndolas en
ejecutables que puede manejar el programa de ejecución.
5.4.3. FORM RUNTIME (ejecutor)
Se usa para ejecutar las aplicaciones generadas por el generador de aplicaciones
Form Compiler. El Form Runtime crea un acceso directo al ejecutable, así es
posible ejecutar la aplicación sin entrar en el Form Builder.
5.5. BLOQUE DE DATOS
Contiene información heterogénea pero conceptualmente relacionada entre sí. Un
bloque es una interconexión entre el formulario y una única tabla de la base de
datos, es por eso que debe contener unos objetos adicionales que permitan
acceder al contenido de dicha tabla. La tabla a la que está conectada el bloque se
le denomina tabla base.7
De acuerdo a su relación con las tablas los bloques pueden ser de dos tipos:
Bloque de control: en él está la información no relacionada directamente
con la base de datos.
Bloque de tabla base: Contiene ítems relacionados con una tabla de la base
de datos y también ítems de control, es decir, no relacionados con ninguna
tabla, como por ejemplo los botones.
5.6. AST (Abstract Syntax Tree – Árbol de sintaxis abstracta)
Básicamente un árbol sintáctico se corresponde con una sentencia, obedece a
una gramática, y constituye una representación que se utiliza para describir el
proceso de derivación de dicha sentencia. La raíz del árbol es el axioma inicial.
Como nodos internos del árbol, se sitúan los elementos no terminales de las
reglas de producción que vayamos aplicando, y cada uno de ellos poseerá tantos
hijos como símbolos existan en la parte derecha de la regla aplicada.
7 MARQUÉS, Andrés. ALIAGA, José. GARCIA, Salvador. QUINTANA, Gregorio. Sql y Desarrollo de aplicaciones
en oracle 8. Publicacions de la Universitat Jaume I. 2001. 159p .
Una secuencia de derivaciones con origen en el axioma inicial y destino en la
cadena a reconocer constituye una representación del árbol sintáctico. A cada
paso de derivación se añade un nuevo trozo del árbol, de forma que al comienzo
del proceso se parte de un árbol que sólo tiene la raíz (el axioma inicial), al igual
que las derivaciones parten también del axioma inicial. De esta forma, en cada
derivación se selecciona un nodo hoja del árbol que se está formando y se le
añaden sus hijos. En cada paso, las hojas del árbol que se va construyendo
constituyen la forma sentencial por la que fluye la derivación. Por otro lado, la
secuencia de derivaciones no sólo representa a un árbol sintáctico, sino que
también da información de en qué orden se han ido aplicando las reglas de
producción.
Una vez abordado los temas principales que se relacionan con un migrador de
código fuente pasamos a definir qué es un migrador de código fuente y cuales
herramientas están en el mercado actualmente.
5.7. MIGRADOR DE CÓDIGO FUENTE.
Un migrador de código fuente, es una herramienta, que permite homologar
aplicaciones hechas en un lenguaje de programación a otro lenguaje diferente sin
que esta aplicación pierda su funcionalidad además esta herramienta permite
ahorrar tiempo de desarrollo.
6. ESTADO DEL ARTE.
6.1. MIGRADORES DE CÓDIGO FUENTE.
Entre las aplicaciones/herramientas de migración de código fuente a Java para el
lenguaje PL/SQL, se encuentran las listadas a continuación.
6.1.1. PLSQL WIZARD.
Es un software que permite la migración del código fuente PL/SQL a Java,
distribuido por informatikatelier. Esta herramienta tiene una interface muy fácil de
utilizar para el usuario. La forma de utilizar este software es pegando el código
fuente de PL/SQL y la herramienta lo convierte a código fuente Java, mostrando el
resultado final en una ventana al lado derecho del código fuente de PL/SQL, lo
que se puede intuir que para algunas aplicaciones, como suele ser muy frecuente
en PL/SQL, en donde un paquete tiene muchas de líneas de código, es posible
que se generen problemas con el software.
Una vista de esta herramienta se muestra a continuación:
Ilustración 1. Ventana de migración PL/SQL WIZARD.
6.1.2. SWISSQL-ORACLE TO JAVA.8
Esta herramienta al igual que la anterior permite la migración de código fuente
PL/SQL a Java, esta herramienta es distribuida por Adventnet. Para realizar una
migración de código fuente se debe realizar de la siguiente forma: se debe
adicionar el fichero donde se encuentre el código PL/SQL luego esta herramienta
se encarga de leer el contenido y realizar la migración y este resultado es
almacenado en archivos (clases) java.
Una vista de esta herramienta se muestra a continuación:
Ilustración 2. Ventana de migración SWISSQL-ORACLE TO JAVA.
8 http://www.swissql.com/products/oracle-to-java/oracle-to-java.html
6.1.3. ORINDABUILD™9.
Al igual que las otras, permite la migración de código fuente de PL/SQL a Java y
es distribuida por Orinda Software. Para realizar una migración con esta
herramienta, es necesario primero establecer una conexión a la base de datos, el
siguiente paso a seguir es ubicar los procedimientos o funciones (código fuente),
después de seleccionar el código fuente la herramienta se encarga de leer y
genera el equivalente en java, con sus respectivas clases .java.
Una vista de esta herramienta se muestra a continuación:
Ilustración 3. Ventana de migración ORINDABUILD™
9 http://www.orindasoft.com/public/features.php4
6.1.4. In2j.10
Quien se encarga de distribuir esta herramienta es Quintessence System. Para
realizar una migración de un código fuente desde PL/SQL a Java, lo primero que
se debe realizar es ubicar el archivo con los fuentes que desean ser migrados, una
vez se tenga seleccionado el fichero que se desea migrar, la herramienta
comienza a generar su equivalente en java, después en otra pantalla aparece un
reporte de la migración en la cual se especifica la ubicación de los fuentes
resultantes, en sus respectivas clases .java.
Una vista de esta herramienta se muestra a continuación:
Ilustración 4. Ventana de migración INJ2
10
http://www.quintessencesystems.com/in2j.php
Ilustración 5. Ventana de migración IN2J.
Estas herramientas descritas son las más comerciales que se pueden encontrar
en el mercado en cuanto a la migración de código fuente PL/SQL a Java, como
son herramientas que tienen un costo o en algunos casos están descontinuadas,
dejan un espacio en la investigación y desarrollo de las herramientas para la
migración de código fuente entre lenguajes de programación, en nuestro caso
FORMS to IceFaces.
6.2. DESCRIPCIÓN DEL PROCESO DE MIGRACIÓN.
En algunas de las herramientas que existen en el mercado permiten realizar esta
funcionalidad, pero tienen algunos inconvenientes como; no definen una buena
arquitectura del código generado, genera mucho código basura, el costos de
mantenimiento y modificación es alto y por ultimo el software es licenciado. De
acuerdo con los inconvenientes encontrados descritos anteriormente, se ha
realizado la pregunta, ¿Es posible realizar una herramienta que permita la
migración de Formulario de Oracle Forms, con una arquitectura definida y la
optimización del código generado?
Al planteamiento de esta pregunta se puede generar la siguiente hipótesis: Definir
una herramienta que no genere código basura, que sea de código abierto y defina
una arquitectura con patrones de diseño. Además se ha planteado la posibilidad
que sea un del framework de zathura-code, con el fin de reutilizar algunos de los
componentes ya implementados y tener así una herramienta mas robusta y de
mayor funcionalidad y lo mas importante que este en la comunidad opensources
En el caso de usar el framework de zathura el lenguaje de programación para el
proyecto que se debería de utilizar es Java. Con la hipótesis ya definida el
siguiente paso fue validar que tan viable era implementar una aplicación con estas
características, por lo que se entro en detalle sobre la aplicación zathura y
encontramos que esta genera un código con una arquitectura en capas y con
patrones de diseños, además que permite la integración de nuevos utilidades y la
reutilización de algunos componentes del mismo, teniendo esta herramienta como
parte de la solución nos enfocamos en dar solución a la transformación de los
formularios de Oracle forms6i, en la que se dio como posible solución utilizar
templates de velocity que permitan definir una estructura y equivalencia entre
datos de Oracle y Java, también , PL/SQL y Extensible Markup Langague XML.
Con el fin dar a conocer el proceso que se realiza al momento de migrar un
formulario de Oracle Forms a Java, a continuación se describe el proceso y la
interacción de algunas clases.
Se tiene como entrada del proceso el formulario de Oracle Forms, al cual se desea
realizar una migración de plataforma, el actor principal es la herramienta que se ha
implementado encargada de realizar la migración de las formas de Oracle forms a
JSP, como segundo actor, esta la herramienta de Zathura code que es utilizada
para la generación de las clases de persistencia y acceso a datos.
El proceso que se realiza para una migración consta como primera fase
seleccionar el formulario de Oracle forms como elemento de entrada, a partir de
este se definen las JSPs con su respectivo bean que se construyen por cada vista
que tenga definida el formulario, la transformación se realiza por medio de
templates de velocity que permite definir un estilo y algunas variables que son
remplazadas de acuerdo a las características que tenga el formulario. Lo mismo
se realiza para los objetos de dominio que en este caso ya que un bloque de base
de datos hace referencia a una tabla específica se utiliza la misma tecnología de
template para realizar las clases de dominio Java, con los objetos de dominio
creados, se puede hacer uso de zathura-code que desde sus primeras versiones
funciona suministrándole los objetos de dominio y este dando como resultado una
arquitectura definida, clases de persistencia con sus respectivos métodos.
La clase principal de la herramienta de migración de formularios de Oracle forms a
la tecnología Java Enterprise Edition es ZathuraOracle2JeeGenerator la cual
implementa de la Interface IZathuraOracle2JeeGenerator y su método principal
generate en el cual se realiza la transformación de JSPs, bean de la vista y las
clases de dominio (Pojos), de acuerdo como se dijo antes por medio de un fichero
.vm equivalente a un template para cada una de los elementos a construir son
remplazado por valores equivalentes al formulario en el estilo de cada template,
existe un template para cada una de los elementos construidos, después es
instanciado el componente zathura-code, por medio de la clase IZathuraGenerator
y del cual se invoca el método toGenerate el cual cuando es ejecutado y esta bien
configurado se encarga de la generación de la persistencia y comunicación entre
la vista y los objetos de dominio.
La generación de clases se realiza por medio de templates que permiten
establecer la estructura de una clase y definir variables que después en el
momento de ser invocados se puede remplazar esas variables por valores
específicos.
A continuación mostramos el proceso que se realiza desde que se obtiene una
forma de Oracle Forms hasta que se hace la migración a Java en él se muestran
las clases principales que interactúan en este proceso.
A continuación se muestra las partes más importantes dentro del proceso de
migración de código fuente:
Se tiene la forma desarrollada en Oracle Forms 6i, en este caso tenemos una
ventana que tiene la descripción de un cliente.
Ilustración 6. Forma en Oracle Form 6i.
A continuación observamos como se compone la forma dentro de la herramienta
de Oracle Forms 6i, en la parte derecha se encuentra la parte grafica y en la parte
izquierda la definición de un bloque de dato de base de datos, que en este caso se
llama y hace referencia a una tabla clientes de la base de datos, con la descripción
de sus elementos.
Ilustración 7. Pantalla de la herramienta de Oracle Forms 6i
Con mas detalle observamos como se compone la forma y en nuestro caso lo que
nos importa el data blocks donde cada ítem corresponde a una columna dentro de
la tabla en la base de datos.
Ilustración 8. Composición de la Forma en Oracle Forms 6i.
Una vez que se tiene la forma que se desea migrar es necesario saber la
ubicación donde se encuentra y el destino donde va a quedar el código migrado.
El método generate es quien empieza todo el proceso de migración.
Ilustración 9 Código Java donde se ubica la forma y se llama al generador.
Acá se muestra la implementación del método generate, en él se hace la
equivalencia entre los lenguajes y se llama a Zathura en el método toGenerate.
}
Ilustración 10. Vista del método generate.
En la siguiente imagen se puede observar la forma en que esta implementado el
template para la definición de los Pojos, en el cual se definen algunas constantes y
variables que son remplazados por los valores específicos que se obtienen del
bloque de datos, referente a una tabla de la base de datos
Ilustración 11 Template para una clase en Java.
Clase del proyecto Zathura que crea el acceso a datos.
Ilustración 12. Clase de Zathura que genera código a partir del modelo de
datos
6.3. DISEÑO ARQUITECTONICO DE LAS APLICACIONES GENERADAS
CON ZATHURA JAVA EE FORMS.
.
La arquitectura implementada para la migración de Formulario de Oracle Forms
reutiliza los componentes de negocio de Zathura JEE WEB Centric como Business
Delegate, Lógica de Negocio, POJOs, DAO y Entity Manager Helper vistos en el
capítulo 6.4 de la documentación de Zathura Code, es por esto que en este
capítulo solo se nombraran los componentes de presentación que se muestran a
continuación:
Ilustración 13. Arquitectura de las aplicaciones generadas por Zathura Code.
6.4. COMPONENTES DE LA ARQUITECTURA DEL MIGRADOR
La herramienta se encarga de leer los data blocks definidos en la aplicación de
Oracle Forms, genera la capa de presentación y los transforma a JSP, creando así
la configuración del fichero xml de ice-faces y la lógica del BackEndBean que
llama al BusinessDelegate, este componente es creado por la aplicación zathura,
por lo cual se hace uso de este, en la generación de este componente y los demás
para el acceso a datos.
En el diagrama a continuación se observan las clases principales del componente
de zathura Forms y una descripción del componente de Zathura Forms que
permite la migración de las Formas de Oracle a iceFaces, en el que interactúan los
proyectos engine y generator.
Ilustración 14. Diagrama de clases del migrador de código de bloque de
datos de formas a JAVA.
IZathuraOracle2JeeGenerator: Interface que define los métodos públicos
que permitirán la transformación de un formulario de oracle a jsps en la
plataforma J2EE
ZathuraGeneratorForm: Clase que implementa
IZathuraOracle2JeeGenerator, permite crear los objetos de dominio a partir
de un bloque de datos de entrada de Oracle Forms y por medio de
templates de velocity se remplazan las propiedades de las formas por
equivalencias en código JAVA. Hace uso de la herramienta de Zathura para
la generación del acceso a datos (DAOs) y la configuración del entorno
para generar una aplicación web.
GeneratorUtil: Se encarga de definir estándares (equivalencias) para el
proceso de transformación de los formularios a Java. Esta clase brinda
utilidades comunes en todo el proceso de transformación con el fin de que
pueda ser accedida desde cualquier punto del proceso de transformación.
GenerationModel: Clase de dominio en la que se asignan cada uno de los
elementos construidos en el proceso de transformación de los formularios
de Oracle a Java.
IMetadataReader: Interface que se utiliza para consultar los metadatos del
módulo de bloque de datos devolviendo una lista con varios mapas. Cada
mapa contiene un par clave-valor que incluyen módulos de información y la
información de los bloques Artículos
MetadataReader: Esta clase se utiliza para leer un Metadato de una forma
en Oracle utilizando la librería JDAPI11.
MetadataReaderFactory: Permite crear una instancia del Metadatareader.
ModuleMetadata: Clase de dominio en la que se asignan cada uno de los
elementos del formulario de Oracle.
ZathuraGeneratorForm: Clase principal la cual se encarga de invocar los
componentes de transformación de los formularios Oralce a código Java.
11
Java Design-time API (JDAPI) es una conjunto de clases Java facilitadas por Oracle que nos permiten cargar, crear, manipular y compilar formularios (.fmb), menús (*.mmb), librerías PL/SQL (.pll) y librerías de objetos (.olb).
FormUtility: Obtiene cada uno de los elementos del formulario.
7. RESULTADOS.
Para realizar una herramienta que permita la migración de código fuente es
necesario tener claro algunos conceptos implícitos durante este proceso, por eso
se realiza una pequeña descripción de qué es un lenguaje de programación, así
como de los lenguajes de programación Java y PL/SQL. También es necesario
mostrar el contexto en el cual se va a desenvolver este proyecto, por lo que se
realiza una introducción y se listan algunas herramientas de migración de código
fuente.
La idea principal de Zathura es permitir a los desarrolladores elegir entre
diferentes arquitecturas basándose en estándares abiertos y patrones de diseño
JEE. Lo que se espera es poder agregar nuevos módulos que permitirán tener una
herramienta más robusta y lo más importante OpenSource (Código abierto).
Se ha encaminado una problemática con el futuro de esta herramienta, puesto
que esta se encuentra en un punto estable lo que permite decir que está
cumpliendo a cabalidad con su objetivo, pero como lo presupuestado para esta
herramienta no es solo para desarrollos web, se han planeado implementar
algunos módulos que permitirán generar vistas en otros lenguajes tales como
GWT (ya implementado), migración de código PL/SQL a java, conversión de
formularios Oracle a SWT y Icefaces.
Para centralizar un poco la problemática o mejor la estructura del futuro de
Zathura se tiene un diagrama el cual permite visualizar donde se encuentra
ubicado este proyecto.
Zathura Web Centric generator
Gwt Generator
Road Map Zathura Oracle Forms to Java
Generator
Ilustración 15. Proyecto Zathura
El proyecto a realizar se encuentra en el apartado 3 de la figura 1 (Zathura Oracle
Forms to Java Generator), pero este modulo abarca otros tres puntos los cuales
se describen a continuación:
Analizando el detalle de este apartado se puede observar los módulos en los que
se divide, del cual el proyecto se va a encargar de Forms to IceFaces.
Para la migración de código fuente nos basamos en el proyecto de grado realizado
en la Universidad de San Buenaventura – Cali, Diseño de una arquitectura para la
migración de código fuente entre lenguajes de programación, hecha por los
estudiantes Danny Gerardo Van Arcken y Ligia Lorena Varela Rodríguez en el año
2004 y en algunas referencias bibliográficas.
Zathura Oracle Forms to Java Generator
PL/SQL to JAVA
- Triggers
- Programas de Unidad.
Forms
to
IceFaces
Forms
to
SWT
Ilustración 16. Zathura Oracle Forms to Java Generator
8. CONCLUSIONES.
La tecnología esta en constante cambio, la web ha sido uno de los avances
más importantes de la informática, es por eso que el desarrollo de software
ha respondido a sacar el mayor provecho de la Web, al pasar a una
arquitectura basada en Web.
Mediante la creación de componentes de generación de código es posible
disminuir los tiempos de desarrollo de software. Al iniciar un proyecto no es
necesario construir sus componentes desde cero; esto conlleva a disminuir
costos en el desarrollo de software para las empresas.
Es importante saber que existen equivalencias entre lenguajes de
programación, es por eso que se pueden hacer modelos que permitan
migrar de un leguaje a otro basándose en la gramática para homologar la
lógica entre ellos.
El uso de java para el desarrollo de aplicaciones hacen que estas puedan
crecer y ajustarse a la medida en que crece el negocio, y estos programas
pueden funcionar en navegadores web y en servicios web.
9. PROYECTOS FUTUROS.
De acuerdo a las utilidades agregadas hasta el momento al proyecto zathura se
tienen algunas ideas de otras utilidades a implementar para que se tenga una
herramienta más robusta para la comunidad, de las cuales se proponen que se
tenga en cuenta como las próximas utilidades para el zathura:
Plug-in de eclipse para la migración de formularios a ice-Faces, debido a
que este punto no estaba sobre el alcance del proyecto.
FORMS TO STANDARD WIDGET TOOLKIT (SWT).
Zathura Oracle Forms to Java Generator, PL/SQL TO JAVA PROGRAMS
UNIT: este apartado consiste en migrar la lógica que tenga un formulario de
Oracle a Java.
10. BIBLIOGRAFÍA.
1. LOUDEN, Kenneth C. Lenguajes de Programación principios y práctica.
Editorial THOMSON. Segunda edición.2004. 635p.
2. VAN ARCKEN, Danny Gerardo y VARELA RODRÍGUEZ, Ligia Lorena.
Diseño de una arquitectura para la migración de código fuente entre
lenguajes de programación. Cali, 2004, 148p. Trabajo de grado.
Universidad de San Buenaventura.
3. DEITEL, Harvey M y DEITEL, Paul J. Cómo programar en Java. Editorial
Pearson Prentice Hall. Quinta edición. México 2004. 1268p
4. GABILLAUD, Jérome. Colección recursos informáticos Oracle 9i SQL,
PL/SQL, SQL*Plus. Ediciones ENI. Mayo 2003. 435p.
5. Definición PL/SQL, disponible en:
http://www.oracle.com/technetwork/database/features/plsql/index.html
[Fecha última consulta: 06 de Enero de 2012].
6. Oracle FORMS, disponible en: http://www.oracle.com/technetwork/developer-
tools/forms/overview/index.html [Fecha de consulta: mayo 22 de 2011.]
7. Definición de cliente/servidor: KENDALL, Kenneth y KENDALL, Julie. Análisis
y diseño de sistemas. Sexta Edicion. Perarson Educación. Mexico 2004.
8. MARQUÉS, Andrés. ALIAGA, José. GARCIA, Salvador. QUINTANA,
Gregorio. Sql y Desarrollo de aplicaciones en oracle 8. Publicacions de la
Universitat Jaume I. 2001. 159p.
9. SWISSQL-ORACLE TO JAVA, disponible en:
http://www.swissql.com/products/oracle-to-java/oracle-to-java.html [Fecha
última consulta: 06 de Enero de 2012].
10. ORINDABUILD™, disponible en:
http://www.orindasoft.com/public/features.php4 [Fecha última consulta: 06 de
Enero de 2012].
11. In2j, disponible en: http://www.quintessencesystems.com/in2j.php [Fecha
última consulta: 06 de Enero de 2012].
12. Definición de JDAPI: http://www.dbadvice.be/index.php/en/oracle-forms
[Fecha última consulta 26 de Diciembre de 2011].