Usted está aquí: Inicio Ingeniería Telemática Software de Comunicaciones (I.T.T.T.) jee practicaJEE EJBexercises

EJBexercises

Acciones de Documento
  • Marcadores (bookmarks)
  • Exportación de LTI
Autores: Florina Almenares, Pablo Basanta
Enunciados prácticas de Java EE
Home UC3M
null
Home IT
null

 

Software de Comunicaciones - ITT Telemática

Ejercicios de EJBs


  • Ejercicio 1: Creación, despliegue y ejecución de un EJB de Sesión sin estado con cliente web.
  • Ejercicio 2: Creación, despliegue y ejecución de un EJB de Sesión con estado con cliente web.
  • Ejercicio 3: Creación, despliegue y ejecución de un EJB de Entidad - persistencia manejada por el bean (BMP) con cliente consola.
  • Ejercicio 4: Creación, despliegue y ejecución de un EJB de Entidad - persistencia manejada por contenedor (CMP) con cliente web y/o consola.

 

 Ejercicio 1: Creación, despliegue y ejecución de un EJB de Sesión sin estado
null

A partir del código de la aplicación ConverterApp, crear y desplegar una nueva aplicación denominada LibraConverterApp cuyos métodos de negocio nos permitan la convesión de una cantidad determinada a Euros y a Libras esterlinas. Por ejemplo, si se introduce 100, la respuesta será: "100 euros son 65.89 libras" y "100 libras son 151.75 euros". 

Para consultar información sobre el cambio puede utilizar los siguientes enlaces: Banco Central Europeo, EuroResidentes.



 Ejercicio 2: Creación, despliegue y ejecución de un EJB de Sesión con estado
null

Similar a los EJBs anteriores, vamos a crear una nueva aplicación, ConverterFinalApp, la cual contiene un EJB de sesión con estado cuyo método de negocio permitirá contar el número de operaciones (conversiones) realizadas. Para ello debe integrar los dos EJBs de sesión sin estado creados previamente.

Para el desarrollo de esta aplicación, tened en cuenta las siguientes instrucciones:

  1. Crear las clases e interfaces correspondientes al contador. Tened en cuenta, que en la implementación del método ejbCreate() hay que inicializar la variable de instancia que llevará la contabilidad de las operaciones.
  2. Para desplegarlo, seguir las instrucciones dadas en el apartado Despliegue y Ejecución, teniendo en cuenta el siguiente cambio:
    • En el punto 3.c.iii., "New Enterprise Bean Wizard - Bean General Settings", modificar el campo Enterprise Bean Type por Stateful Session.
  3. Crear un cliente Web (index.jsp) que contenga:
    • Un título.
    • Un campo de texto para introducir la cantidad a convertir.
    • Un combobox que permita seleccionar la moneda origen (euro, dólar, libra).
    • Un combobox que permita seleccionar la moneda destino (euro, dólar, libra).
    • Un botón para que realice la operación respectiva.

    Recuerda que si el usario elige convertir de dólar a libra, debéis convertir primero de dólar a euro y luego de euro a libra.

    Recuerda que: a) el objeto Contador dentro de la página JSP, no puede ser una variable de instancia, por lo tanto, debe crearse por fuera del método jspInit(); b) este objeto debe almacenarse y recuperarse como atributo de la sesión.

  4. Desplegar el cliente (Web Component) con el nombre de ConverterFinalWAR.

  5. Se recomienda eliminar el despliegue de los EJBs anteriores, para evitar tener componentes con los mismos nombres:
    • Dentro del árbol de servidores, seleccionar la aplicación y hacer clic en el botón undeploy.

  6. Añadir los dos EJBs, a partir del código de los ejercicios anteriores, para ello:
    • En el deploytool, seleccionar File -> New -> Enterprise Bean.
    • Cambiar el nombre de los ficheros JAR para evitar solapamiento con las aplicaciones creadas previamente, si no se llevo a cabo la recomendación en el punto anterior (punto 5). Así, el JAR que contiene las clases del paquete converter se llamará ConverterFinalJAR. Asimismo, el JAR que contiene las clases del paquete libraconverter se llamará LibraConverterFinalJAR.
    • Añadir las referencias al cliente Web, para ello:
      1. Seleccionar ConverterFinalWAR en el árbol de la aplicación.
      2. Seleccionar la pestaña EJB Refs.
      3. Clic en Add:
        • En el campo coded Name, introducir ejb/EuroDollarConverter.
        • En el combobox EJB Type, seleccionar Session.
        • En el combobox Interfaces, seleccionar Remote.
        • En el campo Home Interface, introducir converter.ConverterHome.
        • En el campo Local/Remote Interface, introducir converter.Converter.
        • De las dos opciones disponibles en el apartado Target EJB, seleccionar el campo que pone JNDI Name y seleccionar ConverterBean
        • Clic en OK.
      4. Repetir los mismos pasos para ejb/EuroLibraConverter, seleccionando sus respectivas interfaces y "enterprise bean".

  7. Definir el context root, como /converterfinal.
  8. Verificar que existen los 3 EJBs y sus respectivas referencias:
    • En el árbol de Applications, seleccionar ConverterFinalApp.
    • Seleccionar la pestaña General. Clic en el botón Sun-specific Settings...:
      • En la vista JNDI Names, deben aparecer en la tabla de Application: ConverterBean, LibraConverterBean, y ContadorBean.
      • Lo mismo para la tabla de References.
      • Clic en Close.
  9. Seleccionar ConverterFinalApp, y hacer clic en Tools -> Deploy.
  10. Ejecute la aplicación en el navegador: http://localhost:8888/converterfinal/.
Ejercicio 3: Despliegue y ejecución de CustomerApp
null

Esteconsiste en desplegar y ejecutar una aplicación J2EE denominada CustomerApp que permite representar la información relativa a un usuario, que se almacena de forma persistente en la base de datos de nuestro sistema. CustomerApp consta de un EJB de entidad cuya persistencia está manejada por bean (BMP) y una aplicación cliente, que nos permitirá acceder a la funcionalidad proporcionada por el EJB desarrollado.

El código fuente de la aplicación os lo podéis descargar del siguiente enlace customer.tgz. Descomprimid el fichero en un directorio (por ejemplo, $HOME/swc/practicasj2ee).

  1. Arrancar el servidor J2EE.
     
  2. 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.
     
  3. Crear la aplicación J2EE: CustomerApp
    1. Arrancar el deploytool, para ello ejecutad:$ deploytool &
    2. Seleccionar File -> New -> Application.
    3. 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.
    4. Comprobar que el fichero CustomerApp.ear existe en directorio indicado en el paso b.
  4. Crear el Enterprise Bean: CustomerBean
    1. 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.


       

    2. 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
      


       

    3. 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:
       

      1. "New Enterprise Bean Wizard - Introduction":
        • Leer el texto explicativo que nos indica las tareas que realiza este asistente.
        • Clic en Next.
      2. "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.
      3. "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
      4. "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
      5. "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.


         

    4. 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:
      1. En el árbol de la aplicación, seleccionar CustomerBean.
      2. Seleccionar la pestaña Resource Ref's.
      3. 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.
      4. 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.
      5. Seleccionar en el menú principal, File -> Save.


     

  5. 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:

    1. Extender el árbol de JDBC y a continuación seleccionar JDBC Resources.
    2. 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.


     

  6. 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.

    1. 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).


       

    2. Para ejecutar el asistente en el deploytool, seleccionar: File -> New -> Application Client. El asistente muestra los siguientes cuadros de diálogo:
      1. "New Application Client Wizard - Introduction":
        • Leer el texto explicativo que nos indica las tareas que realiza este asistente.
        • Clic en Next
      2. "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
      3. "New Application Client Wizard - General":
        • En el apartado Application Client, en el combobox correspondiente a Main class, seleccionar CustomerClient.
        • Clic en Next
      4. "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.


     

  7. 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:

    1. En el árbol de la aplicación, seleccionar CustomerClient.
    2. Seleccionar la pestaña EJB Ref's.
    3. 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.


     

  8. Desplegar CustomerApp en el servidor
    1. En el árbol de la aplicación seleccionar CustomerApp.
    2. 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:
        1. 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).
        2. En un terminal, ir al directorio principal de la aplicación customer.
        3. Ejecutar en la línea de comandos:
           $ appclient -client CustomerAppClient.jar
          
        4. 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.

 

Ejercicio 4: Creación, despliegue y ejecución de un EJB de Entidad CMP
null

En este ejercicio vamos a abordar el desarrollo de un EJB de Entidad, denominado AccountBean cuya persistencia está manejada por contenedor que represente las cuentas de los usuarios de en un banco. Para cada cuenta mantener la siguiente información:

  • Número de cuenta, un identificador único asociado a la cuenta. Éste será utilizado como la llave primaria (primary key).
  • Identificador del usuario, el NIA del usuario titular de la cuenta.
  • Saldo, la cantidad monetaria que tiene la cuenta, a favor o en contra del titular.
  • Tipo, el tipo de cuenta (déposito de ahorro, corriente, corriente comercial, extranjera, etc.)
  • Fecha de apertura, la fecha en que se le da de alta a la cuenta. Por lo general, esta fecha corresponde a la fecha del sistema.

Los métodos de negocio y de vida que debe implementar son:

  • Crear una cuenta: ejbCreate(String num, String nia, float saldo, String tipo, java.util.Date apertura).
  • Establecer el contexto del EJB: setEntityContext(EntityContext ec).
  • Liberar el contexto del EJB: unsetEntityContext().
  • Recuperar información: Métodos get por cada atributo del bean, por ejemplo, getNo(), getNia(), getSaldo(), ...
  • Retirar dinero: retirar(int cantidad).
  • Ingresar dinero: ingresar(int cantidad) .
  • Realizar transferencia: transferirA(String cuenta, float cantidad).

Crear una o varias cuentas que permitan validar el funcionamiento del EJB desarrollado. Para ello podéis desarrollar un(os) cliente(s) sencillo que permita(n) validar los métodos de negocio y de vida.

Codificación de las interfaces y clases

  1. Crear el interfaz remota Account que define los métodos de negocio que puede invocar el cliente.
  2. Crear el interfaz origen AccountHome que define los métodos que le permiten al cliente crear y buscar un bean. En este caso, el interfaz proporcionará: a) un método que permite crear el bean a partir de los datos asociados a una cuenta, devolviendo un objeto que implementa la interfaz remota; y b) un método que permite buscar una instancia del bean a partir de la clave primaria, que en este caso es el número de cuenta.
  3. Crear la clase abstracta que contiene el código del EJB, AccountBean, la cual contiene los métodos de negocio definidos en el interfaz remoto Account como métodos abstractos, los métodos de vida definidos en el interfaz EntityBean.

Nota: En el capítulo 27 del tutorial de J2EE podéis encontrar información que os servirá como guía para la codificación de las interfaces y clases.

Despliegue de un EJB de Entidad manejado por contenedor

  1. En la ventana del asistente "New Enterprise Bean Wizard - Entity Bean Settings":
    1. Seleccionar en el combobox Persistence Management Type, la opción Container-Managed Persistence (2.0). Aparecerán automáticamente los campos que pueden ser persistentes, en nuestro caso los seleccionamos todos.
    2. En el campo Abtract Schema Name, introducir el valor AccountBean.
    3. En el apartado Primary Key Class, seleccionar en el combobox Select an existing field, el valor num [java.lang.String], que es el que corresponde con el tipo de clave primaria del EJB que estamos desplegando.
  2. Para realizar el mapeo entre los campos persistentes del bean y el esquema de la base de datos:
    1. En el árbol de la aplicación seleccionar el EJB (por ejemplo, AccountJAR).
    2. En la pestaña General, hacer clic en el botón Sun-specific Settings.... Se abrirá un diálogo:
      1. En el campo View, seleccionar CMP Database.
      2. En el campo JNDI Name, introducir el valor jdbc/bankDB. Esta conexión JDBC a la base de datos, corresponde a la que habíamos creado en el ejercicio anterior.
      3. Verificar que en el combobox Enterprise Bean, esté seleccionado el bean.
      4. Clic en el botón Create Database Mappings ..., se abrirá un cuadro de diálogo:
        • Seleccionar la opción Automatically Generate Necessary Tables.
        • No marcar el campo Generate Unique Table Names.
        • Seleccionar en el combobox Datasource vendor, Derby.
        • Clic en OK.
      5. Al volver a la ventana anterior, automáticamente en el apartado Mappings for Bean 'NombreBean', nos aparecerá la descripción de la tabla que modela nuestro EJB. Es posible modificar la longitud de los campos tipo String.
    3. Clic en Close.
    4. Guardar los cambios.
Reutilizar Curso
Descargar este curso