Académique Documents
Professionnel Documents
Culture Documents
Entity bean- An instance of these persistent EJBs represents an object view of the data,
usually rows in a database. They have a primary key as a unique identifier. Entity bean
persistence can be either container-managed or bean-managed.
Message-driven bean- An instance of these EJBs is integrated with the Java Message
Service (JMS) to provide the ability for message-driven beans to act as a standard JMS
message consumer and perform asynchronous processing between the server and the JMS
message producer.
Session beans are used to manage the interactions of entity and other session
beans,access resources, and generally perform tasks on behalf of the client.
There are two basic kinds of session bean: stateless and stateful.
Stateless session beans are made up of business methods that behave like
procedures; they operate only on the arguments passed to them when they are
invoked. Stateless beans are called stateless because they are transient; they do not
maintain business state between method invocations.Each invocation of a stateless
business method is independent from previous invocations. Because stateless
session beans are stateless, they are easier for the EJB container to manage, so they
tend to process requests faster and use less resources.
Stateful session beans encapsulate business logic and state specific to a client.
Stateful beans are called "stateful" because they do maintain business state between
method invocations, held in memory and not persistent. Unlike stateless session
beans, clients do not share stateful beans. When a client creates a stateful bean,
that bean instance is dedicated to service only that client. This makes it possible to
maintain conversational state, which is business state that can be shared by
methods in the same stateful bean.
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. Vendor tools are used to map
the entity fields to the database and absolutely no database access code is written in
the bean class.
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 command.
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 unsetEntityContext() method is used at the end of the bean's life cycle before
the instance is evicted from memory to dereference the EntityContext and perform
any last-minute clean-up.
The ejbLoad() and ejbStore() methods in CMP entities are invoked when the entity
bean's state is being synchronized with the database. The ejbLoad() is invoked just
after the container has refreshed the bean container-managed fields with its state
from the database. The ejbStore() method is invoked just before the container is
about to write the bean container-managed fields to the database. These methods
are used to modify data as it's being synchronized. This is common when the data
stored in the database is different than the data used in the bean fields.
The ejbPassivate() and ejbActivate() methods are invoked on the bean by the
container just before the bean is passivated and just after the bean is activated,
respectively. Passivation in entity beans means that the bean instance is
disassociated with its remote reference so that the container can evict it from
memory or reuse it. It's a resource conservation measure the container employs to
reduce the number of instances in memory. A bean might be passivated if it hasn't
been used for a while or as a normal operation performed by the container to
maximize reuse of resources. Some containers will evict beans from memory, while
others will reuse instances for other more active remote references. The
ejbPassivate() and ejbActivate() methods provide the bean with a notification as to
when it's about to be passivated (disassociated with the remote reference) or
activated (associated with a remote reference).
3.A bean object (an object, which actually performs business logic and EJB-specific
operations).
4. A deployment descriptor (an XML file containing all information required for
maintaining the EJB) or a set of deployment descriptors (if you are using some container-
specific features).
2. Transaction_read_committed- Guarantees that the data you are getting has been
committed.
1 Q What is EJB? A
Enterprise JavaBeans (EJB) technology is the server-side component architecture for the
Java 2 Platform, Enterprise Edition (J2EE) platform. EJB technology enables rapid and
simplified development of distributed, transactional, secure and portable applications
based on Java technology.
2 Q What are the different type of Enterprise JavaBeans ? A There are 3 types of
enterprise beans, namely: Session bean, Entity beans and Message driven beans. 3 Q
What is Session Bean ? A
Session bean represents a single client inside the J2EE server. To access the application
deployed in the server the client invokes methods on the session bean. The session bean
performs the task shielding the client from the complexity of the business logic.
There are two types of session beans, namely: Stateful and Stateless.
Stateful session bean maintain the state of the conversation between the client and itself.
When the client invokes a method on the bean the instance variables of the bean may
contain a state but only for the duration of the invocation.
A stateful session bean is an enterprise bean (EJB component) that acts as a server-side
extension of the client that uses it. The stateful session bean is created by a client and will
work for only that client until the client connection is dropped or the bean is explicitly
removed. The stateful session bean is EJB component that implements the
javax.ejb.SessionBean interface and is deployed with the declarative attribute "stateful".
Stateful session beans are called "stateful" because they maintain a conversational state
with the client. In other words, they have state or instance fields that can be initialized
and changed by the client with each method invocation. The bean can use the
conversational state as it process business methods invoked by the client.
Stateless session beans are of equal value for all instances of the bean. This means the
container can assign any bean to any client, making it very scalable.
A stateless session bean is an enterprise bean that provides a stateless service to the
client. Conceptually, the business methods on a stateless session bean are similar to
procedural applications or static methods; there is no instance state, so all the data needed
to execute the method is provided by the method arguments. The stateless session bean is
an EJB component that implements the javax.ejb.SessionBean interface and is deployed
with the declarative attribute "stateless". Stateless session beans are called "stateless"
because they do not maintain conversational state specific to a client session. In other
words, the instance fields in a stateless session bean do not maintain data relative to a
client session. This makes stateless session beans very lightweight and fast, but also
limits their behavior. Typically an application requires less number of stateless beans
compared to stateful beans.
8 Q What are different types of entity beans? A There are two types of entity beans
available. Container Managed Persistence (CMP) , Bean managed persistence (BMP). 9
Q What is CMP (Container Managed Persistence) ? A
The term container-managed persistence means that the EJB container handles all
database access required by the entity bean. The bean's code contains no database access
(SQL) calls. As a result, the bean's code is not tied to a specific persistent storage
mechanism (database). Because of this flexibility, even if you redeploy the same entity
bean on different J2EE servers that use different databases, you won't need to modify or
recompile the bean's code. So, your entity beans are more portable.
11 Q What is abstract schema ? A In order to generate the data access calls, the
container needs information that you provide in the entity bean's abstract schema. It is a
part of Deployment Descriptor. It is used to define the bean's persistent fields and relation
ships. 12 Q When we should use Entity Bean ? A
When the bean represents a business entity, not a procedure. we should use an entity
bean. Also when the bean's state must be persistent we should use an entity bean. If the
bean instance terminates or if the J2EE server is shut down, the bean's state still exists in
persistent storage (a database).
At any given time, only one client has access to the bean instance. The state of the bean is
not persistent, existing only for a short period (perhaps a few hours). The bean
implements a web service. Under all the above circumstances we can use session beans.
The bean's state represents the interaction between the bean and a specific client. The
bean needs to hold information about the client across method invocations. The bean
mediates between the client and the other components of the application, presenting a
simplified view to the client. Under all the above circumstances we can use a stateful
session bean.
The bean's state has no data for a specific client. In a single method invocation, the bean
performs a generic task for all clients. For example, you might use a stateless session
bean to send an email that confirms an online order. The bean fetches from a database a
set of read-only data that is often used by clients. Such a bean, for example, could
retrieve the table rows that represent the products that are on sale this month. Under all
the above circumstance we can use a stateless session bean.