web server - Borland Technical Publications

Client view of an enterprise bean
remote interface--sort() and merge()--to do its sorting work. When the work finishes,
the client calls the remote interface's remove() method to remove the instance of the
enterprise bean.
Session beans
A client obtains a reference to a session bean's remote interface by calling one of the
create methods on the home interface.
All session beans must have at least one create() method. A stateless session bean
must have only one create() method, and that method must have no arguments. A
stateful session bean can have one create() method, and may have additional
create() methods whose parameters vary. If a create() method does have parameters,
the values of these parameters are used to initialize the session bean.
The default create() method has no parameters. For example, the sort example uses a
stateless session bean. It has, by definition, one create() method that takes no
parameters:
Sort sort = home.create();
The cart example, on the other hand, uses a stateful session bean, and its home
interface, CartHome, implements more than one create() method. One of its create()
methods takes three parameters, which together identify the purchaser of the cart
contents, and returns a reference to the Cart remote interface. The CartClient sets
values for the three parameters--cardHolderName, creditCardNumber, and expirationDate-
-then calls the create() method. This is shown in the code sample below:
Cart cart;
{
String cardHolderName = "Jack B. Quick";
String creditCardNumber = "1234-5678-9012-3456";
Date expirationDate = new GregorianCalendar(2001, Calendar.JULY,
1).getTime();
cart = home.create(cardHolderName, creditCardNumber, expirationDate);
}
Session beans do not have finder methods.
Entity beans
A client obtains a reference to an entity object either through a find operation or a
create operation. Recall that an entity object represents some underlying data stored in
a database. Because the entity bean represents persistent data, entity beans typically
exist for quite a long time; certainly for much longer than the client applications that call
them. Thus, a client most often needs to find the entity bean that represents the piece
of persistent data of interest, rather than creating a new entity object, which would
create and store new data in the underlying database.
A client uses a find operation to locate an existing entity object, such as a specific row
within a relational database table. That is, find operations locate data entities that have
previously been inserted into data storage. The data may have been added to the data
store by an entity bean or it may have been added outside of the EJB context, such as
directly from within the database management system (DBMS). Or, in the case of
legacy systems, the data may have existed prior to the installation of the EJB
container.
A client uses an entity bean object's create() method to create a new data entity that
will be stored in the underlying database. An entity bean's create() method inserts the
entity state into the database, initializing the entity's variables according to the values in
the create() method's parameters. A create() method for an entity bean always returns
the remote interface, but the corresponding ejbCreate() method returns primary key of
the entity instance.
Chapter 11: Writing enterprise bean clients 87