enterprise javabeans 2 - um · 2011-11-30 · ejb 10 • en ejb una entidad es un objeto...
TRANSCRIPT
Enterprise JavaBeans 2.x Aplicaciones Distribuidas
2
Contenido
• Motivación.
• Alternativas implantación del Modelo.
• Modelado de entidades en EJB.
• Persistencia BMP.
• Persistencia CMP 1.x
• Persistencia CMP 2.x
• Relaciones entre entidades.
• Interfaces locales.
• XDocLet
• Lógica de Negocio.
• Transacciónes.
• Programación Basada en Componentes.
• Roles EJB.
• Visión Cliente de EJB.
• Conclusiones.
3
Motivación
• Implementación del Modelo en un sistema enterprise.
• Datos + Lógica de Negocio.
• Desafíos:
• Representación de los datos: base de datos relacional, BD orientada a objetos, XML, LDAP, ...
• Acceso a los datos: JDBC, JNDI, DAO, JDO, ...
• Representación de la lógica de negocio.
• Todo ello de un modo:
• Distribuido, eficiente, escalable, seguro, transaccional, reutilizable, configurable, ...
4
Implantación del Modelo • Obtenemos el modelo a partir de la aplicación de un proceso de
desarrollo. • Modelos en UML.
• Solución tradicional: • Del modelo se identifican las entidades (objetos de negocio).
• Las entidades se representan en esquema relacional à BD
• Inconveniente: Lógica OO vs. Datos Relacionales.
Base de Datos
Controlador/ Vista
JDBC
Lógica de Negocio
5
Implantación del Modelo
• Alternativa à Correspondencia objeto/relacional: • Herramientas que proporcionan persistencia relacional a los objetos
de un modo transparente.
• Ejemplo: JavaBlend
• Inconvenientes: no son estándares.
Controlador/ Vista
Base de Datos
Correspondencia Objeto/Relacional
Lógica de Negocio
JDBC
Desarrollo de Aplicaciones Distribuidas 6
Implantación del Modelo - JDO
• Especificación Java Data Objects (JDO): • Persistencia transparente en Java.
• Soporte de transacciones locales y distribuidas.
• Mecanismo de consultas basado en filtros de colecciones.
• Independiente del almacenamiento. Controlador/ Vista
Base de Datos Lógica de Negocio
JDO
Implantación del Modelo - JDO
7
• Inconvenientes: • Los objetos entidad se
replican a través del sistema.
• No es escalable.
8
Implantación del Modelo - EJB
• EJB: compartir las entidades entre aplicaciones ...
Base de Datos
Controlador/ Vista
Lógica de Negocio
EJB
RMI/IIOP
Con
trol
ador
/
Vis
ta Lóg
ica
de
Neg
ocio
RM
I/II
OP
9
Implantación del Modelo - EJB
• EJB: compartir la lógica de negocio • Principio: lógica de negocio cercana a los datos.
Base de Datos
Controlador/ Vista
Lógica de Negocio
EJB RMI/IIOP
Con
trol
ador
/
Vis
ta
RM
I/II
OP
Modelado de Entidades en EJB
10
• En EJB una entidad es un objeto distribuido: • è Hay que definir su interface remota RMI.
import java.rmi.*;!!public interface Producto extends javax.ejb.EJBObject {!
!!!// Los atributos se representan como propiedades JavaBean!
!public String getNombre() throws RemoteException;! !public void setNombre(String nombre) throws RemoteException;!
!!!// Si es de sólo lectura sólo ponemos el método "get"!!public String getId() throws RemoteException; !!!// ... !!!// Operaciones!!public int precio() throws RemoteException; !!
}!
11
Entidades – Ciclo de Vida
• Para controlar su ciclo de vida y obtener los objetos necesitamos un Home. • Interface remota RMI que permite manejar las entidades.
import java.rmi.*;!import javax.ejb.*;!!public interface ProductoHome extends javax.ejb.EJBHome { !!
!// Métodos de creación!!public Producto create (String id, String nombre, int precioBase, int porcentajeDto) !! !throws RemoteException, CreateException;!!!!// Métodos de localización!!public Producto findByPrimaryKey(String id) // Obligatorio!! !throws RemoteException, FinderException; !!!!public java.util.Collection findAll() throws RemoteException, FinderException;!!
}
12
Entidades - Implementación
• Hay que programar una sola clase implementación para las dos interfaces remotas.
• La implementación depende del modelo de persistencia que utilicemos:
• Bean Managed Persistence (BMP): • El programador se encarga de toda la persistencia.
• Container Managed Persistence (CMP) 1.x: • El programador delega parte del trabajo al contenedor.
• Todo lo relativo a la persistencia se indica declarativamente.
• CMP 2.x: • El contenedor se encarga de toda la persistencia.
13
Persistencia BMP • La clase implementación (bean) debe implementar la interface
javax.ejb.EntityBean
• Declarar atributos para manejar la persistencia y el contexto EJB:
• Declarar atributos para almacenar las propiedades del objeto:
!private ProductoDAO productoDAO; // DAO productos!private EntityContext context; // Contexto EJB!
!private String id; // Clave primaria!private String nombre;!// ...!
14
Persistencia BMP • Declarar un constructor vacío para la inicialización: • è Obtener el DAO Producto, etc.
• Implementar los métodos de la interface remota:
!// Métodos de la interface remota del objeto!!public String getId() { return id; }!!!!public String getNombre() { return nombre; }!!!!public void setNombre(String nombre) { this.nombre = nombre; }!!// ... !
15
Persistencia BMP
• Programar los métodos de creación:
public String ejbCreate (String id, String nombre, int precioBase, int porcentajeDto) {!! !!! !// Actualiza la instancia!! !this.id = id; this.nombre = nombre; // ...!! !!! !// Almacena la instancia en la base de datos!! !productoDAO.create(id, nombre, precioBase, porcentajeDto);!! !!! !// Devuelve la clave primaria!! !return id;!
}!!
// El contenedor confirma que la instancia ya es está disponible !!public void ejbPostCreate (String id, String nombre, int precioBase, int porcentajeDto) { }!!
16
Persistencia BMP
• Programar los métodos de localización:
!// Métodos de localización!!public String ejbFindByPrimaryKey (String id) throws FinderException {!! !!! !// Se limita a comprobar si existe el objeto en el almacenamiento!! !if (productoDAO.findById(id) == null)!! ! !return null;!! !else!! ! !return id;!!} !!!public Collection ejbFindAll() { ! ! !!! !Collection resultados = productoDAO.findAll();!! !!! !// Iteramos sobre los resultados y construimos una colección!! !// con las claves primarias ...!! !!! !return clavesPrimarias; ! !!!}
17
Persistencia BMP
• Programar un método de eliminación:
• Métodos que actualizan el contexto de EJB:
public void ejbRemove() throws RemoveException {!! !!!// Borra la instancia actual de la base de datos!!productoDAO.remove(id); !!
}
public void setEntityContext(EntityContext context) {! !this.context = context;! }!! public void unsetEntityContext() {! !this.context = null;! }
18
Persistencia BMP • El contenedor EJB se encarga de: • Mantener en memoria una caché eficiente de objetos.
• Para realizar esta tarea tenemos que ayudarle programando unos de métodos de retrollamada.
• Sincronización instancia – base de datos:
// Almacena la instancia en la base de datos!public void ejbStore() { ! !!
!productoDAO.update(id, nombre, precioBase, porcentajeDto);!} !!// Actualiza la instancia con la información de la base de datos!public void ejbLoad() { ! !!
!ProductoVO pVO = productoDAO.findById(id);! !!!// Actualiza la instancia!!id = pVO.id; nombre = pVO.nombre; // ...!
}
19
Persistencia BMP
• Métodos para activar/desactivar la instancia:
• Cuando se desactiva, la instancia pierde la identidad.
• Antes de la desactivación, guarda la instancia (ejbStore).
• Después a la activación, carga la instancia (ejbLoad).
!// Elimina su identidad y libera recursos!!public void ejbPassivate() {!! ! id = null; !!}!
! !// Obtiene una nueva identidad y adquiere recursos! !public void ejbActivate() { !
! !id = (String) context.getPrimaryKey(); !!}
20
Persistencia BMP - Ciclo de Vida
No Existe Pooled Ready
new()
setEntityContext()
Métodos Home
ejbCreate/ejbPostCreate()
ejbRemove()
ejbActivate/ejbLoad()
ejbStore/ejbPassivate()
Métodos interface
ejbLoad() ejbStore()
Libera la instancia
21
Persistencia BMP - Configuración
• Necesitamos declarar ciertas propiedades del bean en un fichero de configuración (ejb-jar.xml)
<entity>
<ejb-name>Producto</ejb-name>
<home>ProductoHome</home>
<remote>Producto</remote>
<ejb-class>ProductoBean</ejb-class>
<persistence-type>bean</persistence-type>
<prim-key-class>java.lang.String</prim-key-class>
<reentrant>False</reentrant>
</entity>
22
Persistencia BMP - Conclusiones
• Responsabilidades del programador: • Atributos para la persistencia y contexto EJB. • Atributos para la propiedades.
• Constructor para la inicialización. • Métodos de creación.
• Métodos de localización. • Método de borrado.
• Métodos para actualizar el contexto. • Métodos de sincronización.
• Métodos de cambio de identidad.
• è Este modelo de persistencia conviene cuando el servidor EJB no sepa manejar la persistencia de nuestros datos: XML, LDAP, ...
23
Persistencia CMP 1.x
• Quita al programador la responsabilidad del acceso a datos.
• Todo lo relativo a la persistencia se indica declarativamente en ficheros de configuración.
• Diferencias con el modelo anterior:
• Hay que declarar como atributos públicos las propiedades persistentes de la instancia.
!public String id; // Clave primaria!public String nombre;!// ...
24
Persistencia CMP 1.x
• Diferencias: • No es necesario un constructor de inicialización.
• Los métodos de creación sólo tienen que inicializar la instancia: à el contenedor gestiona la clave primaria
public String ejbCreate (String id, String nombre, int precioBase, int porcentajeDto) {!! !!! !// Actualiza la instancia!! !this.id = id; this.nombre = nombre; // ...!! !!! !// No tiene que devolver ninguna clave primara!! !return null;!
}!
// Confirma que la instancia ya es está disponible !!public void ejbPostCreate (String id, String nombre, int precioBase, int porcentajeDto) { }!
25
Persistencia CMP 1.x • Diferencias: • No hay que programar los métodos de localización: • è Se especificarán declarativamente.
• No hay que programar un método borrado: • Implementados por el contenedor.
• Lo métodos de sincronización (ejbLoad/ejbStore) se pueden dejar vacíos.
• Los métodos de cambio de estado (ejbPassivate/ ejbActivate) se pueden dejar vacíos.
26
Persistencia CMP 1.x - Configuración
<entity> <ejb-name>Producto</ejb-name> <ejb-class>ProductoBean</ejb-class> <home>ProductoHome</home> <remote>Producto</remote> <persistence-type>Container</persistence-type> <primkey-field>id</primkey-field> <prim-key-class>java.lang.String</prim-key-class> <reentrant>True</reentrant> <cmp-version>1.x</cmp-version> <cmp-field> <field-name>id</field-name> </cmp-field> <cmp-field> <field-name>nombre</field-name> </cmp-field> …
</entity>
27
CMP 1.x – Configuración Persistencia
Depende del servidor EJB <entity>
<ejb-name>Producto</ejb-name>
<jdbc-mappings>
<jdbc-mapping>
<name>create</name>
<statement>
<action>INSERT INTO Producto (id , nombre , precioBase, porcentajeDto) VALUES ( ? , ? , ? , ?)
</action>
<source>isi</source>
<params>
<param>
<name>id</name>
<type>VARCHAR</type>
</param>
…
</statement>
</jdbc-mapping>
28
CMP 1.x – Configuración Persistencia <jdbc-mapping>
<name>load</name>
<statement>
<action>SELECT id, nombre, precioBase, porcentajeDto
FROM Producto WHERE id=?
</action>
<source>aadd</source>
<params>…</params>
<fields>
<field>id</field>
<field>nombre</field>
…
</fields> … <jdbc-mapping>
<name>findAll</name>
<statement>
<action>SELECT id FROM Producto </action>
29
Persistencia CMP 1.x - Conclusiones
• Este modelo de persistencia ahorra trabajo de programación Java, pero no de base de datos.
• El modo de especificar el acceso a datos es propietario.
• El componente es reutilizable y configurable.
• è Resulta práctico cuando tengamos que utilizar un esquema dado de base de datos.
30
Persistencia CMP 2.x • Nos olvidamos de cualquier cuestión relativa a la persistencia.
• Diferencias respecto al modelo anterior:
• La clase implementación debe ser abstracta.
• No hay que declarar los atributos persistentes.
• Los métodos de la interface remota de las propiedades se declaran abstractos.
• Los métodos de creación utilizan los métodos “set” para configurar la instancia.
public String ejbCreate (String id, String nombre, int precioBase, int porcentajeDto) {!!setId(id); setNombre(nombre); // ... ! ! ! !!!return null;!
}
31
Persistencia CMP 2.x - Configuración
• En la configuración definimos los métodos de localización utilizando el lenguaje neutral EJB-QL:
• Similar a SQL, pero con extensiones orientadas a objetos.
• Ejemplos: • SELECT OBJECT(p) FROM Productos AS p
• SELECT OBJECT(p) FROM Productos AS p WHERE p.id = ?1
• En el descriptor de despliegue añadimos el nombre del esquema para el componente: • <abstract-schema-name>Productos</abstract-schema-name>
• La versión del modelo de persistencia es “2.x”.
• <cmp-version>2.x</cmp-version>
32
Persistencia CMP 2.x - Configuración
• Los métodos de localización se indican como: <query>
<query-method>
<method-name>findByNombre</method-name>
<method-params>
<method-param>java.lang.String</method-param>
</method-params>
</query-method>
<ejb-ql> ... </ejb-ql>
</query>
• El método de consulta para “findByPrimaryKey” es automático.
• è El contenedor crea las tablas e implementa los métodos create, store, load y remove.
• En el modelo CMP 2.x podemos modelar las relaciones entre los objetos de negocio.
• La clase implementación ProductoBean define la relación del siguiente modo: • public abstract Categoria getCategoria(); • public abstract void setCategoria(Categoria c);
Persistencia CMP 2.x - Relaciones
33
Producto id : String nombre : String precioBase : int porcentajeDto : int precio() : int
Categoria * * 1
categoria-producto +tiene-productos
+producto-pertenece-categoria
34
Persistencia CMP 2.x - Relaciones
• En el fichero de configuración: <ejb-relation>
<ejb-relation-name>Categoria-Producto</...> <ejb-relationship-role>
<ejb-relationship-role-name>producto-pertenece-categoria</...>
<multiplicity>one</multiplicity>
<ejb-relationship-role-source> <ejb-name>Producto</ejb-name>
</ejb-relationship-role-source >
<cmr-field><cmr-field-name>categoria</...>
</ ejb-relationship-role>
...
35
Persistencia CMP 2.x - Relaciones
• Podemos modelar una relación 1:N: • Desde Categoria a Producto
• En la clase implementación CategoriaBean incluimos: • public abstract Collection getProductos();
• public abstract void setProductos(
Collection productos);
• En el fichero de configuración expresamos el rol de Categoria en la relación: ...
<multiplicity>many</multiplicity>
<cmr-field>
<cmr-field-name>productos</cmr-field-name>
<cmr-field-type>java.util.Collection</cmr-field-name>
...
36
Persistencia CMP 2.x - Relaciones
• Relaciones N:M:
• Las dos partes tendrían una cardinalidad “many”.
• Si la relación es unidireccional, en el lado destino no definimos ningún campo CMR.
• Ejemplo: Categoria à Producto
• La semántica composición se consigue añadiendo <cascade-delete /> a la parte dependiente de la relación.
• Ejemplo: Venta à LineaVenta (dependiente)
• La integridad referencial es controlada por el contenedor.
• è La implementación de las colecciones permite mantener esta integridad.
37
Persistencia CMP 2.x - EJB-QL
• Las consultas se realizan sobre los esquemas: Productos, ...
• Se utilizan los nombre lógicos de los campos: nombre, categoria, ...
• 1. Todos los Productos: • SELECT OBJECT(p) FROM Productos AS p
• 2. Todos los Clientes que hayan comprado, evitando duplicados: • SELECT DISTINT OBJECT(p.cliente) FROM
Pedidos p
• 3. Todos los correos electrónicos de los clientes que hayan comprado: • SELECT p.cliente.correo FROM Pedidos p
• 4. Todas los pedidos que hayan solicitado más de 5 CDs o libros: • SELECT OBJECT(p)
FROM Pedidos p, IN (p.lineasVenta) lv
WHERE lv.producto.nombre IN (‘CD’, ‘LIBRO’) AND lv.cantidad > 5
• 5. Todos los productos cuyo id coincida con un parámetro: • SELECT OBJECT(p) FROM Productos AS p
WHERE p.id = ?1
• 6. Todos las categorías con productos, que no sean la raíz: • SELECT OBJECT(c) FROM Categorias AS c
WHERE c.productos IS NOT EMPTY AND c.categoriaPadre IS NOT NULL
38
Persistencia CMP 2.x - Conclusiones
• Permite trasladar un diagrama de clases en UML a un modelo de entidades y relaciones EJB.
• Modelo de persistencia ideal cuando desarrollamos el sistema de información desde el principio.
• è Dependemos de la eficiencia de la implementación del contenedor EJB.
39
Interfaces Locales • Problema:
• La interacción entre objetos de negocio relacionados se realiza a través de RMI.
• è Disminuye sensiblemente el rendimiento.
• Solución: • Definir interfaces locales para los objetos.
• Pasos: • Definición la interface local ProductoLocal:
• Hereda de javax.ejb.EJBLocalObject
• Definición la interface home ProductoLocalHome: • Hereda de javax.ejb.EJBLocalHome
• è Ninguna de las operaciones lanza la excepción RMIException
• En el descriptor de configuración: • <local-home>ProductoLocalHome</local-home>
• <local>ProductoLocal</local>
40
XDocLet • Problema: • Para crear un objeto de negocio necesitamos programar
muchas clases e interfaces: • Producto, ProductoLocal, ProductoHome, ProductLocalHome,
ProductoBean • La información de configuración se expresa en un fichero
independiente (ejb-jar.xml). • è La programación EJB se complica.
• Solución: • Utilizar la programación basada en atributos (al estilo .NET) • La información declarativa se expresa dentro del código è
Herramienta XDocLet
41
XDocLet • Programamos sólo la clase implementación.
• Todas las propiedades se especifican mediante etiquetas.
/**!* @ejb:bean !type="CMP" !name="Producto" !cmp-version="2.x"!* ! !primary-key="id“!schema="Productos"!* @ejb:interface!remote-class="Producto"!* @ejb:home !remote-class="ProductoHome"!* @ejb:finder !signature="java.util.Collection findAll()"!* ! !query="SELECT OBJECT(o) FROM Productos AS o"!* @ejb:pk ! !class="java.lang.String"!*/!pubic abstract class ProductoBean implements EntityBean {!
!/**!!* @ejb:interface-method!!* @ejb:persistent-field!!* @ejb:pk-field!!*/!!public abstract String getId();
42
Lógica de Negocio
• EJB permite definir componentes que representen la lógica de negocio: • Ejemplo: el controlador de un “caso de uso”
• EJB session: • Están asociados a un solo cliente en tiempo de
ejecución y tienen un time-out. • El número de instancias en memoria de estos
componentes es controlado.
• El proceso de desarrollo se diferencia de los objetos de negocio (entidades).
43
Lógica de Negocio – EJB Session
• Definición de la interface remota: • Igual que los EJB entidad.
• Definición de la interface home: • Sólo tienen sentido métodos de creación.
• Programación del bean: • Implementa la interface javax.ejb.SessionBean • Puede definir los atributos que necesite, siempre que sean
serializables • à la instancia puede pasar a almacenamento secundario.
• Podría tener un constructor de inicialización si necesitara trabajar con algún recurso externo: BD, procesador XML, etc.
44
Lógica de Negocio – EJB Session
• Programación del bean: • Los métodos de creación configuran la instancia: • è No es necesario definir los métodos ejbPostCreate
• Hay que programar los métodos para manejar el contexto EJB:
• Hay que definir los métodos para activar/desactivar la instancia è pasar a almacenamiento secundario
private transient SessionContext context;!!public void setSessionContext(SessionContext context) { this.context = context; }!public SessionContext getSessionContext() { return context; }
public void ejbActivate() {}!public void ejbPassivate() {}
45
Lógica de Negocio – EJB Session
• Los componentes sesión que tienen estado se denominan “Stateful” • El contenedor guarda su estado en disco cuando necesite
desactivarlos.
• Asegura que la misma instancia siempre esté asociada al cliente.
• Los que no tienen estado son del tipo “Stateless”. • El contenedor los maneja de forma más eficiente.
• No mantiene una asociación con los clientes.
• Diferencias respecto a la programación: • Sólo tiene sentido que el home tenga un solo método create sin parámetros.
• Los métodos de activación/desactivación pueden ser ignorados.
46
EJB Session - Configuración
<session> <ejb-name>GestorPedidos</ejb-name>
<home>GestorPedidosHome</home>
<remote>GestorPedidos</remote>
<ejb-class>GestorPedidosBean</ejb-class>
<session-type>Stateful</session-type>
<transaction-type>Container</transaction-type>
</session>
• Session-type: Stateless o Stateful
• Hay que indicar quien controla las transacciones (transaction-type):
• è Los componentes entidad son controlados automáticamente.
Colaboración
47
• Habitualmente los EJB sesión colaboran con los entidad a través de sus interfaces locales.
compras : GestorCompras Cliente
totalAPagar( ) miCompra :
Compra l1 : LineaVenta p1 : Producto l2 : LineaVenta
getTotal( ) getSubtotal( )
precio( )
getSubtotal( ) Suma los subtotales de todas las lineas de venta
Retorna (cantidad * precio)
EJB-Session Stateful EJB-Entity
Controlador Modelo
48
Transacciones • Los componentes EJB pueden ser transaccionales.
• El contenedor garantiza (propiedades ACID):
• La atomicidad de las operaciones.
• La consistencia de los datos.
• El aislamiento transaccional.
• La perdurabilidad de las modificaciones.
• Modelos de transaccionalidad:
• Required, RequiresNew, Mandatory, Supports, NotSupported y Never.
• è Se definen para los métodos.
Transacciones – Modelo Required
49
• El modelo required es adecuado para una colaboración de un caso de uso:
compras : GestorCompras Cliente miCompra :
Compra l1 : LineaVenta p1 : Producto l2 : LineaVenta
totalAPagar( ) getTotal( )
getSubtotal( ) precio( )
getSubtotal( )
Crea una Tx
Modelo Transaccional "Required"
Utilizan la Tx
50
Transacciones
• Las transacciones de los EJB entidad son gestionadas por el contenedor.
• Para los sesión, dos alternativas (fichero configuración): • Gestionada por el bean. • Gestionada por el contenedor à recomendada.
• Situaciones que abortan una transacción: • Una excepción de Runtime: • La instancia que la lanza queda descartada.
• Marcar la transacción como rollback: • context.setRollbackOnly();
• Transacciones gestionadas por el contenedor.
51
EJB – Visión de Componente
• Componente:
• Entidad binaria reutilizable y configurable.
• Ejemplos: componente COM, componente JavaBean, ensamblados .NET, ...
• Finalizado el desarrollo de un EJB podemos empaquetarlo como componente:
• Clases compiladas: Producto, ProductoHome, ProductoBean, ProductoLocal, ProductoLocalHome
• Descripción: META-INF/ejb-jar.xml
• è Producto.jar
• Entidad binaria (class) con metainformación, reutilizable y configurable
52
Componentes EJB - Dependencias
• Un componente expresa sus dependencias: • Un valor de configuración:
<env-entry> <description>Directorio Ficheros XML</description> <env-entry-name>directorio-XML</env-entry-name> <env-entry-type>java.lang.String</env-entry-type> <env-entry-value>/XML</env-entry-value>
</env-entry>
• Una referencia a otro componente:
<ejb-ref> <ejb-ref-name>ejb/validador</ejb-ref-name> <ejb-ref-type>Session</ejb-ref-type> <home>ValidadorHome</home> <remote>Validador</remote>
</ejb-ref>
53
Componentes EJB - Dependencias
• Dependencias:
• Un recurso (servicio) del sistema:
<resource-ref>
<description>Fuente de Datos</description>
<res-ref-name>jdbc/Datos</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
<res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>
• Las dependencias permiten configurar el componente.
• Rol desarrollador.
54
Componentes EJB - Configuración
• Un componente obtiene sus dependencias de su contexto JNDI (“java:comp/env”):
Context ctxInicio = new InitialContext();!!// Obtiene la configuración del componente!Context entorno = ctxInicio.lookup("java:comp/env");!!String dirXML = (String) entorno.resolve("directorio-XML");!!// Obtiene una referencia RMI/IIOP al Home!Object obj = entorno.resolve("ejb/validador");!ValidadorHome valHome = !
!(ValidadorHome)PortableRemoteObject.narrow(obj, ValidadorHome.class);!!// Obtiene la fuente de datos!Object obj2 = entorno.resolve("jdbc/Datos");!DataSource ds = (DataSource) obj2;
55
Componentes EJB - Roles
• Programación Basada en Componentes: • Desarrollo de aplicaciones basada en el ensamblado de componentes.
• Rol ensamblador: • Establece los valores de configuración de los componentes.
• Establece las dependencias entre los componentes.
• Define los métodos transaccionales.
• Define la seguridad de la aplicación ...
• Rol deployer: • Proporciona los recursos necesarios a los componentes de la
aplicación.
• è en un ficheros de configuración.
56
Componentes EJB - Roles • Establecer valores de configuración:
<env-entry> <env-entry-name>directorio-XML</env-entry-name> <env-entry-value>c:/datos/XML</env-entry-value>
</env-entry>
• Enlace entre componentes: <ejb-ref>
<ejb-link>Validador</ejb-link> <ejb-ref-name>ejb/validador</ejb-ref-name>
</ejb-ref>
• Transaccionalidad: <container-transaction>
<method> <ejb-name>Producto</ejb-name> <method-name>*</method-name>
</method> <trans-attribute>Required</trans-attribute>
</container-transaction>
57
Componentes EJB - Seguridad
• Programación declarativa de la seguridad.
• Definición de roles: <security-role>
<role-name>Gerente</role-name>
</security-role>
• Controlar la ejecución de los métodos: <method-permission>
<role-name>Gerente</role-name>
<method>
<ejb-name> Producto </ejb-name>
<method-name> setPrecioBase </ejb-name>
</method>
<method-permission>
• è Rol EJB administrador: • Asigna cuentas del sistema a roles de la aplicación.
58
EJB – Visión Cliente
• El contenedor EJB registra una referencia al objeto remoto Home de cada componente.
• El registro se hace en un Servicio de Nombres CORBA.
• Un cliente Java accede al registro configurando su contexto JNDI:
Context ctxInicio = new InitialContext();!!// Obtiene una referencia al Home del Producto!Object obj = ctxInicio.lookup("Producto");!ProductoHome productoHome = !
!(ProductoHome)PortableRemoteObject.narrow(obj, ProductoHome.class);!!Producto p = productoHome.findByPrimaryKey("1332343");!System.out.println(p.getNombre());!...
59
EJB – Otros Aspectos de Interés
• Componentes Message-Driven: • Componentes consumidores de mensajes asíncronos JMS. • Sin interfaces remoto y home. • Son componentes anónimos instanciados cuando son
necesarios.
• Guardar una referencia a un EJB en un fichero: • Método getHandle() de cualquier referencia EJB. • Objeto Handle es serializable: • Se puede guardar en un fichero.
• Método getEJBObject() de Handle: • Obtiene la referencia.
• Aplicar un narrow portable al tipo de la referencia.
60
Conclusiones
• Servidor de aplicaciones para implantar el modelo de un sistema de información: • Modelado de la lógica y objetos de negocio.
• Eficiente: controla el uso de los objetos.
• Diferente niveles de gestión de la persistencia.
• Transaccional, a través de reglas declarativas.
• Reglas de seguridad declarativas.
• Orientado a la programación con componentes.
• Independiente de la plataforma: • Ejecución Java y protocolo CORBA/IIOP.
• Muchos servidores de aplicaciones: WebLogic, JRun, JBoss ...
• è Tecnología ideal para la implantación de un sistema de información enterprise en Java.