Spring动态配置多数据源

Spring动态配置多数据源，即在大型应用中对数据进行切分，并且采用多个数据库实例进行管理，这样可以有效提高系统的水平伸缩性。而这样的方案就会不同于常见的单一数据实例的方案，这就要程序在运行时根据当时的请求及系统状态来动态的决定将数据存储在哪个数据库实例中，以及从哪个数据库提取数据。

Spring配置多数据源的方式和具体使用过程。 
Spring对于多数据源，以数据库表为参照，大体上可以分成两大类情况： 
一是，表级上的跨数据库。即，对于不同的数据库却有相同的表（表名和表结构完全相同）。 
二是，非表级上的跨数据库。即，多个数据源不存在相同的表。

1、根据用户的选择，使用不同的数据源。

2、解决思路锁定：将sessionFactory的属性dataSource设置成不同的数据源，以达到切换数据源的目的。

3、问题产生：因为整个项目用的几乎都是单例模式，当多个用户并发访问数据库的时候，会产生资源争夺的问题。即项目启动时候，所有的bean都被装载到内存，并且每个bean都只有一个对象。正因为只有一个对象，所有的对象属性就如同静态变量（静态变量跟单例很相似，常用静态来实现单例）。整个项目系统的dataSource只有一个，如果很多用户不断的去改变dataSource的值，那必然会出现资源的掠夺问题，造成系统隐患。

4、多资源共享解决思路：同一资源被抢夺的时候，通常有两种做法，a、以时间换空间 b、以空间换时间。

5、线程同步机制就是典型的“以时间换空间”，采用排队稍等的方法，一个个等待，直到前面一个用完，后面的才跟上，多人共用一个变量，用synchronized锁定排队。  

6、“ThreadLocal”就是典型的“以空间换时间”，她可以为每一个人提供一份变量，因此可以同时访问并互不干扰。

7、言归正传：sessionFactory的属性dataSource设置成不用的数据源，首先不能在配置文件中写死，我们必须为她单独写一个类，让她来引用这个类，在这个类中再来判断我们到底要选择哪个数据源。

----------------------------------------------------------------------------------------------------------------------------------

假设现在有两个数据库myone和mytwo,读者可以理解为一个写库,一个读库,数据库中都各自有一个表,表的格式都一样，如下：

------------------------------------------------------------
id         int(11) PRI auto_increment
username varchar(20)
password varchar(20)
------------------------------------------------------------

数据库脚本如下：

[java] view plain copy

1. create database myone;  
2. use myone;  
3. create table user(id int auto_increment primary key,username varchar(20),password varchar(20));  
4.   
5. create database mytwo;  
6. use mytwo;  
7. create table user(id int auto_increment primary key,username varchar(20),password varchar(20));  
8. insert into mytwo.user(username,password) value('test','test');  

现在想要实现数据库的自动切换，有些mapper操作写库myone，有些mapper操作读库mytwo。
首先，构建maven工程，pom文件如下：

[java] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5.     <modelVersion>4.0.0</modelVersion>  
6.   
7.     <groupId>com.aliyun.security</groupId>  
8.     <artifactId>resourcegroup</artifactId>  
9.     <version>1.0-SNAPSHOT</version>  
10.   
11.     <dependencies>  
12.         <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->  
13.         <dependency>  
14.             <groupId>org.apache.commons</groupId>  
15.             <artifactId>commons-dbcp2</artifactId>  
16.             <version>2.1.1</version>  
17.         </dependency>  
18.         <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->  
19.         <dependency>  
20.             <groupId>org.mybatis</groupId>  
21.             <artifactId>mybatis</artifactId>  
22.             <version>3.2.8</version>  
23.         </dependency>  
24.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->  
25.         <dependency>  
26.             <groupId>org.springframework</groupId>  
27.             <artifactId>spring-jdbc</artifactId>  
28.             <version>4.1.6.RELEASE</version>  
29.         </dependency>  
30.   
31.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->  
32.         <dependency>  
33.             <groupId>org.springframework</groupId>  
34.             <artifactId>spring-aop</artifactId>  
35.             <version>4.1.6.RELEASE</version>  
36.         </dependency>  
37.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->  
38.         <dependency>  
39.             <groupId>org.springframework</groupId>  
40.             <artifactId>spring-context</artifactId>  
41.             <version>4.1.6.RELEASE</version>  
42.         </dependency>  
43.         <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->  
44.         <dependency>  
45.             <groupId>org.aspectj</groupId>  
46.             <artifactId>aspectjweaver</artifactId>  
47.             <version>1.8.6</version>  
48.         </dependency>  
49.         <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->  
50.         <dependency>  
51.             <groupId>org.mybatis</groupId>  
52.             <artifactId>mybatis-spring</artifactId>  
53.             <version>1.1.1</version>  
54.         </dependency>  
55.   
56.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->  
57.         <dependency>  
58.             <groupId>mysql</groupId>  
59.             <artifactId>mysql-connector-java</artifactId>  
60.             <version>5.1.38</version>  
61.         </dependency>  
62.     </dependencies>  
63. </project> 
    

接下来是写库myone对应的mapper，如下：

[java] view plain copy

1. package dal.mapper.myone;  
2.   
3. import dal.dataobject.myone.User;  
4.   
5. public interface OneUserManageMapper {  
6.     int createUser(User user);  
7. }  

[java] view plain copy

1. <?xml version="1.0" encoding="GBK"?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
3. <mapper namespace="dal.mapper.myone.OneUserManageMapper">  
4.     <insert id="createUser">  
5.         INSERT INTO user(username, password) VALUES(#{username}, #{password})  
6.     </insert>  
7. </mapper>  

接下来是读库mytwo对应的mapper，如下：

[java] view plain copy

1. package dal.mapper.mytwo;  
2.   
3. import dal.dataobject.mytwo.User;  
4. import org.apache.ibatis.annotations.Param;  
5.   
6. public interface TwoUserManageMapper {  
7.     User getUserById(@Param("id") int id);  
8. }  

[java] view plain copy

1. <?xml version="1.0" encoding="GBK"?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
3. <mapper namespace="dal.mapper.mytwo.TwoUserManageMapper">  
4.     <!--<insert id="createUser">-->  
5.         <!--INSERT INTO user(username, password) VALUES(#{username}, #{password})-->  
6.     <!--</insert>-->  
7.     <resultMap id="RM-User" type="dal.dataobject.mytwo.User">  
8.         <result column="id" property="id"/>  
9.         <result column="username" property="username"/>  
10.         <result column="password" property="password"/>  
11.     </resultMap>  
12.     <select id="getUserById" resultMap="RM-User">  
13.         SELECT * from user WHERE id=#{id}  
14.     </select>  
15. </mapper>  

接下来是实现自动切换最主要的代码，这里使用AOP编程来实现：

[java] view plain copy

1. package dal.datasourceswitch;  
2.   
3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
4. /** 
5.  * Created by Administrator on 2016/8/22. 
6.  */  
7.   
8. /** 
9.  * Created by rabbit on 14-5-25. 
10.  */  
11. public class MultipleDataSource extends AbstractRoutingDataSource {  
12.   
13.     private static ThreadLocal<String> threadLocalDatasource=new ThreadLocal<String>(){  
14.         @Override  
15.         protected String initialValue() {  
16.             return null;  
17.         }  
18.     };  
19.   
20.     public static void setThreadLocalDatasource(String dsName){  
21.         threadLocalDatasource.set(dsName);  
22.     }  
23.   
24.   
25.     @Override  
26.     protected Object determineCurrentLookupKey() {  
27.         return threadLocalDatasource.get();  
28.     }  
29. }  

[java] view plain copy

1. package dal.datasourceswitch;  
2.   
3. import org.aspectj.lang.ProceedingJoinPoint;  
4. import org.aspectj.lang.annotation.Around;  
5. import org.aspectj.lang.annotation.Aspect;  
6. import org.springframework.stereotype.Component;  
7.   
8. @Component  
9. @Aspect  
10. public class MultipleDataSourceAspectAdvice {  
11.   
12.     @Around("execution(* dal.mapper.myone..*.*(*))")  
13.     public Object doAround1(ProceedingJoinPoint jp) throws Throwable {  
14.         MultipleDataSource.setThreadLocalDatasource("myone");  
15.         return jp.proceed();  
16.     }  
17.   
18.     @Around("execution(* dal.mapper.mytwo..*.*(*))")  
19.     public Object doAround2(ProceedingJoinPoint jp) throws Throwable {  
20.         MultipleDataSource.setThreadLocalDatasource("mytwo");  
21.         return jp.proceed();  
22.     }  
23.   
24. }  

读者可以学习下AbstractRoutingDataSource类，就知道这么做的理由了。
最后，看下spring的配置文件：

[java] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.        xmlns:context="http://www.springframework.org/schema/context"  
4.        xmlns:aop="http://www.springframework.org/schema/aop"  
5.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
6.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
7.     http://www.springframework.org/schema/context  
8.     http://www.springframework.org/schema/context/spring-context-3.0.xsd  
9.       http://www.springframework.org/schema/aop  
10.           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  
11.     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
12.         <property name="location">  
13.             <value>jdbc.properties</value>  
14.         </property>  
15.     </bean>  
16.     <bean id="myoneDataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">  
17.         <property name="driverClassName" value="${jdbc.myone.driver}"/>  
18.         <property name="url" value="${jdbc.myone.url}"/>  
19.         <property name="username" value="${jdbc.myone.username}"/>  
20.         <property name="password" value="${jdbc.myone.password}"/>  
21.     </bean>  
22.     <bean id="mytwoDataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">  
23.         <property name="driverClassName" value="${jdbc.mytwo.driver}"/>  
24.         <property name="url" value="${jdbc.mytwo.url}"/>  
25.         <property name="username" value="${jdbc.mytwo.username}"/>  
26.         <property name="password" value="${jdbc.mytwo.password}"/>  
27.     </bean>  
28.   
29.     <bean id="multipleDataSource" class="dal.datasourceswitch.MultipleDataSource">  
30.         <property name="defaultTargetDataSource" ref="myoneDataSource"/> <!--默认主库-->  
31.         <property name="targetDataSources">  
32.             <map>  
33.                 <entry key="myone" value-ref="myoneDataSource"/>            <!--辅助aop完成自动数据库切换-->  
34.                 <entry key="mytwo" value-ref="mytwoDataSource"/>  
35.             </map>  
36.         </property>  
37.     </bean>  
38.   
39.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
40.         <property name="dataSource" ref="multipleDataSource"/>  
41.         <property name="mapperLocations">  
42.             <list>  
43.                 <value>mapper/OneUserManageMapper.xml</value>  
44.                 <value>mapper/TwoUserManageMapper.xml</value>  
45.             </list>  
46.         </property>  
47.     </bean>  
48.   
49.   
50.     <bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true">  
51.         <property name="sqlSessionFactory" ref="sqlSessionFactory" />  
52.     </bean>  
53.   
54.     <bean id="myoneUserManageMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"  
55.           parent="baseMapper">  
56.         <property name="mapperInterface"  
57.                   value="dal.mapper.myone.OneUserManageMapper" />  
58.     </bean>  
59.   
60.     <bean id="mytwoUserManageMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"  
61.           parent="baseMapper">  
62.         <property name="mapperInterface"  
63.                   value="dal.mapper.mytwo.TwoUserManageMapper" />  
64.     </bean>  
65.     <aop:aspectj-autoproxy/>  
66.     <!-- 自动扫描，多个包以 逗号分隔 -->  
67.     <context:component-scan base-package="dal"/> <!--注解自动装配-->  
68.     <context:annotation-config />  <!--组件自动扫描-->  
69. </beans>  

上面是实现多数据源自动切换的主要代码，源码github地址：
https://github.com/ZhenShiErGe/Multi-Datasource-Autoswitch.git

文章修改自http://www.cnblogs.com/lzrabbit/p/3750803.html