Spring+Hibernate动态切换数据源以及失败解决方案

前言

​ 本来只是动态数据源切换的话，是不准备记录下来当博客发表的。但是在使用Spring + Hibernate实现数据源切换时，遇到了切换失败的问题。无论是查看源码还是debug调试都解决不了，最后还是在网上找到了答案，这里留一个悬念。

​ 所以本文主旨在查阅大量资料后解决动态切换数据源失败的问题，顺便在前面介绍如何进行配置动态切换数据源。所有场景以Spring 4.2.6 + Hibernate 4.2.7 + proxool为标准，后文不再赘述。

正文

设计思路

​ Hibernate所有事务的操作都是和session绑定，而session由sessionFactory生成。sessionFactory作为一个重量级别的对象，不宜根据数据源的不同生成多个sessionFactory对象。这也是使用单例的原因。那么想动态切换数据源只能从sessionFactory依赖的dataSource动手。而Spring从2.0版本就提供了一个可以动态切换的数据源AbstractRoutingDataSource，那么所有的一切就有了解决方案：

设计实现

1. Spring关于数据源事务管理器的配置：

     
     <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/tx
             http://www.springframework.org/schema/tx/spring-tx.xsd">
   
   
        <bean id="parentDataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
           <property name="user" value="${jdbc.username}"/>
           <property name="driver" value="${jdbc.driverClassName}"/>
           <property name="maximumConnectionCount" value="1000"/>
           <property name="minimumConnectionCount" value="20"/>
           <property name="houseKeepingSleepTime" value="300000"/>
           <property name="simultaneousBuildThrottle" value="200"/>
           <property name="prototypeCount" value="5"/>
           <property name="maximumActiveTime" value="172800000"/>
           <property name="maximumConnectionLifetime" value="180000000"/>
           <property name="testBeforeUse" value="false"/>
           <property name="houseKeepingTestSql" value="select CURRENT_DATE"/>
       bean> 
   
       <bean parent="parentDataSource" id="production_env">
           <property name="driverUrl" value="${jdbc.url.local}"/>
           <property name="password" value="${jdbc.password.local}"/> 
           <property name="alias" value="proxool.a2"/>
       bean>
   
       <bean parent="parentDataSource" id="test_env">
           <property name="driverUrl" value="${jdbc.url.server.test}"/>
           <property name="password" value="${jdbc.password.server.test}"/>
           <property name="alias" value="proxool.a1"/>
       bean>
   
       <bean class="com.config.datasource.DynamicDataSource" id="dataSource">
           <property name="targetDataSources">
               <map key-type="java.lang.String">
                   <entry value-ref="production_env" key="pro_db">entry>
                   <entry value-ref="test_env" key="test_db">entry>
               map>
           property>
           <property name="defaultTargetDataSource" ref="production_env">property>
       bean>
   
   
   
   
       <bean id="sessionFactory"
           class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
            <property name="mappingResources">
                  <list>
                      
                     <value >**.**.hbm.xmlvalue>
                  list>
              property>
           <property name="configLocation">
               <value>classpath:hibernate.cfg.xmlvalue>
           property>
           <property name="dataSource" ref="dataSource">
           property>
       bean>
       <bean id="transactionManager"
           class="org.springframework.orm.hibernate4.HibernateTransactionManager">
           <property name="sessionFactory" ref="sessionFactory">property>
       bean>    
        
       <tx:annotation-driven transaction-manager="transactionManager" />
     beans>

2. 数据源的确定

   public class DynamicDataSource extends AbstractRoutingDataSource{
   //private static final Logger log = Logger.getLogger(DynamicDataSource.class);
      @Override
      protected Object determineCurrentLookupKey() {
          String type = DataSourceHolder.getType();
          //log.info("switch_ds:"+type);
          System.out.println("switch_ds:"+type);
          return type;
      }
   }

   // 保留AbstractRoutingDataSource类中的关键实现方法
   public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
   
   private Map targetDataSources;
   
   private Object defaultTargetDataSource;
   
   private boolean lenientFallback = true;
   
   private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
   
   private Map resolvedDataSources;
   
   private DataSource resolvedDefaultDataSource;
       // Spring初始化时的对属性的初始化，获取配置文件中配置的数据源
       // 对配置的key名和配置的数据源Object以map形式保存。
   @Override
   public void afterPropertiesSet() {
       if (this.targetDataSources == null) {
           throw new IllegalArgumentException("Property 'targetDataSources' is required");
       }
       this.resolvedDataSources = new HashMap(this.targetDataSources.size());
       for (Map.Entry entry : this.targetDataSources.entrySet()) {
           Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());
           DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
           this.resolvedDataSources.put(lookupKey, dataSource);
       }
       if (this.defaultTargetDataSource != null) {
           this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
       }
   }
   
   protected Object resolveSpecifiedLookupKey(Object lookupKey) {
       return lookupKey;
   }
   
   protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
       if (dataSource instanceof DataSource) {
           return (DataSource) dataSource;
       }
       else if (dataSource instanceof String) {
           return this.dataSourceLookup.getDataSource((String) dataSource);
       }
       else {
           throw new IllegalArgumentException(
                   "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
       }
   }
   
   // dataSource获取连接的实现
   @Override
   public Connection getConnection() throws SQLException {
       return determineTargetDataSource().getConnection();
   }
   
   @Override
   public Connection getConnection(String username, String password) throws SQLException {
       return determineTargetDataSource().getConnection(username, password);
   }
   
   @Override
   @SuppressWarnings("unchecked")
   public  T unwrap(Class iface) throws SQLException {
       if (iface.isInstance(this)) {
           return (T) this;
       }
       return determineTargetDataSource().unwrap(iface);
   }
   
   @Override
   public boolean isWrapperFor(Class iface) throws SQLException {
       return (iface.isInstance(this) || determineTargetDataSource().isWrapperFor(iface));
   }
   
       // 根据key获取配置中对应的数据源
   protected DataSource determineTargetDataSource() {
       Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
       Object lookupKey = determineCurrentLookupKey();
       DataSource dataSource = this.resolvedDataSources.get(lookupKey);
       if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
           dataSource = this.resolvedDefaultDataSource;
       }
       if (dataSource == null) {
           throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
       }
       return dataSource;
   }
   
       // 子类实现，获取对应的key
   protected abstract Object determineCurrentLookupKey();
   
   }

3. 动态切换的基础容器

   public enum DataSourceType {
      PRODUCTION_DB("pro_db"),TEST_DB("test_db");
   
      private String type;
      DataSourceType(String type) {
          this.type = type;
      }
   
      public String type() {
          return type;
      }
   }

   // 实现这个容器以后，已经可以通过编程方式，在需要切换数据源处通过代码显示更改
   // DataSourceHolder.setType();需要切到目标数据源后，使用setType()方法设置为该数据源的key即可
   public class DataSourceHolder {
   
      private static ThreadLocal dataSourceHolder = new ThreadLocal<>();
   
      private static Set