Technical Interview Questions
Oracle Interview Questions
J2EE Interview Questions
EJB Interview Questions and Answers
What are the methods of
Entity Bean?What is the difference between Container-Managed Persistent (CMP)
bean and Bean-Managed Persistent(BMP) ?
Container-managed persistence beans are the simplest for the bean developer to
create and the most difficult for the EJB server to support. This is because all
the logic for synchronizing the beanís state with the database is handled
automatically by the container. This means that the bean developer doesnít need
to write any data access logic, while the EJB server is supposed to take care of
all the persistence needs automatically. With CMP, the container manages the
persistence of the entity bean. A CMP bean developer doesnít need to worry about
JDBC code and transactions, because the Container performs database calls and
transaction management instead of the programmer. Vendor tools are used to map
the entity fields to the database and absolutely no database access code is
written in the bean class. All table mapping is specified in the deployment
descriptor. Otherwise, a BMP bean developer takes the load of linking an
application and a database on his shoulders.
The bean-managed persistence (BMP) enterprise bean manages synchronizing its
state with the database as directed by the container. The bean uses a database
API to read and write its fields to the database, but the container tells it
when to do each synchronization operation and manages the transactions for the
bean automatically. Bean-managed persistence gives the bean developer the
flexibility to perform persistence operations that are too complicated for the
container or to use a data source that is not supported by the container.BMP
beans are not 100% database-independent, because they may contain
database-specific code, but CMP beans are unable to perform complicated DML
(data manipulation language) statements. EJB 2.0 specification introduced some
new ways of querying database (by using the EJB QL - query language).
What are the methods of
An entity bean consists of 4 groups of methods:
1. create methods: To create a new instance of a CMP entity bean, and
therefore insert data into the database, the create() method on the beanís
home interface must be invoked. They look like this: EntityBeanClass
ejbCreateXXX(parameters), where EntityBeanClass is an Entity Bean you are
trying to instantiate, ejbCreateXXX(parameters) methods are used for
creating Entity Bean instances according to the parameters specified and to
some programmer-defined conditions.
A beanís home interface may declare zero or more create() methods, each of
which must have corresponding ejbCreate() and ejbPostCreate() methods in the
bean class. These creation methods are linked at run time, so that when a
create() method is invoked on the home interface, the container delegates
the invocation to the corresponding ejbCreate() and ejbPostCreate() methods
on the bean class.
2. finder methods: The methods in the home interface that begin with ďfindĒ
are called the find methods. These are used to query the EJB server for
specific entity beans, based on the name of the method and arguments passed.
Unfortunately, there is no standard query language defined for find methods,
so each vendor will implement the find method differently. In CMP entity
beans, the find methods are not implemented with matching methods in the
bean class; containers implement them when the bean is deployed in a vendor
specific manner. The deployer will use vendor specific tools to tell the
container how a particular find method should behave. Some vendors will use
object-relational mapping tools to define the behavior of a find method
while others will simply require the deployer to enter the appropriate SQL
There are two basic kinds of find methods: single-entity and multi-entity.
Single-entity find methods return a remote reference to the one specific
entity bean that matches the find request. If no entity beans are found, the
method throws an ObjectNotFoundException . Every entity bean must define the
single-entity find method with the method name findByPrimaryKey(), which
takes the beanís primary key type as an argument.
The multi-entity find methods return a collection ( Enumeration or
Collection type) of entities that match the find request. If no entities are
found, the multi-entity find returns an empty collection.
3. remove methods: These methods (you may have up to 2 remove methods, or
donít have them at all) allow the client to physically remove Entity beans
by specifying either Handle or a Primary Key for the Entity Bean.
4. home methods: These methods are designed and implemented by a developer,
and EJB specification doesnít have any requirements for them except the need
to throw a RemoteException is each home method
Page Numbers :