1.2. EJB container environment
1.2.1. Container-managed entit y manager
The most common and widely used entity manager in a Java EE environment is the container-managed
entity manager. In this mode, the container is responsible for the opening and closing of the entity
manager (this is transparent to the application). It is also responsible for transaction boundaries. A
container-managed entity manager is obtained in an application through dependency injection or through
JNDI lookup. A container-managed entity manger requires the use of a JT A transaction.
1.2.2. Application-managed entity manager
An application-managed entity manager allows you to control the entity manager in application code.
This entity manager is retrieved through the EntityManagerFactory API. An application managed
entity manager can be either involved in the current JTA transaction (a JT A entity manager), or the
transaction may be controlled through the EntityTransaction API (a resource-local entity manager).
The resource-local entity manager transaction maps to a direct resource transaction (i. e. in Hibernate's
case a JDBC transaction). The entity manager type (JTA or resource-local) is defined at configuration
time, when setting up the entity manager factory.
1.2.3. Persist ence cont ext scope
An entity manager is the API to interact with the persistence context. T wo common strategies can be
used: binding the persistence context to the transaction boundaries, or keeping the persistence context
available across several transactions.
The most common case is to bind the persistence context scope to the current transaction scope. T his
is only doable when JT A transactions are used: the persistence context is associated with the JTA
transaction life cycle. When a entity manager is invoked, the persistence context is also opened, if there
is no persistence context associated with the current JTA transaction. Otherwise, the associated
persistence context is used. T he persistence context ends when the JTA transaction completes. This
means that during the JT A transaction, an application will be able to work on managed entities of the
same persistence context. In other words, you do not have to pass the entity manager's persistence
context across your EJB method calls, but simply use dependency injection or lookup whenever you
need an entity manager.
You can also use an extended persistence context. T his can be combined with stateful session beans, if
you use a container-managed entity manager: the persistence context is created when an entity
manager is retrieved from dependency injection or JNDI lookup, and is kept until the container closes it
after the completion of the Remove stateful session bean method. T his is a perfect mechanism for
implementing a "long" unit of work pattern. For example, if you have to deal with multiple user interaction
cycles as a single unit of work (e.g. a wizard dialog that has to be fully completed), you usually model
this as a unit of work from the point of view of the application user, and implement it using an extended
persistence context. Please refer to the Hibernate reference manual or the book Hibernate In Action for
more information about this pattern. JBoss Seam is a framework that link together JSF and EJB3 around
the notion of conversation and unit of work. For an application-managed entity manager the persistence
context is created when the entity manager is created and kept until the entity manager is closed. In an
extended persistence context, all modification operations (persist, merge, remove) executed outside a
transaction are queued until the persistence context is attached to a transaction. The transaction
typically occurs at the user process end, allowing the whole process to be committed or rolled back. For
application-managed entity manager only support the extended persistence context.
A resource-local entity manager or an entity manager created with
EntityManagerFactory.createEntityManager() (application-managed) has a one-to-one
relationship with a persistence context. In other situations persistence context propagation occurs.