用于 EntityManager bean 的@Autowired vs@PersisenceContext

@PersistenceContext is a JPA 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

@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: http://www.coderanch.com/t/481448/java-EJB-SCBCD/certification/unitName-PersistenceContext

@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: https://stackoverflow.com/a/42074452/2623162

EntityManager instances are not thread-safe.

Source: https://docs.oracle.com/cd/E19798-01/821-1841/bnbqy/index.html

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

https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.misc.jpa-context

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: