How do you use Spring Data JPA outside of a Spring Container?

The general principle behind the design of JpaRepositoryFactory and the according Spring integration JpaRepositoryFactory bean is the following:

We're assuming you run your application inside a managed JPA runtime environment, not caring about which one.

That's the reason we rely on injected EntityManager rather than an EntityManagerFactory. By definition the EntityManager is not thread safe. So if dealt with an EntityManagerFactory directly we would have to rewrite all the resource managing code a managed runtime environment (just like Spring or EJB) would provide you.

To integrate with the Spring transaction management we use Spring's SharedEntityManagerCreator that actually does the transaction resource binding magic you've implemented manually. So you probably want to use that one to create EntityManager instances from your EntityManagerFactory. If you want to activate the transactionality at the repository beans directly (so that a call to e.g. repo.save(…) creates a transaction if none is already active) have a look at the TransactionalRepositoryProxyPostProcessor implementation in Spring Data Commons. It actually activates transactions when Spring Data repositories are used directly (e.g. for repo.save(…)) and slightly customizes the transaction configuration lookup to prefer interfaces over implementation classes to allow repository interfaces to override transaction configuration defined in SimpleJpaRepository.

I solved this by manually binding the EntityManager and EntityManagerFactory to the executing thread, before creating repositories with the JpaRepositoryFactory. This is accomplished using the TransactionSynchronizationManager.bindResource method:

emf = Persistence.createEntityManagerFactory("com.foo.model", properties);em = emf.createEntityManager();// Create your transaction manager and RespositoryFactoryfinal JpaTransactionManager xactManager = new JpaTransactionManager(emf);final JpaRepositoryFactory factory = new JpaRepositoryFactory(em);// Make sure calls to the repository instance are intercepted for annotated transactionsfactory.addRepositoryProxyPostProcessor(new RepositoryProxyPostProcessor() {    @Override    public void postProcess(ProxyFactory factory) {        factory.addAdvice(new TransactionInterceptor(xactManager, new MatchAlwaysTransactionAttributeSource()));    }});// Create your repository proxy instanceFooRepository repository = factory.getRepository(FooRepository.class);// Bind the same EntityManger used to create the Repository to the threadTransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));try{    repository.save(someInstance); // Done in a transaction using 1 EntityManger} finally {    // Make sure to unbind when done with the repository instance    TransactionSynchronizationManager.unbindResource(getEntityManagerFactory());}

There must be be a better way though. It seems strange that the RepositoryFactory was designed to use EnitiyManager instead of an EntityManagerFactory. I would expect, that it would first look to see if an EntityManger is bound to the thread and then either create a new one and bind it, or use an existing one.

Basically, I would want to inject the repository proxies, and expect on every call they internally create a new EntityManager, so that calls are thread safe.