Enterprise JavaBeans 3

Aplicaciones Distribuidas
 Contenido
•  Introducción

•  Motivación

•  Características básicas

•  Servicios integrados en EJB 3

•  Ejemplo ‘Hola Mundo’

•  Inyección de dependencia

•  Tipos de EJB 3

•  Conclusiones
2
 Introducción

•  EJB 3.0 es una tecnología basada en J2EE que proporciona

una arquitectura portable, reusable, escalable, transaccional y
multiusuario.

•  Desde el punto de vista del desarrollador, un EJB es una

porción de código que se ejecuta en un contenedor EJB

•  Con la introducción de EJB 3.0 se consigue:

•  La estandarización de una estructura de persistencia (EJB es
una especificación no un Framework ni una herramienta)
•  Hace más fácil el desarrollo de EJB

3
•  En la especificación 3.0, los EJB no son más que
POJOs con servicios implicitos, que se activan
en runtime cuando son ejecutados en un contenedor
de EJBs.

4
•  Los servicios que debe proveer el contenedor de EJBs deben ser
especificados por el programador a través de metadatos:
•  Anotaciones de Java5 intercaladas en el código de las clases.
•  Descriptores XML (archivos XML separados).

•  Las técnicas no son exclusivas(en el caso de superponerse, los

XML tendrán prioridad sobre las anotaciones)

5
•  Existen tres tipos de EJBs:

•  Session Beans: componentes para la lógica de negocio. Hay dos tipos

de Session Beans: Stateless y Stateful. El primero no conserva el estado
de ninguno de sus atributos de la invocación de un método a otro y
el segundo conserva el estado a lo largo de toda una sesión.
•  Message-Driven Beans (MDBs): para la lógica de negocio, son usados
para invocar métodos de forma asincrónica. Los MDBs encapsulan
se usan sobre JMS.
•  Entities: para la capa de persistencia y son los EJBs que se manejan
en Java Persistence API(JPA). Incluidos desde la especificación de
EJB 3.0.

6
 Motivación

•  Limitaciones EJB 2.x

•  Crear múltiples descriptores de despliegue XML para un solo EJB.
Se prefieren alternativas como XDoclet.
•  Se crean múltiples métodos callbacks usualmente inutilizados.
•  Se deben crear las interfaces: remote y local, las interfaces home:
remote y local, y finalmente la clase Bean.
•  Imposibilidad de probar (testear) EJB fuera del contexto del
contenedor de EJB, desde componentes como entity beans
(container-managed) que son clases abstractas.
•  EJB-QL tiene limitaciones en funcionalidad y dificultades de uso
(principalmente en funciones de sumarización para agrupamientos,
causa que propicio la aparición de extensiones propietarias del
lenguaje EJB-QL). Búsqueda de otras alternativas como Toplink e
Hibernate.

7
 Características básicas
•  No necesario el uso de descriptores XML (uso de metadatos)
•  Anotaciones como tipo de programación orientado a atributos
(similar a XDoclet).

import javax.ejb.*;
@Stateless
public class MyAccountBean implements MyAccount
{
@Tx(TxType.REQUIRED)
@MethodPermission({"customer"})
public void deposit(double money) {...}
}

@Stateless nos indica que el bean es stateless.

@Tx es un atributo que indica la demarcación transaccional para el método
deposit.
@MethodPermission especifica a los usuarios quienes están permitidos para usar
el método
deposit.
8
•  Nuevo modelo de programación basado en POJOs
•  JPA desde EJB 3.0
•  El contenedor genera automáticamente la interfaz considerando
métodos public

•  Simplicidad métodos Callbacks

•  Antes un gran número de métodos de retrollamada ejbActive(),
ejbPassivate(), ejbLoad(), etc.
•  En la nueva especificación se puede asignar un método cualquiera
como método callback para recibir notificación por eventos de ciclo
de vida.
•  Cada método es declarado mediante una anotación, la cual describe
uno de los muchos eventos de ciclo de vida.
•  Ej: PostContruct, PreDestroy, PostActivate, PrePassivate, PostPersist.

9
@Entity

public class AccountBean

@PostPersist insertAccountDetails (AccountDetails

accountDetails)

public void createAccount(){}

}
10
 Servicios integrados en
EJB 3
•  Integración: Proveen una forma de acoplar en tiempo de
ejecución diferentes componentes (se puede hacer
mediante Inyección de Dependencia o usando JNDI)

•  Pooling: El contenedor de EJBs crea para componentes EJB

un pool de instancias que es compartido por los diferentes
clientes. 

•  Thread-safely: El programador puede escribir componentes del

lado del servidor como si estuviera trabajando en una
aplicación sencilla con un solo thread. El contenedor da el
soporte multiusuario

•  Administración de Estados: El contenedor de EJBs almacena

y maneja el estado del EJB
11
•  Transacciones: EJB soporta el manejo de transacciones
declarativas que permiten agregar comportamiento
transaccional a un componente simplemente usando
anotaciones o XMLs de configuración.

•  Seguridad: EJB soporta integración con la Java Authentication

and Authorization Service (JAAS) API, haciendo casi
transparente el manejo transversal de la seguridad

•  Acceso Remoto: Es posible acceder de forma remota a

distintos EJBs de forma sencilla mediante la Inyección de
Dependencia.

12
•  Web Services: Un Stateless Session Bean puede publicar sus
métodos como web services mediante una sencilla anotación

•  Persistencia: EJB 3 provee la especificación JPA para el mapeo

de objetos (Entities) a tablas.

•  Catching and Performance: JPA provee de forma transparente

un importante número de servicios que permiten usar
un caché de entidades en memoria y lectura/escritura sobre
base de datos de manera eficiente.

13
 Ejemplo ‘Hola Mundo’
package ejb3inaction.example;

public interface HelloUser {
public void sayHello(String name);

package ejb3inaction.example;

import javax.ejb.Stateless;

@Stateless

public class HelloUserBean implement HelloUser {

public void sayHello(String name) {

System.out.println(“Hola " + name);

}
14
 Inyección de dependencia
•  La Inyección de Dependencia (ID) es un concepto (o patrón)
de arquitectura  que  se especializa en inyectar objetos en una
clase, en lugar de ser la propia clase quien cree el objeto

•  En EJB 3 es el contenedor de EJBs quien inyecta en cada

objeto los objetos necesarios según las relaciones plasmadas en
los descriptores de despliegue o en las anotaciones.

•  Ejemplo ‘Hola Mundo’:

•  La anotación @EJB es una orden directa al contenedor de
EJBs para que cree una instancia de HelloUser con la
implementación proporcionada del lado del servidor

15
•  La inyeccion de dependecias sirve para desacoplar
completamente una interface de su implementación
•  En el ejemplo, gracias al polimorfismo podemos usar la
interface HelloUser sin conocer HelloUserBean y además
evitamos new HelloUserBean()

•  ID reemplaza el rutinario código de JNDI lookup usado

en EJB 2.
•  Cuando se usa JNDI, es responsabilidad del cliente buscar y
obtener la referencia al objeto. La ID es exactamente lo
opuesto a JNDI: es responsabilidad del contenedor
inyectar un objeto basado en una dependencia declarada.

16
•  La inyección de dependencias para el uso de entidades
requiere @PresistenceContext:

@Stateless 
public class PlaceBidBean implements PlaceBid {

@PersistenceContext(unitName="actionBazaar")
private EntityManager entityManager;
...
private Bid save(Bid bid) {
entityManager.persist(bid);
return bid;
}
}

17
•  Inyección de recursos

@Resource(name=”jdbc/ActionBazaarDS”)

private DataSource dataSource;

private DataSource dataSource;

@Resource(name=”jdbc/ActionBazaarDB”)

public void setDataSource(DataSource dataSource) {

this.dataSource = dataSource;

}
18
•  ejb-jar.xml
<resource-ref>
<res-ref-name>jdbc/ActionBazaarDS</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
<res-sharing-scope>Shareable</res-sharing-scope>
<injection-target>
<injection-target-class>
actionbazaar.buslogic.BidManagerBean</injection-target-class>
<injection-target-name>dataSource</injection-target-name>
</injection-target>

</resource-ref>

19
•  Inyección de dependencias de EJB de Sesión
@EJB(name=”BidManagerRemote”)
private BidManager bidManager;

•  ejb-jar.xml

<ejb-ref>
<ejb-ref-name> BidManagerRemote</ejb-ref-name>
<ejb-ref-type>Session</ejb-ref-type>
<remote>example. BidManagerRemote</remote>
</ejb-ref>
20
 Tipos de EJB 3
Tipos: Beans de Sesion (con/sin estado), de Entidad y MDB

•  Stateless Session Beans

•  Clase Bean
•  Se define solo añadiendo la anotación @Stateless
@Stateless
public class TraderBean implements Trader{
public void buy (String symbol, int quantity){
System.out.println("Buying "+quantity+ " of "+ symbol);
}
public void sell (String symbol, int quantity);{
System.out.println("Selling "+quantity+ " of "+ symbol);
}
}
•  Cliente (usando JNDI)
private Trader tr = null;
public void initialize () {
try {
InitialContext ctx = new InitialContext();
tr = (Trader) ctx.lookup(Trader.class.getName());

21
•  Interface
•  Aunque son requeridas, no es necesario definirlas, ya que el contenedor es
capaz de generarlas
•  Puede ser definida como local (por defecto) o global
•  En una interfaz generada automáticamente se agregan todos los métodos
de la clase bean que han sido definidos públicos.
@Stateless
@Local ({Trader.class})
@Remote ({RemoteTrader.class})
public class TraderBean implements Trader, RemoteTrader
{
public void buy (String symbol, int quantity){
System.out.println("Buying "+quantity+ " of "+ symbol); }
public void sell (String symbol, int quantity);{
System.out.println("Selling "+quantity+ " of "+ symbol); }
}

22
•  Statefull Session Beans
•  Clase Bean
•  Mediante la anotación @Stateful
•  Cada stateful session bean necesita implementar la interfaz
serializable, para que de esta manera el contenedor pueda
serializar las instancias del bean y almacenarlas para preservar el
estado cuando las instancias no son usadas.

@Stateful
public class TraderBean implements Trader, Serializable
{
…
}

23
•  Entity Beans
•  La anotación asociada a este tipo de EJB es el @Entity y
todas sus propiedades y campos en la clase entity bean no
marcadas con la anotación @Transient son consideradas
persistentes

@Entity
public class Customer implements Serializable {
private Long id;
private String name;
@Id
public Long getId() { return id; }
…

24
 Conclusiones
•  EJB 3 es una especificación abierta de Sun Microsystem.
•  Para utilizar EJB 3 se requiere un contenedor de EJB 3 que
implemente la especificación (Glassfish, JBoss…).
•  El uso de EJBs en una aplicación nos abstrae de muchos
servicios transversales como: integración, pooling, mensajería,
transacciones, seguridad, dependencias, etc.

•  La especificación 3 de EJB presenta grandes ventajas frente a la

2:
•  el uso de anotaciones, en lugar de descriptores XML verbosos
•  un modelo de programación más liviano y menos intrusivo
•  una especificación de persistencia mucho más flexible (basada en
los ORM que ya existían en el mercado)
•  el uso de inyección de dependencia en lugar del uso directo de
JNDI lookup.
25