Vamos a ver un diagrama para no perder la visión de conjunto. Lo haremos ayudándonos de un ejemplo en el que la clase AccountEJB representa al Bean de una cuenta.

En el código fuente del cliente se refleja estas relaciones con los elementos del EJB. Para simplificar el cliente es una sencilla aplicación Java en modo texto. Importa recalcar que el cliente accede al Bean por medio de referencias del interfaz remoto (Account).

import java.util.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.rmi.PortableRemoteObject;

public class AccountClient {

   public static void main(String[] args) {

       try {
	   ////// Creo un contexto
           Context initial = new InitialContext();
           Object objref = initial.lookup("MyAccount");

	   ////// Para obtener un interfaz Home
           AccountHome home = 
               (AccountHome)PortableRemoteObject.narrow(objref, 
                                            AccountHome.class);

	   ////// Crea los Beans, referenciados por su interfaz remoto o "vista del bean" (Account)
           Account duke = home.create("123", "Duke", "Earl", 0.00);

	   ////// Accedo al Bean por medio del interfaz remoto
           duke.credit(88.50);
           duke.debit(20.25);
           double balance = duke.getBalance();
           System.out.println("balance = " + String.valueOf(balance));
           duke.remove();
           ....

Es un interfaz que declara los métodos de lógica de negocio implementados en el EntityBean. Es el intermediario con el Bean:

import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Account extends EJBObject {
    
    public void debit(double amount)
        throws InsufficientBalanceException, RemoteException;

    public void credit(double amount)
        throws RemoteException;
    
    public double getBalance()
        throws RemoteException;
}

Es un interfaz responsable de la creación y localización de los objetos Bean:

import java.util.Collection;
import java.rmi.RemoteException;
import javax.ejb.*;

public interface AccountHome extends EJBHome {

    public Account create(String id, String firstName,
                          String lastName)
        throws RemoteException, CreateException;
    
    public Account findByPrimaryKey(String id) 
        throws FinderException, RemoteException;
    
    public Collection findByLastName(String lastName)
        throws FinderException, RemoteException;

    public Collection findInRange(double low, double high)
        throws FinderException, RemoteException;
}

• Los datos que nos interesan de la base de datos aparecen como atributos (id, nombre, balance, etc.). Además suele tener atributos no asociados directamente con la base de datos.



• Puesto que implementa el interfaz EntityBean debe definir los métodos de dicho interfaz: load(), etc.



• Define los métodos de negocio, como por ejemplo, los que definen la forma de calcular el balance: debit(), credit(), etc.



• En este ejemplo el bean es el responsable de la persistencia, por ello accede por medio de JDBC a la base de datos.



• Observar la implementación de otra regla de negocio: si se trata de crear un objeto que tiene un balance negativo, no se llega a realizar la instancia y se lanza una excepción.

import java.sql.*;
import javax.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.*;

public class AccountEJB implements EntityBean {

    private String id;
    private String firstName;
    private String lastName;
    private double balance;
    private Connection con;
    private String dbName = "java:comp/env/jdbc/AccountDB";

    public void debit(double amount) 
       throws InsufficientBalanceException {

       if (balance - amount < 0) {
           throw new InsufficientBalanceException();
       }
       balance -= amount;
    }

    public void credit(double amount) {

       balance += amount;
    }
    
    public double getBalance() {

       return balance;
    }

    public String ejbCreate(String id, String firstName, 
       String lastName, double balance)
       throws CreateException {

       if (balance < 0.00) {
          throw new CreateException
             ("A negative initial balance is not allowed.");
       }

       try {
          insertRow(id, firstName, lastName, balance);
       } catch (Exception ex) {
           throw new EJBException("ejbCreate: " + 
              ex.getMessage());
       }

       this.id = id;
       this.firstName = firstName;
       this.lastName = lastName;
       this.balance = balance;

       return id;
    }
	....