Ability to switch Persistence Unit dynamically within the application (JPA)

Question

My application data access layer is built using Spring and EclipseLink and I am currently trying to implement the following feature - Ability to switch the current/active persistence unit dynamically for a user. I tried various options and finally ended up doing the following.

In the persistence.xml, declare multiple PUs. Create a class with as many EntityManagerFactory attributes as there are PUs defined. This will act as a factory and return the appropriate EntityManager based on my logic

public class MyEntityManagerFactory {
  @PersistenceUnit(unitName="PU_1")
  private EntityManagerFactory emf1;

  @PersistenceUnit(unitName="PU_2")
  private EntityManagerFactory emf2;

  public EntityManager getEntityManager(int releaseId) {
    // Logic goes here to return the appropriate entityManeger
 }
}

My spring-beans xml looks like this..

<!--  First persistence unit  -->    
<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="emFactory1">
  <property name="persistenceUnitName" value="PU_1" />
</bean>
<bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager1">
  <property name="entityManagerFactory" ref="emFactory1"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager1"/>

The above section is repeated for the second PU (with names like emFactory2, transactionManager2 etc).

I am a JPA newbie and I know that this is not the best solution. I appreciate any assistance in implementing this requirement in a better/elegant way!

Thanks!

Answer 1

I am also looking for a similar solution.

Answer 2

I am not sure if this is a clean method. Instead of declaring the enitiymanagerfactory multiple times, we can use the spring application context to get the entitymanagerfactory declared in the spring application.xml.

hm = applicationContext.getBeansOfType(org.springframework.orm.jpa.LocalEntityManagerFactoryBean.class);
EntityManagerFactory emf = ((org.springframework.orm.jpa.LocalEntityManagerFactoryBean) hm.get("&emf1")).getNativeEntityManagerFactory();
EntityManagerFactory emf2 = ((org.springframework.orm.jpa.LocalEntityManagerFactoryBean) hm.get("&emf2")).getNativeEntityManagerFactory();

Answer 3

This is something i need to do in the future too, for this i have bookmarked Spring DynamicDatasourceRouting

http://blog.springsource.com/2007/01/23/dynamic-datasource-routing/

As far as i understand, this is using one PU, which gets assigned different DataSources. Perhaps it is helpful.

Answer 4

First of all thanks to user332768 and bert. I tried using AbstractRoutingDataSource as mentioned in the link provided by bert, but got lost trying to hook up my jpa layer (eclipselink). I reverted to my older approach with some modifications. The solution looks cleaner (IMHO) and is working fine. (switching database at runtime and also writing to multiple databases in the same transaction)

public class MyEntityManagerFactoryImpl implements MyEntityManagerFactory, ApplicationContextAware {

    private HashMap<String, EntityManagerFactory> emFactoryMap;

    public EntityManager getEntityManager(String releaseId) {
        return SharedEntityManagerCreator.createSharedEntityManager(emFactoryMap.get(releaseName));
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        Map<String, LocalContainerEntityManagerFactoryBean> emMap = applicationContext.getBeansOfType(LocalContainerEntityManagerFactoryBean.class);
        Set<String> keys = emMap.keySet();
        EntityManagerFactory entityManagerFactory = null;
        String releaseId = null;
        emFactoryMap = new HashMap<String, EntityManagerFactory>();
        for (String key:keys) {
            releaseId = key.split("_")[1];
            entityManagerFactory = emMap.get(key).getObject();
            emFactoryMap.put(releaseId, entityManagerFactory);
        }
    }
}

I now inject my DAO's with an instance (singleton) of MyEntityManagerFactoryImpl. The dao will then simply call createSharedEntityManager with the required release and will get the correct EntityManager for that database. (Note that i am now using application managed EntityManager and hence i have to explicitly close them in my dao)

I also moved to jta transaction manager (to manage transaction across multiple databases) This is how my spring xml looks like now.

...
<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="em_Rel1">
        <property name="persistenceUnitName" value="PU1" />
</bean>
<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="em_Rel2">
        <property name="persistenceUnitName" value="PU2" />
</bean>

<bean class="org.springframework.transaction.jta.JtaTransactionManager" id="jtaTransactionManager">
</bean>
<tx:annotation-driven transaction-manager="jtaTransactionManager"/>
....

Cheers! (comments are welcome)