Apartado 1: Despliegue y ejecución de la
aplicación CustomerApp
- Arrancar
el servidor J2EE.
- Configurar el gestor de base de datos,
derby
que utilizaremos en esta práctica. Para ello, seguir las
instrucciones en Guía
del gestor de Base de datos Derby.
- Crear la aplicación J2EE:
CustomerApp
- Arrancar el
deploytool,
para ello ejecutad:$ deploytool &
- Seleccionar
File -> New
-> Application.
- Clic en
Browse:
- Seleccionar el directorio en el que
habéis descomprimido los fuentes de la
aplicación, por ejemplo:
${HOME}/swc/practicasj2ee/customer/.
- Introducir
CustomerApp.ear,
en el campo File Name.
- Clic en
New Application.
- Clic en
Ok.
- Comprobar que el fichero
CustomerApp.ear
existe en directorio indicado en el paso b.
- Crear el Enterprise Bean:
CustomerBean
- Codificar las interfaces del bean y las clases:
- En este caso se proporciona el
código dentro del directorio
customer/src,
por lo que sólo deberéis editarlo y comprenderlo:
Customer.java:
Interfaz remota ("remote interface") que define los métodos
de negocio
que puede invocar el cliente. En este caso podéis comprobar
que existe
sólo un método getInformation,
que permite obtener la información asociada a un usuario del
banco. Este método se implementa en la clase del bean.CustomerHome.java:
Interfaz origen ("home interface") que define los métodos
que le
permiten al cliente crear y buscar un bean. En este caso
podéis
comprobar que esta interfaz proporciona un método que
permite crear el
bean a partir de los datos asociados a un usuario, devolviendo un
objeto que implementa la interfaz remota definida en Customer.java,
de esta forma se crea un nuevo usario en nuestro sistema que se
almacenará de manera persistente en la base de datos. En
esta interfaz
también existe un método que permite buscar una
instancia del bean a
partir de la clave primaria, que en este caso es el nombre del usuario.CustomerBean.java:
Esta clase contiene el código del EJB que implementa los
métodos de negocio definidos en el interfaz remoto Customer,
además de todos los métodos definidos en la
interfaz EntityBean. CustomerTO.java:
Es una clase auxiliar que representa la información asociada
a un
usuario, es una clase serializable ya que el método de
negocio definido
en la interfaz remota devuelve un objeto de este tipo.
- Compilar el código fuente, para ello
dentro del directorio
src ejecutad:
javac -d ../build *.java
Si este paso se ha realizado correctamente, en
el directorio ../build tendréis la
siguiente estructura de ficheros:
build +-- Customer.class
|
+-- CustomerBean.class
|
+-- CustomerClient.class
|
+-- CustomerHome.class
|
+-- CustomerTO.class
- Empaquetar el EJB: Para ello vamos a utilizar el
asistente ("wizard") proporcionado por el
deploytool,
que nos permite realizar las siguientes tareas de forma más
sencilla:
- Crear el descriptor de despliegue del bean.
- Empaquetar el descriptor de despliegue y las
clases del bean en un ficheoro EJB JAR.
- Añadir el fichero EJB JAR en el
fichero (
CustomerApp.ear).
Para ejecutar el asistente es necesario
seleccionar en el deploytool: File
-> New -> Enterprise Bean. El asistente
muestra los siguientes cuadros de dialogo:
- "New Enterprise Bean Wizard -
Introduction":
- Leer el texto explicativo que nos indica
las tareas que realiza este asistente.
- Clic en
Next.
- "New Enterprise Bean Wizard -
EJB JAR General Settings":
- En el apartado
JAR Location,
seleccionar la opción Create New JAR Module in
Application y en el combobox inferior seleccionar CustomerApp.
- En el apartado
JAR Naming,
introducir en el campo JAR Display Name, CustomerJAR.
- En el apartado
Contents,
clic en Edit Contents, en el árbol
de Available Files, localizar el directorio build/
y seleccionar los cuatro ficheros de clases del bean: Customer.class,
CustomerBean.class, CustomerHome.class
y CustomerTO.class. Hacer clic en Add
y después en OK para volver a la
pantalla anterior.
- Clic en
Next.
- "New Enterprise Bean Wizard -
Bean General Settings":
- En el combobox bajo
Enterprise
Bean Class seleccionar CustomerBean.
Automáticamente en los campos Enterprise Bean
Name aparecerá CustomerBean
y en Enterprise Bean Type se
seleccionará Entity.
- En el apartado
Remote
Interfaces, seleccionar en el combobox correspondiente a Remote
Home Interface, CustomerHome y
en el combobox correspondiente a Remote Interface,
Customer.
- Clic en
Next
- "New Enterprise Bean Wizard -
Entity Bean Settings":
- En el apartado
Persistence
Management, indicar en el combobox Persistence
Management Type, la opción Bean-Managed
Persistence.
- En el apartado
Primary Key
Class, seleccionar la opción Select
a standard java class. Automáticamente se
seleccionará java.lang.String, que
es el que corresponde con el tipo de clave primaria del EJB que estamos
desplegando (recordar que la clave primaria es el dni
que es de tipo String).
- Clic en
Next
- "New Enterprise Bean Wizard -
Next Steps":
- Leer el texto en el que se indican las
tareas que se pueden realizar a continuación.
- Clic en
Finish.
- Para
finalizar la creación de este EJB de Entidad es necesario
configurar la
referencia a la base de datos en la cual está almacenada la
tabla de
usuarios que representa este EJB. Para ello es necesario realizar los
siguientes pasos:
- En el árbol de la
aplicación, seleccionar
CustomerBean.
- Seleccionar la pestaña
Resource
Ref's.
- Clic en
Add.
Automáticamente se añade una fila con las
siguientes características:
- El campo
Coded Name
está en blanco. Introducir el valor jdbc/CustomerDataSource
(es la referencia que se busca en CustomerBean).
- En el campo
Type
está seleccionada la opción javax.sql.DataSource
(valor por defecto).
- En el campo
Authentication
está seleccionada la opción Container
(valor por defecto).
- El campo
Shareable
está activado.
- En el apartado
Sun-specific
Settings for:
- Indicar
jdbc/bankdb,
en la opción JNDI Name.
- En los campos
User Name
y Password, introducir los datos necesarios
para establecer la conexión con la base de datos, en este
caso los valores son, swc y swc
respectivamente.
- Seleccionar en el menú principal,
File
-> Save.
- Configurar la conexión JDBC del servidor
J2EE:
Una
vez creado el EJB para que funcione correctamente es necesario
configurar la conexión JDBC del servidor J2EE. La
gestión de las
conexiones se realiza a través de la herramienta de
administración del
servidor, a la que se puede acceder a través de la
página http://localhost:4848. Los
pasos a realizar son:
- Extender el árbol de
JDBC
y a continuación seleccionar JDBC Resources.
- En la parte derecha de la página, clic
en el botón
New... para crear un
nuevo recurso:
- En el campo
JNDI Name,
introducir jdbc/bankdb.
- En el campo
Pool Name,
seleccionar en el combobox el correspondiente a la base de datos Derby,
DerbyBankdbPool.
- De forma opcional, introducir una
descripción en el campo
Description.
- Clic en
Ok.
- Crear un cliente para la
aplicación:
CustomerClient
Para interactuar con el EJB anterior vamos a crear
un cliente, cuyo código se encuentra en el directorio src/CustomerClient.java.
Este cliente se lanzará en un terminal y su objetivo es
permitirnos probar la funcionalidad de la aplicación CustomerApp.
- Compilar el código fuente si no ha
sido compilado:
$ javac -classpath ../build -d ../build CustomerClient.java
Para empaquetar la aplicación cliente
vamos a utilizar el asistente proporcionado por el deploytool,
que nos permite realizar las siguientes tareas de forma más
sencilla:
- Crear el descriptor de despliegue de la
aplicación cliente.
- Empaquetar el descriptor de despliegue y los
ficheros de la aplicación en un fichero JAR.
- Añadir el fichero JAR en el fichero (
CustomerApp.ear).
- Para ejecutar el asistente en el
deploytool,
seleccionar: File -> New -> Application
Client. El asistente muestra los siguientes cuadros de
diálogo:
- "New Application Client Wizard
- Introduction":
- Leer el texto explicativo que nos indica
las tareas que realiza este asistente.
- Clic en
Next
- "New Application Client Wizard
- JAR File Contents":
- En el apartado
AppClient
Location, seleccionar la opción Create
New AppClient Module in Application, y en su respectivo
combobox seleccionar CustomerApp.
- En el apartado
AppClient
Naming, introducir en el campo AppClient
Display Name, CustomerClient.
- En el apartado
Contents,
clic en Edit Contents: en el árbol
debajo de Available Files localizar el
directorio build y seleccionar el fichero
correspondiente a la aplicación cliente CustomerClient.class
y hacer clic en Add y después en OK
para volver a la pantalla anterior.
- Clic en
Next
- "New Application Client Wizard
- General":
- En el apartado
Application
Client, en el combobox correspondiente a Main
class, seleccionar CustomerClient.
- Clic en
Next
- "New Application Client Wizard
- Next Steps":
- Leer el texto en el que se indican las
tareas que se pueden realizar a continuación.
- Clic en
Finish.
- Especificar la referencia al EJB:
Si nos fijamos en el código de CustomerClient.java,
se busca una referencia al bean mediante el método lookup:
Object objRef = ic.lookup("java:comp/env/ejb/SimpleCustomer");
Para especificar esta referencia es necesario
realizar los siguientes pasos en el deploytool:
- En el árbol de la
aplicación, seleccionar
CustomerClient.
- Seleccionar la pestaña
EJB
Ref's.
- Click
Add:
- En el campo
Coded Name,
introducir ejb/SimpleCustomer.
- En el combobox
EJB Type,
seleccionar Entity.
- En el combobox
Interfaces,
seleccionar Remote.
- En el campo
Home Interface,
introducir CustomerHome.
- En el campo
Local/Remote
Interface, introducir Customer
- En el apartado
Target EJB,
en el combobox correspondiente a JNDI Name,
seleccionar CustomerBean.
- Clic en
OK.
- Desplegar
CustomerApp
en el servidor
- En el árbol de la
aplicación seleccionar
CustomerApp.
- Seleccionar
Tools -> Deploy:
- En el apartado
Connection Settings,
introducir el "login" y "password" del administrador del servidor.
- Seleccionar el chechbox
Return
Client JAR y clic en OK.
- Confirmar el despliegue en la ventana
Confirm
Save and Deploy.
- Hacer clic en
Close
en la ventana Distribute Module cuando
finalice el despliegue.
- Para verificar el despliegue: en el
árbol de
Servers, seleccionar el
host en el que se está ejecutando el servidor J2EE (localhost).
En la tabla Deployed Applications,
debería aparecer listada la aplicación CustomerApp
y su estado debería ser Running.
- Ejecutar
CustomerApp:
- Introducir en la tabla creada
previamente,
users,
algunos registros, ya que el método de negocio que soporta
el bean,
sólo permite la visualización de datos de
usuarios existentes. Para
realizar esta tarea se proporciona el script insert_table.sql
que debéis ejecutar en la consola de Derby (ij).
- En un terminal, ir al directorio
principal de la aplicación
customer.
- Ejecutar en la línea de
comandos:
$ appclient -client CustomerAppClient.jar
- En el terminal, el cliente
mostrará los valores asignados al cliente "1111A":
DNI: 1111A
User Name: Usuario1
Address: C/Usuario, 1
Phone Number: 666111111
Si ha llegado aquí es señal de que
ya sabes compilar (haciendo uso de las librerías de J2EE)
aplicaciones empresariales, así como desplegarlas haciendo
uso del deploytool.
|
