PersistenceUnit vs PersistenceContext
EntityManager
obtained via @PersistenceContext
is called Container Managed EntityManager
as container will be responsible for managing "EntityManager
". EntityManager
obtained via @PersistenceUnit
/ entityManagerFactory.createEntityManager()
is managed in the application by the developer. (for e.g. managing lifecycle of EntityManager
, releasing the resources acquired by EntityManager
, etc.).
PersistenceUnit
injects an EntityManagerFactory
, and PersistenceContext
injects an EntityManager
. It's generally better to use PersistenceContext
unless you really need to manage the EntityManager
lifecycle manually.
I don't know how it works exactly in the Java EE, but in Spring, when you specify @PersistenceContext
annotation, it injects EntityManager
. Where does it get EntityManager
? It is wrong to create one EntityManager
for the whole application lifetime by calling EntityManagerFactory.createEntityManager()
. So instead a special implementation of EntityManager
interface is used and instantiated directly. It has an internal mutable thread-local reference to a real EntityManager
. Implementations of methods just redirect calls to this real EntityManager
. And there is a servlet listener, that before each request obtain EM
by calling EMF.createEntityManager()
and assign it to that inner reference of special EM
. Also this listener manages transactions by calling getTransaction().begin()
, .commit()
and .rollback()
on the real EM
. It is very simplified description of performed work. And I believe, that JEE container does the same thing, as Spring does.
In general case it is better to inject EntityManager
, because with EntityManagerFactory
and @PersistenceUnit
you should create/destroy EntityManager
every time by hands and manage transactions too.