Spring多数据源的配置

Spring多数据源的配置

在大型的应用中，为了提高数据库的水平伸缩性，对多个数据库实例进行管理，需要配置多数据源。在Spring框架被广泛运用的今天，可以很简单的运用Spring中的特性配置动态多数据。 

1. 首先配置一个基于c3p0.ComboPooledDataSource的数据源A 
daoContext.xml 
Xml代码  

1. <bean id="dataSourceA" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
2.     <property name="driverClass" value="${jdbc.driver}"></property>  
3.     <property name="jdbcUrl" value="${jdbc.url.a}?zeroDateTimeBehavior=convertToNull&amp;characterEncoding=utf8"></property>  
4.     <property name="user" value="${jdbc.user}"></property>  
5.     <property name="password" value="${jdbc.password}"></property>  
6.     <property name="minPoolSize" value="${jdbc.miniPoolSize}" />  
7.     <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>    
8.     <property name="initialPoolSize" value="${jdbc.initialPoolSize}"/>  
9.     <property name="maxIdleTime" value="${jdbc.maxIdleTime}"/>  
10.     <property name="acquireIncrement" value="${jdbc.acquireIncrement}"/>  
11.     <property name="acquireRetryAttempts" value="${jdbc.acquireRetryAttempts}"/>  
12.     <property name="acquireRetryDelay" value="${jdbc.acquireRetryDelay}"/>  
13.     <property name="idleConnectionTestPeriod" value="${jdbc.idleConnectionTestPeriod}"/>  
14.     <property name="checkoutTimeout" value="${jdbc.checkoutTimeout}"/>  
15. </bean>  

2. 接着增加一个数据源B 
daoContext.xml 
Xml代码  

1. <bean id="dataSourceB" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
2.     <property name="driverClass" value="${jdbc.driver}"></property>  
3.     <property name="jdbcUrl" value="${jdbc.url.b}?zeroDateTimeBehavior=convertToNull&amp;characterEncoding=utf8"></property>  
4.     <property name="user" value="${jdbc.user}"></property>  
5.     <property name="password" value="${jdbc.password}"></property>  
6.     <property name="minPoolSize" value="${jdbc.miniPoolSize}" />  
7.     <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>    
8.     <property name="initialPoolSize" value="${jdbc.initialPoolSize}"/>  
9.     <property name="maxIdleTime" value="${jdbc.maxIdleTime}"/>  
10.     <property name="acquireIncrement" value="${jdbc.acquireIncrement}"/>  
11.     <property name="acquireRetryAttempts" value="${jdbc.acquireRetryAttempts}"/>  
12.     <property name="acquireRetryDelay" value="${jdbc.acquireRetryDelay}"/>  
13.     <property name="idleConnectionTestPeriod" value="${jdbc.idleConnectionTestPeriod}"/>  
14.     <property name="checkoutTimeout" value="${jdbc.checkoutTimeout}"/>  
15. </bean>  

3. 接着扩展一个Spring提供的AbstractRoutingDataSource，Override 其中的 determineCurrentLookupKey方法实现数据源的route. 
Java代码  

1. package datasource;  
2.   
3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
4.   
5. public class DynamicDataSource extends AbstractRoutingDataSource{  
6.   
7.     @Override  
8.     protected Object determineCurrentLookupKey() {  
9.         return CustomerContextHolder.getCustomerType();  
10.     }  
11. }  

而其中的CustomerContextHolder这是开发人员自己实现的一个封装了ThreadLocal类型的ContextHolder。 
Java代码  

1. package datasource;  
2.   
3. public class CustomerContextHolder {  
4.   
5.     public static final String DATA_SOURCE_A = "dataSourceA";  
6.       
7.     public static final String DATA_SOURCE_B = "dataSourceB";  
8.       
9.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();  
10.       
11.     public static void setCustomerType(String customerType) {  
12.         contextHolder.set(customerType);  
13.     }  
14.       
15.     public static String getCustomerType() {  
16.         return contextHolder.get();  
17.     }  
18.       
19.     public static void clearCustomerType() {  
20.         contextHolder.remove();  
21.     }  
22. }  

接下来就是在我们上面的daoContext.xml将这个DynamicDataSource Bean加入进去，同时配置targetDataSources的 Map映射。 
Xml代码  

1. <bean id="dynamicDataSource" class="datasource.DynamicDataSource" >  
2.     <!-- 通过key-value的形式来关联数据源 -->  
3.     <property name="targetDataSources">  
4.         <map key-type="java.lang.String">  
5.             <entry value-ref="dataSourceA" key="dataSourceA"></entry>  
6.             <entry value-ref="dataSourceB" key="dataSourceB"></entry>  
7.         </map>  
8.     </property>  
9.     <property name="defaultTargetDataSource" ref="dataSourceA" >  
10.     </property>  
11. </bean>   

4. 如何是用这个动态的多数据源呢？ 其实很简单，因为我们的DynamicDataSource 是继承与AbstractRoutingDataSource，而AbstractRoutingDataSource又是继承于org.springframework.jdbc.datasource.AbstractDataSource，显然的AbstractDataSource实现了统一的DataSource接口，所以我们的DynamicDataSource 同样可以方便的当一个DataSource使用，下面拿Hibernate做例子： 
Xml代码  

1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
2.     <!-- 可以看到和 普通的dataSource用法一样 -->  
3.     <property name="dataSource" ref="dynamicDataSource" />  
4.     <property name="configLocations" value="classpath:hibernate.cfg.xml" />  
5.     <property name="hibernateProperties">  
6.         <props>  
7.                <prop key="hibernate.dialect">${hibernate.dialect}</prop>      
8.     </property>  
9. </bean>  

可以看到我们用的仍然是一个sessionFactory，这样看来事务管理的配置也和以前一样。 
Xml代码  

1. <tx:annotation-driven transaction-manager="transactionManager"/>  
2.   
3. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
4.     <property name="sessionFactory" ref="sessionFactory" />  
5. </bean>  

DynamicDataSource Bean也在容器中了，现在剩下的就在程序中如何控制，选择某一个想要的数据源该怎么做：
Java代码  

1. //这样就将数据源动态的设置成了dataSourceB.  
2. stomerContextHolder.setCustomerType(CustomerContextHolder.DATA_SOURCE_B);  

或者使用AOP实现 
Java代码  

1. package datasource;  
2.   
3. import org.aspectj.lang.JoinPoint;  
4. import org.aspectj.lang.annotation.Aspect;  
5. import org.aspectj.lang.annotation.Before;  
6. import org.aspectj.lang.annotation.Pointcut;  
7.   
8. @Aspect  
9. public class DynamicDataSourceAspect {  
10.     @Pointcut("execution (public service.impl..*.*(..))")  
11.     public void serviceExecution(){}  
12.       
13.     @Before("serviceExecution()")  
14.     public void setDynamicDataSource(JoinPoint jp) {  
15.         for(Object o : jp.getArgs()) {  
16.             //处理具体的逻辑 ，根据具体的境况CustomerContextHolder.setCustomerType()选取DataSource  
17.         }  
18.     }  
19. }  

5. 总结： 我们可以看到运用AbstractRoutingDataSource可以很好的实现多数据源的，而且以后扩展更多的数据源时也非常容易，只要增加数据源和修改DynamicDataSource Bean的targetDataSources 配置就好。关于选择某一个数据源，其实可以很好的用@Aspect在Service的入口加入一个切面@Pointcut，在@Before里判断JoinPoint的类容选定特定的数据源（例如更加JoinPoint的某个key来判断在设置CustomerContextHolder.setCustomerType）。 
根究实际的应用来确定。个人看法： 以前有很多应用部署了writeDataSource和readDataSource和slaveDataBase的实现，但现在的大部分应用在构架上已经不太适合了，越来越注重和用户的交互性使得数据库间他同步变得日益复杂和难以维护，所以在架构系统时不妨考虑使用水平切割的方法来切割数据库，当然这种开发需要需要更多的时间分析业务领域，选取如何的配置数据源其实也是和业务息息相关的。