Enterprise JavaBeans · Enterprise JavaBeans Layer:07 Entity. Last Revised: 10/21/2001 Copyright (C) 2001 2 Agenda • Build entity beans

Enterprise JavaBeans

Layer:07

Entity

Last Revised: 10/21/2001 Copyright (C) 2001 2

Agenda

• Build entity beans.• Describe the bean's lifecycle.• Describe the server's free pool.

Entity Beans


Purpose

• Entity beans represent business data.• In general, an entity bean should only be

used to represent a conceptual entity that requires some kind of persistent storage.

• A poorly architected entity bean will destroy your performance.


Structure

• The bean class may extend any java class.• It must implement the EntityBean

interface.• Each entity bean must minimally provide a findByPrimaryKey() method.


Bean Instance Lifecycle


EntityBean Interface(1 of 2)

• The EntityBean interface declares a set of container-callback methods.

• These methods must be implemented by the bean class and are used by the container to manage the bean instance.

• The complete interface is on the following slide.


EntityBean Interface(2 of 2)

1. public interface EntityBeanextends EnterpriseBean {

2. public void ejbActivate();

3. public void ejbLoad();

4. public void ejbPassivate();

5. public void ejbRemove();

6. public void ejbStore();

7. public voidsetEntityContext(EntityContext sc);

8. public void unsetEntityContext()

9. }


ejbActivate(1 of 2)

• The ejbActivate() method is called by the container whenever an entity bean is "loaned out" from the free pool.

• This method should prepare the bean to perform work based on the business methods as well as the synchronization callbacks.


ejbActivate(2 of 2)

1. public void ejbActivate() {

2. // TODO: perform any required resource

3. // allocations to ensure that the

4. // bean is capable of handling

5. // business requests.

6. }


ejbLoad(1 of 2)

• The ejbLoad() method is called by the container whenever an entity bean is associated with an EJBObject.

• This method is used to synchronize the bean's internal data members with those of the underlying data store.

• The container is required to call this method at least once after the start of a transaction.


ejbLoad(2 of 2)

1. public void ejbLoad() {

2. // TODO: synchronize the bean's data

3. // members with the appropriate

4. // fields from the underlying data

5. // store.

6. //

7. // TODO: any final initialization to be

8. // complete prior to the invocation

9. // of a business method.

10. }


ejbPassivate(1 of 2)

• The ejbPassivate() method is called by the container whenever a bean is returned to the free pool.

• This method should set all persistable fields to null.


ejbPassivate(2 of 2)

1. public void ejbPassivate() {

2. // TODO: set all non-persistable fields

3. // to null.

4. }


ejbRemove(1 of 2)

• The ejbRemove() method is called by the container when:– A client calls the remove() method on their

remote reference or on the home interface.• For entity beans, a call to ejbRemove()

typically indicates that a physical delete against the database will be performed.


ejbRemove(2 of 2)

1. public void ejbRemove() {

2. // TODO: perform a physical or logical

3. // delete according to the business

4. // rules.

5. //

6. // TODO: de-allocate scarce resources and

7. // set object references to null to

8. // help the garbage collector.

9. }


ejbStore(1 of 2)

• The ejbStore() method is called by the container whenever an entity bean is dissociated with an EJBObject.

• This method is used to synchronize the underlying data store with the bean's internal data members.

• The container is required to call this method at least once before the end of a transaction.


ejbStore(2 of 2)

1. public void ejbStore() {

2. // TODO: any final initialization to be

3. // complete prior to persisting the

4. // bean's state.

5. //

6. // TODO: synchronize the underlying data

7. // store with the bean's internal

8. // data members.

9. }


setEntityContext(1 of 2)

• The setEntityContext() method is called by the container when the bean is first added to the free pool.

• Be sure to capture a reference to the EntityContext argument for later use.

• Use this method for one-time initialization with the benefit of the EntityContext.


setEntityContext(2 of 2)

1. public voidsetEntityContext(EntityContext ec) {

2. this.context = ec;

3. // TODO: any other one-time actions

4. }

EntityContext


Purpose

• The EntityContext interface inherits from the EJBContext.

• It provides additional methods that are critical for proper integration of the entity beans into their containers.


Structure(1 of 2)

1. public interface EntityContextextends EJBContext {

2. public EJBObject getEJBObject()throws IllegalStateException;

3. public Object getPrimaryKey()throws IllegalStateException;

4. }


Structure(2 of 2)

• Each of these methods can throw an IllegalStateException if it's invoked at any time while the bean instance is not associated with an EJBObject.

• We'll look at the lifecycles a bit later to see when this situation might occur.

Primary Keys


Purpose

• Primary keys are used to uniquely identify bean instances within a given home.

• Each primary key is associated with an EJBObject, not with a bean instance.

• This allows any bean instance to satisfy any business method on behalf of any client.

• This increases the scalability of the server.


Structure(1 of 2)

• Primary keys can be of any type although they should be compatible with RMI-IIOP.

• If we're dealing with only a single column key within the data store, then we can use one of the wrapper classes such as String, Double, or Integer.

• Otherwise we need to build a custom class.


Structure(2 of 2)

• Primary keys are often constructed using public data members to allow a performance improvement when using CMP.

• In EJB 2.0, this restriction was relaxed and now primary keys can follow the JavaBeans naming conventions.


BookKey

1. public class BookKeyimplements java.io.Serializable {

2. public String isbn = null;

3. public BookKey(String isbn) {

4. this.isbn = isbn;

5. }

6. public String getISBN() {

7. return this.isbn;

8. }9. }

Scalability


Free Pool(1 of 3)

• Entity beans are stored within a free pool.• This is similar to a database connection pool

in that entity bean instances are loaned out to clients on a demand basis.

• The policies around the use and management of this pool are left to the server and container providers.


Free Pool(2 of 3)

• The setEntityContext() method is called when the bean is first added to the free pool.

• The unsetEntityContext() method is called when the bean is removed from the free pool for the last time.


Free Pool(3 of 3)

• The ejbActivate() method is called when the bean is "loaned out" of the free pool.

• The ejbPassivate() method is called when the bean is returned to the free pool.

Runtime Environment


Creating Entity Beans


Creating(1 of 9)

• At some point the free pool will be populated with a set of entity bean instances.

• The specifics are left to the container.• When each bean is added to the free pool its setEntityContext() method will be called.


Creating(2 of 9)

• The client has already performed a JNDI lookup on the home interface as usual.

• When the client is ready to create a new entry in the backing store, then the client will call the appropriate create()method on the home interface.


Creating(3 of 9)

• The home object will request a bean instance of the free pool.

• The ejbActivate() method will be called on the bean instance to prepare it for the creation process.


Creating(4 of 9)

• The home object calls the ejbCreate()on the bean instance.

• The bean instance can perform any required preprocessing of the data.


Creating(5 of 9)

• The bean instance uses JDBC to perform that actual insertion into the database.

• It is the bean's job to catch and handle any SQLExceptions that might result from this process.


Creating(6 of 9)

• The primary key of the data that was just created is returned from the ejbCreate() method using the appropriate primary key type.

• It's the bean instance's job to create and populate the key.


Creating(7 of 9)

• The home object creates a new EJBObject.• The primary key returned from the ejbCreate() method is placed into that EJBObject.


Creating(8 of 9)

• The home object calls the appropriate version of the ejbPostCreate()method on the bean instance.

• This allows the bean to complete its initialization with access to the EJBObject.


Creating(9 of 9)

• The home object returns the remote reference to the client the same way that it was done using session beans.


Using Entity Beans


Using(1 of 6)

• Eventually the client invokes a business method on the entity bean's remote reference.


Using(2 of 6)

• The EJBObject asks the container for a bean instance to be used to satisfy the client's request.


Using(3 of 6)

• The container locates and activates a bean instance from the free pool.

• The bean's ejbActivate() method is called to make it method-ready.


Using(4 of 6)

• The container invokes the bean's ejbLoad() method to synchronize the bean's state with the state of the primary key associated with the EJBObject on which the client made the original call.


Using(5 of 6)

• The bean instance makes a call to the database to retrieve the appropriate data.


Using(6 of 6)

• The EJBObject makes the same call to the bean instance that the client made on the remote reference.


Passivating Entity Beans


Passivating(1 of 3)

• At some point the container will want the bean instance returned to the free pool so that it can be loaned to another client.

• The container will call the bean's ejbStore() method to synchronize the underlying backing store with the bean's state.


Passivating(2 of 3)

• The bean issues and appropriate update against the underlying data source.


Passivating(3 of 3)

• The container calls the bean's ejbPassivate() method and places the bean back into the free pool.


Removing Entity Beans


Removing(1 of 5)

• At some point the client may choose to remove the bean.

• The client calls the remove() method on their remote reference.


Removing(2 of 5)

• The EJBObject informs the container that it requires a bean to perform a remove.

• The container goes through the normal synchronization process when providing the bean instance to the EJBObject.


Removing(3 of 5)

• The container calls the bean's ejbRemove() method.


Removing(4 of 5)

• The bean issue's the appropriate database calls for the removal.

• This could be logical or physical.• The bean could throw an exception to

ensure that a deletion never takes place.


Removing(5 of 5)

• The container call's the bean's ejbPassivate() method and returns the bean instance to the free pool.


Design

• Entity beans are not meant to be table wrappers– This is one of the leading causes of poor

performance using entity beans.• They're meant to be course-grained business

objects.


Summary

• Build entity beans.• Describe the bean's lifecycle.• Describe the server's free pool.


Next Steps

• Please read chapter 6, pp.153-211.• Layer:07 homework will be available on the

course website.

Documents

Enterprise JavaBeans · Enterprise JavaBeans Layer:07 Entity. Last Revised: 10/21/2001 Copyright (C) 2001 2 Agenda • Build entity beans