@Autowired vs @PersistenceContext for EntityManager bean

What is the difference between:

@Autowired
private EntityManager em;

versus:

@PersistenceContext
private EntityManager em;

Both options work in my application, but can I break something by using the `@Autowired` annotation?

`@PersistenceContext` is a [JPA][1] standard annotation designed for that specific purpose. Whereas `@Autowired` is used for any dependency injection in Spring. Using `@PersistenceContext` gives you greater control over your context as it provides you with ability to specify optional elements e.g. name, properties


[1]:

[To see links please register here]

`@PersistenceContext` allows you to specify which persistence unit you want to use. Your project might have multiple data sources connected to different DBs and `@PersistenceContext` allows you to say which one you want to operate on

check the explanation here:

[To see links please register here]

**@PersistenceContext**:

**does not** return entity manager instance

**it returns** container-managed proxy that acquires and releases presistence context on behalf of the application code

You shouldn't use `@Autowired`.
`@PersistenceContext` takes care to create a unique EntityManager for every thread. In a production application you can have multiple clients calling your application in the same time. For each call, the application creates a thread. Each thread should use its own EntityManager. Imagine what would happen if they share the same EntityManager: different users would access the same entities.

usually the EntityManager or Session are bound to the thread (implemented as a ThreadLocal variable).

Source:

[To see links please register here]

EntityManager instances are not thread-safe.
Source:

[To see links please register here]

Please notice that `@PersistenceContext` annotation comes from `javax.persistence` package, not from spring framework. In JavaEE it is used by the JavaEE container (aka the application server) to inject the EntityManager. Spring borrowed the PersistenceContext annotation to do the same: to inject an **application-managed** (= not container-managed) EntityManager bean per thread, exactly as the JavaEE container does.

You can create the following `FactoryBean` to make `EntityManager` properly injectable, even via constructor injection:

/**
* Makes the {@link EntityManager} injectable via <i>@Autowired</i>,
* so it can be injected with constructor injection too.
* (<i>@PersistenceContext</i> cannot be used for constructor injection.)
*/
public static class EntityManagerInjectionFactory extends AbstractFactoryBean<EntityManager> {

@PersistenceContext
private EntityManager entityManager;

@Override
public Class<?> getObjectType() {
return EntityManager.class;
}

@Override
protected EntityManager createInstance() {
return entityManager;
}

}

Please note, that because we use the `@PersistenceContext` annotation internally, the returned `EntityManager` will be a proper thread-safe proxy, as it would have been injected directly at the place of usage with field injection (using `@PersistenceContext`).

I think @Autowire will work same way as @PersistenceContext

[

[To see links please register here]

][1]

> When working with multiple EntityManager instances and custom
> repository implementations, you need to wire the correct EntityManager
> into the repository implementation class. You can do so by explicitly
> naming the EntityManager in the @PersistenceContext annotation or, if
> the EntityManager is @Autowired, by using @Qualifier.
>
> As of Spring Data JPA 1.9, Spring Data JPA includes a class called
> JpaContext that lets you obtain the EntityManager by managed domain
> class, assuming it is managed by only one of the EntityManager
> instances in the application. The following example shows how to use
> JpaContext in a custom repository:


[1]:

[To see links please register here]