Download Desarrollo de una Aplicación

Introducción al Desarrollo de
Aplicaciones con Oracle ADF
Ferran Garcia
[email protected]
Sales Consulting
Oracle Iberica, SRL
1
Introducción .................................................................................................................... 3
Objetivo ........................................................................................................................ 3
Oracle ADF .................................................................................................................. 3
Arquitectura General ................................................................................................ 3
Servicios de Negocio ................................................................................................ 6
Modelo...................................................................................................................... 7
Vista.......................................................................................................................... 8
Controlador............................................................................................................... 8
Desarrollo de una Aplicación ...................................................................................... 10
Prerrequisitos .............................................................................................................. 10
Arquitectura de la Aplicación Ejemplo. ..................................................................... 10
Creación de una Conexión a la base de datos............................................................. 10
Crear un nuevo WorkSpace........................................................................................ 13
Generación de los Servicios de Negocio y el Modelo................................................ 15
Generación del Controlador........................................................................................ 19
Generación de la Vista................................................................................................ 21
Test del Desarrollo...................................................................................................... 26
Conclusiones.................................................................................................................. 28
Desarrollo Java y Productividad................................................................................. 28
JDeveloper y ADF ...................................................................................................... 28
Gran variedad de desarrolladores ............................................................................... 28
Dudas, Comentarios y Feedback ................................................................................ 28
2
Introducción
Objetivo
El objetivo de este documento es introducir al lector en el conocimiento del nuevo
framework de desarrollo Oracle ADF, Application Developer Framework. Por esta
razón en el siguiente apartado, Oracle ADF, se realiza una descripción general de la
arquitectura y en siguiente capítulo se proporcionan los pasos para que el lector
desarrolle una pequeña aplicación de ejemplo.
Oracle ADF
Últimamente, la complejidad de los desarrollos Java ha aumentado de forma importante,
provocando una reducción importante en la productividad de los desarrolladores. Para
reducir esta complejidad y poder mejorar la productividad de los desarrollos es
importante analizar que razones provocan este incremento. Una de las razones es la
propio evolución de la tecnología que cada vez evoluciona de forma más rápida y hacia
arquitecturas más complejas. Otro motivo es el aumento de la necesidad de integración
de sistemas heterogéneos. Finalmente, hay que tener en cuenta una diversidad cada vez
mayor del tipo de desarrollos a realizar.
Por esta razón, al plantearnos una estrategia de desarrollo, tenemos que buscar una que
nos permita reducir la complejidad para garantizar una productividad adecuada. En
desarrollo, la complejidad se reduce mediante abstracciones que aíslan cada uno de los
componentes para que los detalles de su implementación no tengan que ser conocidos
por otros componentes.
Por otro lado, es importante que la estrategia de desarrollo adoptada sea estándar,
portable entre plataformas y no limite el tipo de tecnología a utilizar.
Teniendo en cuenta estos preceptos, Oracle ha diseñado su nuevo framework de
desarrollo Java con una arquitectura portable y basada en estándares.
Arquitectura General
ADF implementa el patrón Modelo Vista Controlador
En la actualidad, las aplicaciones Java tienden a utilizar el patrón de diseño ‘ModeloVista-Controlador’, o MVC, para controlar el flujo de pantallas.
Este patrón surge para solucionar los problemas que planteaba el modelo inicial de
desarrollo de aplicaciones en Internet, llamado Modelo JSP 1.
JSP
JSP
JSP
JSP
JSP
JSP
JSP
JSP
3
En este primer modelo, la navegación se definía mediante enlaces en cada una de las
pantallas, que generalmente se desarrollaban utilizando JSP. Así para modificar la
navegación era necesario editar cada JSP y modificar el enlace con otra página. En
aplicaciones complejas, este modelo requería mucho esfuerzo, tanto en desarrollo como
en mantenimiento. Para superar este modelo se empezó a implementar el Modelo JSP 2,
basado en el patrón de diseño MVC.
JSP
JSP
JSP
JSP
JSP
JSP
JSP
JSP
Controlador
Servlet
En este modelo, la lógica de la navegación se concentra en una clase controlador, que
generalmente se implementa mediante un servlet. Con este modelo las aplicaciones son
más fáciles de desarrollar y de mantener, ya que toda la lógica de navegación está
concentrada en un punto.
En el modelo MVC existen tres componentes importantes: la vista, el controlador y el
modelo. La vista es la interfaz de usuario y en aplicaciones Internet/Java generalmente
se implementa mediante JSP. La responsabilidad de la vista es mostrar la información al
usuario. El controlador tiene como responsabilidad recibir los inputs del usuario, que en
aplicaciones web son peticiones http, realizar las consultas o modificaciones necesarias
en la lógica de negocio y mostrar la siguiente vista al usuario. En las aplicaciones
web/java el controlador generalmente se implementa mediante un servlet. En el modelo
se implementan las funciones de negocio y los objetos de negocio. Las
responsabilidades de esta capa son realizar el mapeo de los objetos del dominio con las
tablas de la base de datos y implementar las funciones de negocio. Esta capa puede
desarrollarse utilizando una gran variedad de tecnologías, como por ejemplo EJB,
POJO’s, Web Services, TopLink o Business Components entre otros.
Vista
Controlador
JSP pages
Servlet HTML rendering
XML & Web Services
Swing
Input/update handling
Page flow
Process flow
Mostrar datos desde
Business logic
O/R mapping
SQL queries
Controlar cambios a
Modelo
4
Con base en este modelo han aparecido diversos frameworks de desarrollo. La idea
principal es implementar un controlador genérico que lea el flujo de la aplicación en un
fichero de configuración XML. El más conocido de estos frameworks es ‘Struts’, que se
trata de un framework open source de la Fundación Apache que se ha convertido en el
estándar del mercado. JDeveloper dispone de diversas herramientas para potenciar el
desarrollo en Struts, como por ejemplo un editor visual que permite editar el flujo de la
aplicación. Este editor visual, permite no solo desarrollar nuevas aplicaciones si no que
puede realizarse ingeniería inversa para obtener el modelo de una aplicación ya
existente.
Además de soporte a Struts, JDeveloper dispone de un framework de desarrollo llamado
ADF Controller que implementa esta arquitectura.
ADF implementa el estándar ‘Data Binding Facility’ (JSR 227)
Como hemos visto, para desarrollar una aplicación en base a este modelo, pueden
utilizarse diversas tecnologías e incluso pueden mezclarse en el mismo desarrollo. Esto
presenta un problema importante que añade complejidad al desarrollo; se debe a que
desde la vista y desde el controlador es necesario consultar y interactuar con los objetos
de negocio que se implementan en el modelo, esto provoca que los detalles de
implementación del modelo trasciendan a las otras capas. Esto puede significar que si el
modelo está implementado utilizando EJB y Web Services, la complejidad te esta
tecnología se expanda hasta la vista y el modelo.
Para evitar esto, la JSR 227 (Java Specification Request 227) ha estandarizado la ‘Data
Binding Facility’. Oracle ha tenido un peso importante en el proceso de definición de
este nuevo estándar. Mediante este estándar, se crea una abstracción sobre la capa de la
lógica que ahora pasaremos a llamar Servicios de Negocio. De esta manera, la capa del
modelo es una abstracción sobre los servicios de negocio, que son los que realmente
implementan el modelo. Esta abstracción oculta la implementación de los servicios de
negocio a las capas del controlador y de las vistas y solo muestra una abstracción de
estos servicios.
5
Vista
Swing/
Swing/
ADF
ADFJClient
JClient
JSP
JSP
ADF
ADFUIX
UIX
Controlador
Struts
Struts
Modelo
ADF
ADFModel
Model
Servicios de
Negocio
Web
Web
Services
Services
EJB
EJB
Session
Session
Beans
Beans
JSF
JSF
ADF
ADF
Controller
Controller
ADF
ADF
Business
Business
Components
Components
JavaBeans/
JavaBeans/
Other
Other
La capa del modelo o ADF Model, consta de unas clases Java que proporciona Oracle y
unos ficheros XML donde se describen los objetos y funciones de la capa de servicios
de negocio, de esta manera el controlador y las vistas solo tienen acceso a la abstracción
de estos servicios de negocio.
ADF consolida los distintos frameworks de desarrollo.
En el desarrollo de una aplicación que siga el modelo MVC existen importantes
decisiones tecnológicas que deben ser evaluadas. Para cada una de las tres capas existen
diversas opciones de desarrollo o frameworks. Por ejemplo, para el desarrollo de la vista
puede utilizarse JSP, JSF, UIX, Swing, ... Para el controlador podemos utilizar Struts o
ADF Controller y para los servicios de negocio podemos utilizar EJB, Web Services,
Top Link, POJO’s o Business Components entre otros. Cada una de las distintas
opciones de desarrollo aportan ventajas e inconvenientes, por lo que es tarea del
arquitecto Java seleccionar cual es la mejor aproximación para cada proyecto.
El framework ADF consolida todas estas aproximaciones integrando todos estos
frameworks de desarrollo en uno solo. Anteriormente a la aparición de ADF el
desarrollador debía escoger entre realizar el mismo la integración entre las distintas
capas, por ejemplo Top Link y Struts, o escoger un framework de desarrollo monolítico.
Entendemos por framework monolítico, uno basado en tecnología propietaria que cubre
todas las capas pero que no permite integración con otros frameworks e incluso a veces
no es portable entre servidores de aplicaciones. El nuevo ADF proporciona al
productividad de desarrollo, manteniendo abiertas las distintas opciones de frameworks.
Servicios de Negocio
Esta capa tiene la responsabilidad de encapsular los objetos y las funciones de negocio.
Aquí se realizan el mapeo entre objetos y tablas relaciones, se realizan validaciones,
funciones de negocio y se implementa el dominio de la lógica de negocio.
En esta versión JDeveloper y ADF han integrado Web Services, EJB, Top Link y
Business Componetes para realizar los servicios de negocio. Dentro de los desarrollos
ADF pueden escogerse cualquiera de estas tecnologías o pueden combinarse.
Los Web Services y los EJB son tecnologías estándar ampliamente extendidos.
JDeveloper proporciona editores de código, asistentes declarativos y editores visuales
para que cada desarrollador pueda escoger la aproximación que más le interese.
6
Top Link es un framework de Oracle para el desarrollo de la persistencia con la base de
datos. Al desarrollar en Top Link se parte de unos objetos de lógica de negocio y de
unas tablas en la base de datos para definir el mapeo entre ellos, que se almacena en un
fichero de configuración XML. En ejecución, el motor de Top Link, que son un
conjunto de clases Java, lee en el fichero de configuración la relación entre las tablas y
los objetos de negocio, que pueden ser objetos java tradicionales o EJB. Se trata de una
tecnología estándar que puede se puede desplegar en cualquier servidor de aplicaciones.
Los Business Componets son un framework de Oracle para el desarrollo de la lógica de
negocio. A diferencia de Top Link que solo se ocupa de la persistencia con la base de
datos, Business Componets está diseñado para desarrollar toda la lógica de negocio.
Con Business Components se diseña la persistencia entre las tablas y los objetos Java, la
presentación de los objetos de negocio y las funciones de negocio. La implementación
final de los objetos se puede realizar con objetos Java tradicionales o con EJB.
Top Link y Business Componets son dos alternativas de Oracle para el desarrollo de los
servicios de negocio. Generalmente, los desarrolladores con fuertes conocimientos de
SQL y tecnología relacional se siente más comandos con Business Componets; mientras
que los desarrolladores Java con experiencia en orientación a objetos prefieren la
aproximación de Top Link.
Modelo
Esta capa de software es una de las más innovadoras del nuevo ADF y es la responsable
de crear la abstracción sobre los servicios de negocio con la finalidad de esconder la
complejidad del mismo. Esta capa de software está diseñada siguiendo la nueva JSR
(Java Speficication Request) 277, en la que Oracle ha tenido un papel decisivo.
En esta capa existen dos tipos de componentes primordiales, los ADF Binding y los
ADF Data Control. Los últimos crean una abstracción sobre los objetos de los servicios
mediante clases Java y una descripción de los objetos de negocio en una hoja xml. Los
Data Binding presentan los servicios de negocio a las capas superiores en un formato
neutro independiente de la tecnología en que han sido desarrollados. Mediante esta
arquitectura se consigue que los detalles de implementación de los servicios de negocio
no se transmitan a las capas superiores.
7
Vista
La vista tiene la responsabilidad de mostrar la interfaz de usuario. A grandes rasgos,
existen dos grandes grupos de interfaz de usuario, los clientes complejos desarrollados
mediante tecnología swing y los clientes ligeros como navegadores web o navegadores
para dispositivos wireless. Los clientes más habituales son los navegadores web. El
termino cliente ligero define aquellos que están basados en una interfaz de usuario
HTML. Dadas las limitaciones de interactividad de la interfaz HTML, el termino cliente
complejo define a aquella interfaz de usuario que no está basada en HTML.
Esta capa se puede desarrollar mediante diversas opciones, como Swing, ADF JClient,
JSP, HTML, JSF y ADF UIX. Swing y ADF JClient son tecnologías para el desarrollo
de interfaz compleja. Los JSP son la tecnología más extendida para el desarrollo de
clientes web. Las nuevas JSF (JSR 127) son un estándar para el desarrollo de interfaz de
usuario en clientes ligeros. Finalmente, ADF UIX es un framework de Oracle para el
desarrollo de interfaz web. UIX ha sido desarrollado con el estándar JSF en mente, por
esta razón, en futuras versiones UIX será la implementación de Oracle del estándar JSF.
En esta nueva versión de JDeveloper, gracias a ADF, se ha incorporado una herramienta
visual de construcción de interfaz de usuario.
Controlador
Como ya se ha dicho, el controlador tiene como responsabilidad principal controlar el
flujo de la aplicación. La utilización de un controlador facilita el desarrollo, incrementa
la productividad; además hace que nuestros desarrollos sean más flexibles y fáciles de
mantener. Desde el controlador se realiza la interacción programática con el modelo
para acceder a las funciones y datos de negocio. También desde el controlador se redireccionan las distintas vistas al usuario.
Para el desarrollo del controlador, ADF proporciona dos opciones Struts y ADF
Controller. Struts es un framework de código abierto de la fundación Apache que es
ampliamente utilizado para el desarrollo de aplicaciones web.
Fuente: Fundación Apache
8
En el esquema superior puede verse la arquitectura de Struts. El núcleo de esta
arquitectura es un servlet llamado ActioServlet que es el encargado de recibir los inputs
(peticiones http) de los usuarios, actuar sobre el modelo o consultarlo y redirigir la vista
adecuada. La lógica de este comportamiento está implementada de forma declarativa en
el fichero de configuración struts-config.xml. Escribir este fichero de configuración es
una tarea laboriosa, razón por la cual Oracle proporciona un editor declarativo y uno de
visual para el desarrollo del flujo de la aplicación.
Además de Struts, Oracle también proporciona ADF Controller que es un framework
con una arquitectura muy similar y con las mismas herramientas de desarrollo.
9
Desarrollo de una Aplicación
En este apartado vamos a desarrollar una pequeña aplicación de ejemplo, con la
intención de introducir .al lector en la utilización de ADF. El desarrollo consta de una
sola pantalla con el mantenimiento de una tabla de empleados.
El desarrollo de la aplicación se divide en distintos pasos. En primer lugar
desarrollaremos los servicios de negocio a partir de las tablas almacenadas en la base de
datos. Luego implementaremos el modelo, el controlador y finalmente la interfaz de
usuario.
Prerrequisitos
Para el desarrollo de esta aplicación se va a utilizar Oracle JDeveloper 10g y el esquema
hr en una base de datos Oracle. El esquema hr está pre-cargado en las bases de datos
Oracle 9i y 10g. Por motivos de seguridad el esquema está bloqueado y es necesario
habilitarlo (ALTER USER "HR" ACCOUNT UNLOCK).
Arquitectura de la Aplicación Ejemplo.
Para desarrollar una aplicación de ejemplo, se ha escogido la siguiente combinación
tecnológica. Para los servicios de negocio utilizaremos Business Components, para el
controlador utilizaremos Struts y para la vista JSP.
Se ha escogido Business Componets para desarrollar la lógica de negocio por que con
muy poco esfuerzo nos permitirá desarrollar la lógica que necesitamos y podremos
concentrarnos, durante el desarrollo, en los aspectos del ADF que más interesan en este
documento.
Para implementar el controlador disponemos de dos opciones, ADF Controller y Struts.
Seleccionamos Struts por que está más extendido y se ha convertido en el estándar para
este tipo de aplicaciones.
Finalmente para el desarrollo de la vista se ha seleccionado JSP, por que al tratarse de
un estándar ampliamente extendido permitirá centrarse en la arquitectura de ADF sin
introducir nuevos conceptos.
Creación de una Conexión a la base de datos.
En este apartado se creará una conexión datos de desarrollo y JDeveloper,
posteriormente exploraremos algunas de las posibilidades que ofrece JDeveloper para
explorar las tablas de la base de datos.
En la ventana superior derecha seleccionar la pestaña ‘Connections’ para abrir el
‘Connections Navigator’.
10
En esta ventana podemos crear y navegar por múltiples tipos de conexiones. Para crear
una nueva conexión a la Base de datos, seleccionamos ‘Database’, hacemos un clic con
el botón derecho del ratón y seleccionamos ‘New Database Connection’.
Esto abrirá el asistente de creación de una nueva conexión a la base de datos. En la
primera pantalla del asistente pulsamos siguiente, en la segunda introducimos un
nombre a la conexión y pulsamos siguiente.
En el paso siguiente introducimos ‘hr’ como nombre de usuario y ‘hr’ como password y
seleccionamos le check-box ‘Deploy Password’.
11
En el paso 3 del asistente modificamos el nombre del host y presionamos en Siguiente.
En el paso 4 del asistente presionar en ‘Test’ para chequear la conexión; en caso de que
el resultado sea satisfactorio presionamos ‘Terminar’.
Ahora vamos a explorar la tablas ‘Jobs y ‘Employees’ que vamos a utilizar en el
desarrollo de la aplicación.
Abrimos la conexión en la ventana de ‘Connections Navigator’. En la parte superior
vemos los distintos tipos de datos o funciones almacenados en el esquema de base de
datos. En la parte inferior vemos la estructura del objeto seleccionado en la ventana
superior, en el caso de la imagen, se ha seleccionado la conexión y la ventana inferior
nos muestra el tipo de driver, el usuario y la url de la conexión.
Para continuar explorando este esquema de base de datos, expandimos ‘Tables’, con lo
que podremos ver las distintas tablas que conforman este esquema. Seleccionamos la
tabla ‘Employees’ y pulsamos el botón derecho del ‘mouse’. En el menú contextual
seleccionamos ‘Open’. En la ventana central de JDeveloper aparecerá el contenido de la
tabla seleccionada. En la parte inferior de la ventana aparecen dos pestañas, ‘Data’ y
‘Structure’. La pestaña de ‘Data’ nos permite consultar los datos que almacena la tabla,
se trata de una ventana de consulta, no de actualización. La pestaña ‘Structure’ nos
permite ver la estructura de la tabla, como en el caso anterior se trata de una ventana de
consulta que no permite actualizar la estructura de la tabla.
Para continuar explorando las posibilidades de JDeveloper seleccionamos la pestaña de
‘Structure’ en la parte inferior de la ventana y observamos que una de las filas de la base
de datos es ‘Job_Id’.
Volvemos a la ventana de ‘Connections Navigator’, seleccionamos la tabla ‘Employees’
y pulsamos el botón derecho del ‘mouse’. En el menú contextual esta vez seleccionamos
‘Edit’. JDeveloper abrirá un asistente que nos ayudará en la definición de la tabla de
12
departamentos. Seleccionando en el árbol derecho en ‘Foreign Keys’ nos aparece la
definición de las claves externas. Tal como puede verse en la imagen, la fila ‘Job_id’
tiene una clave externa con la clave primaria de la tabla ‘Jobs’.
Salimos de este editor pulsando ‘Cancelar’. Para finalizar utilizamos estas dos
herramientas para estudiar la tabla ‘Jobs’. Después de explorar la tabla de ‘Jobs’
cancelamos las modificaciones y volvemos a JDeveloper.
Crear un nuevo WorkSpace
Seleccionamos el menú FileÎNew. Se abre una ventana que nos muestra los artefactos
disponibles.
En el cuadro izquierdo seleccionamos General y en la ventana izquierda seleccionamos
‘Application Workspace’. Presionamos ‘Aceptar’. Aparece la ventana del asistente de
creación de ‘Application Workspace’.
Modificamos el nombre de la aplicación y el paquete donde se almacena el código.
13
En este punto hay que introducir un concepto interesante, el ‘Application Template’.
Como ya se ha venido explicando, las aplicaciones basadas en MVC, constan de
diversas capas para las que disponemos de diversas opciones de implementación. Cada
combinación de estas opciones de implementación es lo que denominamos un
‘Application Template’; por ejemplo, para nuestra aplicación el template estará formado
por Business Components, Struts y JSP. Si presionamos el botón ‘Manage Templates’
nos aparecerá una ventana que nos permite gestionar nuestros ‘Application Templates’.
Utilicemos esta ventana para inspeccionar los templates que incorpora JDeveloper por
defecto y como podemos modificarlos. Finalmente presionamos ‘Cancelar’ para volver
al asistente de creación del workspace.
En ‘Application Template’ seleccionamos ‘Web Application [Default]’. Finalmente,
presionamos ‘Aceptar’.
En el ‘Application Navigator’ podemos ver la estructura de proyectos que JDeveloper
ha creado para nuestro proyecto.
JDeveloper ha generado dos proyectos ‘Model’ y ‘ViewController’. En el primero
vamos a generar toda la lógica de negocio. En el segundo generaremos el controlador
del flujo de la aplicación y los JSP para la interfaz de usuario.
14
Generación de los Servicios de Negocio y el Modelo
En este apartado desarrollaremos los servios de negocio mediante el modelado UML, tal
como ya se ha dicho, la tecnología que utilizaremos será Business Components.
En el ‘Applications Navigator’ seleccionamos el proyecto ‘Model’ y hacemos un clic
con el botón derecho del ratón. Seleccionamos ‘New’, esto abrirá una ventana que nos
mostrará todos los artefactos disponibles.
Tal como puede verse en el diagrama de abajo, seleccionamos ‘Business Components
Diagram’ y presionamos ‘Aceptar’.
En la ventana que aparece, damos un nombre al diagrama y podemos dejar el paquete
por defecto. En el espacio central de JDeveloper aparece una ventana en blanco donde
podremos realizar el diagrama de clases para nuestros Business Components.
En la ventana izquierda abrimos el ‘Connections – Navigator’, expandimos la
conexiones a la base de datos. Seleccionamos y expandimos la conexión que hemos
creado en el apartado anterior.
15
Expandimos las tablas de la conexión con la que estamos trabajando. Seleccionamos las
tablas Employees y Jobs, las arrastramos sobre el diagrama y las soltamos.
Aparecerá una ventana para seleccionar el tipo de componentes con que queremos
mapear estas tablas. Podemos seleccionar ver todos los componentes disponibles o ver
solo los de el alcance tecnológico del proyecto. Esto tiene que ver con el concepto de
‘Application Template’ que hemos introducido en el apartado anterior. Si
seleccionamos ‘Projects Tecnologies’ veremos solo aquellas tecnologías que estén
dentro de nuestro ‘Application Template’; mientras que si seleccionamos ‘All
Technologies’ veremos todas las tecnologías disponibles.
Seleccionamos las tecnologías del proyecto y escogemos los únicos componentes
posibles, que son los ‘Business Components Entity Objects’.
16
Una vez finalizado este proceso, JDeveloper ha generado el diagrama y los
componentes Java y xml estándar que mapean estas tablas.
En la parte izquierda de la pantalla podemos ver el ‘Application Navigator’ y la ventana
‘Structure’, aquí podemos ver los artefactos que ha creado JDeveloper. Por ejemplo, en
el diagrama siguiente vemos que para el objeto Jobs ha creado una clase Java
‘JobsImpl.java’ y una hoja xml ‘Jobs.xml’.
Ahora vamos a generar el modelo de datos para estos objetos de negocio. Presionamos
el botón derecho del ratón sobre un área libre del diagrama y nos aparece un menú
contextual. Expandimos el menú ‘Generate’ y seleccionamos la opción ‘Default Data
Model Components for Diagram’.
17
En el asistente de creación del modelo de datos seleccionar todas las opciones por
defecto.
En la parte derecha de JDeveloper aparece la ventana ‘Data Control Palette’1. En esta
ventana pueden verse los componentes del ‘Model’ que son una abstracción de los que
habíamos generado en la capa de ‘Business Serevicess’, es decir la capa del Modelo.
Antes de seguir adelante, vamos a recopilar lo que hemos desarrollado hasta ahora y
como lo está tratando JDeveloper 10g. Lo primero que hemos desarrollado han sido los
servicios de negocio. En la ventana superior izquierda podemos ver estos servicios de
negocio. En la ventana inferior izquierda podemos ver como están desarrollados a nivel
de clases Java y hojas XML. Así, en la parte izquierda estamos viendo como han sido
implementados los servicios de negocio, podríamos decir que estamos viendo las
‘tripas’ de los servicios de negocio.
1
Si la ventana ‘Data Control Palete’ no se abre automáticamente, en el menú superior seleccionamos
‘View’ y luego ‘Data Control Palete’ o presionamos simultáneamente Ctrl+Mayúsculas+D.
18
Clientes Ricos
Ricos
Clientes Web
Controlador
Controlador
Modelo
Modelo
Servicios
Servicios de
de Negocio
Negocio
En la ventana superior derecha los que estamos viendo es el modelo que hemos
desarrollado en segundo lugar. Como puede verse este modelo contiene los mismos
datos (objetos) y funciones que los servicios de negocio, pero no se muestra como han
sido implementados. Dicho de otra forma, en la parte derecha estamos viendo una
abstracción de los servicios de negocio que podemos ver implementados en la parte
izquierda.
Generación del Controlador.
Ahora vamos a desarrollar la capa del controlador. Para ello vamos a la ventana
‘Applications Navigator’ y tal como puede verse en el esquema siguiente abrimos el
diagramador visual del flujo de la aplicación.
En la ventana central de JDeveloper nos aparece un diagrama en blanco. Aquí vamos a
dibujar el flujo de nuestra aplicación.
19
En la parte derecha de JDeveloper tenemos la ‘Component Palette’2, que muestra los
distintos componentes que podemos usar para desarrollar el diagrama de flujo de la
aplicación. Arrastramos una ‘Data Action’ y una ‘Page’ y las soltamos sobre el
diagrama en blanco. Les cambiamos los nombres por empleadosDA a la ‘Data Action’ y
empleados.jsp.
Los dos componentes aparecen con un signo de admiración. Esto significa que ninguno
de los dos está completamente definido. Hacemos doble clic sobre la página y se abrirá
la página jsp, mediante el menú FileÎSave All guardamos nuestro trabajo.
Mediante las pestañas de la ventana principal volvemos al diagrama visual de Struts,
más tarde volveremos al JSP.
En la paleta de componentes seleccionamos el ‘Forward’, hacemos un clic sobre la
‘Data Action’ y luego otro sobre la ‘Page’.
2
Si la ventana ‘Component Palete’ no se abre automáticamente, en el menú superior seleccionamos
‘View’ y luego ‘Component Palete’ o presionamos simultáneamente Ctrl+Mayúsculas+P.
20
Generación de la Vista.
Mediante las pestañas de la parte superior, volvemos a la página JSP para diseñar la
interfaz de usuario. En la ventana central le ponemos un nombre a la aplicación y le
damos formato de ‘Heading 1’ tal como puede verse en la imagen siguiente.
Añadimos un segundo subtítulo y esta vez le damos formato ‘Heading 2’.
Mediante las pestañas de la ventana superior derecha seleccionamos la ventana
‘Components’.
21
En la ‘Component Palette’ seleccionamos los elementos del tipo ‘CSS’. Estos
elementos son hojas de estilo que nos servirán para dar un aspecto determinado a la
aplicación. Presionamos en el estilo ‘JDeveloper’ y toda la aplicación cambia de estilo.
Ahora vamos a incorporar la edición de los empleados a la pantalla. Mediante las
pestañas de la ventana superior derecha volvemos a la ‘Data Controls Palette’.
Seleccionamos ‘EmployeesView1’ y ‘Drag and Drop as. Input Form’, tal como
podemos ver en el diagrama siguiente.
Seguidamente arrastramos y soltamos el componente en el medio de la pantalla JSP.
22
Ahora vamos a añadir una barra de botones de navegación para que el usuario pueda ver
los distintos empleados. Para ello volvemos a la ‘Data Controls Palette’ y
seleccionamos ‘EmployeesView1’ y ‘Drag and Drop as: Navigation Buttons’.
Arrastramos y soltamos este componente dentro del formulario que acabamos de
desarrollar.
Seguidamente, añadiremos un botón de ‘Commit’ y uno de ‘RollBack’ a la botonera.
Para ello seleccionamos una de las operaciones que aparecen en la ‘Data Control
Palette’ y seleccionamos ‘Drag and Drop as: Button’, luego arrastramos y soltamos el
componente al lado del último botón.
23
Ahora sustituimos el text area del atributo ‘JobId’ por una list box. Empezamos
situando el cursor sobre el text are a la derecha de la etiqueta JobId. Luego presionamos
‘Supr’.
La celda de la columna derecha aparece vacía. Volvemos a la ‘Data Control Palette’ y
seleccionamos el atributo JobId de EmployeesView1, también seleccionamos ‘Drag and
Drop as: List of Values’. Finalmente, lo arrastramos y lo soltamos sobre la celda vacía.
Ahora vamos a asociar la lista de valores con el objeto Jobs para que la lista de valores
aparezca llena con los distintos tipos de trabajo.
En la ventana inferior izquierda seleccionamos la pestaña UI Model. Aparece una lista
de los componentes que aparecen en el JSP que estamos diseñando. En la parte inferior
de esta lista seleccionamos ‘JobId1’, hacemos click con el botón derecho y en el menú
contextual seleccionamos ‘Edit’.
24
Aparece una ventana donde vamos a definir el comportamiento de la lista de valores. En
la ventana del source seleccionamos ‘JobsView1’ y en la del target ‘EmpoyeesView1’.
Si la lista del ‘LOV Source Iterator’ aparece vacía presionar el botón ‘New’ y
automáticamente aparecerá el valor adecuado.
Una vez definidos el origen y destino de la lista de valores, vamos a definir la relación
existente. En la parte inferior derecha presionar el botón ‘Add’. El origen y el destino de
la relación tienen que ser ‘JobId’.
Mediante la pestaña de ‘LOV Display Atributes’ y la lista de atributos disponibles
seleccionamos el atributo ‘JobTitle’.
25
Para finalizar, guardamos todo el trabajo mediante el menú ‘FileÎSave All’.
Test del Desarrollo.
Para terminar con el desarrollo de esta aplicación vamos a testar el resultado del
desarrollo. Volvemos al diagrama de flujo de la aplicación. Seleccionamos la ‘Data
Action’ y hacemos un clic con el botón derecho del ratón. Seleccionamos ‘Run’ y
JDeveloper abrirá automáticamente la aplicación en el browser por defecto del sistema
operativo.
Ahora JDeveloper arranca una instancia de OC4J que tiene embebida y despliega la
aplicación en ella. Si este despliegue es correcto inicializa el navegador de Internet y
llama a la aplicación. El resultado final es que podemos ejecutar la aplicación que
acabamos de desarrollar en el Internet Explorer o en el navegador que tengamos
configurado en JDeveloper.
26
27
Conclusiones
Desarrollo Java y Productividad
Hoy en día el mayor obstáculo a la productividad en los desarrollos Java es la
complejidad tecnológica. Para reducir esta complejidad tecnológica es necesario utilizar
un framework de desarrollo. Estos frameworks de desarrollo al reducir la complejidad
reducen la curva de aprendizaje y aumentan la productividad.
Por otro lado, las aplicaciones desarrolladas con un framework incrementan su calidad
debido a que están construidas en base a arquitecturas probadas y a que se reduce la
necesidad de codificar manualmente.
JDeveloper y ADF
Hasta ahora los desarrolladores Java que querían utilizar frameworks estándar se veían
en la obligación se integrar manualmente la tecnología utilizada para desarrollar la
lógica de negocio con la tecnología usada en el controlador o en la vista. Con ADF el
arquitecto puede escoger la arquitectura técnica que mejor se adapte al proyecto y al
equipo de desarrollo y no es necesario preocuparse de la integración entre las distintas
piezas.
Otro aspecto importante por lo que se refiere a ADF es la posibilidad de integrar
desarrollos heredados en diversas tecnologías Java como EJB o Business Components
en una sola arquitectura común. Por otro lado si disponemos de proyectos realizados en
base a cualquier tecnología e implementados como Web Services también es posible
integrarlos en la arquitectura.
Finalmente, cuando se selecciona un framework de desarrollo Java es importante que
este sea portable entre servidores de aplicaciones, bases de datos y sistemas operativos.
Gran variedad de desarrolladores
La popularización del desarrollo Java conlleva que estén empezando a desarrollar en
Java muchos especialistas funcionales que no disponen de unos conocimientos muy
profundos en J2EE. Esto unido a la creciente complejidad tecnológica hace que hoy sea
más crítico que nunca disponer de un framework. JDeveloper 10g y ADF simplifican el
desarrollo Java, de manera que son la alternativa ideal para desarrolladores con un perfil
muy funcional y pocos conocimientos Java y para desarrolladores Java con un perfil
muy técnico.
Dudas, Comentarios y Feedback
Desde Oracle agradeceremos que se nos hagan llegar las dudas del lector, los errores
que haya podido encontrar, así comentarios o propuestas de mejora.
Ferran Garcia
Senior Sales Consultant.
[email protected]
28