同一个项目有时会涉及到多个
数据库
，也就是多数据源。多数据源又可以分为两种情况：
1）两个或多个数据库没有相关性，各自独立，其实这种可以作为两个项目来开发。比如在游戏开发中一个数据库是平台数据库，其它还有平台下的游戏对应的数据库；
2）两个或多个数据库是master-slave的关系，比如有
mysql
搭建一个 master-master，其后又带有多个slave；或者采用MHA搭建的master-slave复制；
目前我所知道的 Spring 多数据源的搭建大概有两种方式，可以根据多数据源的情况进行选择。
1. 采用spring配置文件直接配置多个数据源
比如针对两个数据库没有相关性的情况，可以采用直接在spring的配置文件中配置多个数据源，然后分别进行事务的配置，如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
<context:component-scan base-
package
=
"com.bosssoft.nontax.agency"
/>
<!-- 引入属性文件 -->
<context:property-placeholder location=
"classpath:config/db.properties"
/>
<!-- 配置数据源 -->
<bean name=
"dataSource"
class
=
"com.alibaba.druid.pool.DruidDataSource"
init-method=
"init"
destroy-method=
"close"
>
<property name=
"url"
value=
"${jdbc_url}"
/>
<property name=
"username"
value=
"${jdbc_username}"
/>
<property name=
"password"
value=
"${jdbc_password}"
/>
<!-- 初始化连接大小 -->
<property name=
"initialSize"
value=
"0"
/>
<!-- 连接池最大使用连接数量 -->
<property name=
"maxActive"
value=
"20"
/>
<!-- 连接池最大空闲 -->
<property name=
"maxIdle"
value=
"20"
/>
<!-- 连接池最小空闲 -->
<property name=
"minIdle"
value=
"0"
/>
<!-- 获取连接最大等待时间 -->
<property name=
"maxWait"
value=
"60000"
/>
</bean>
<bean id=
"sqlSessionFactory"
class
=
"org.mybatis.spring.SqlSessionFactoryBean"
>
<property name=
"dataSource"
ref=
"dataSource"
/>
<property name=
"configLocation"
value=
"classpath:config/mybatis-config.xml"
/>
<property name=
"mapperLocations"
value=
"classpath*:config/mappers/**/*.xml"
/>
</bean>
<!-- Transaction manager
for
a single JDBC DataSource -->
<bean id=
"transactionManager"
class
=
"org.springframework.jdbc.datasource.DataSourceTransactionManager"
>
<property name=
"dataSource"
ref=
"dataSource"
/>
</bean>
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager=
"transactionManager"
/>
<bean
class
=
"org.mybatis.spring.mapper.MapperScannerConfigurer"
>
<property name=
"basePackage"
value=
"com.bosssoft.mapper"
/>
<property name=
"sqlSessionFactoryBeanName"
value=
"sqlSessionFactory"
/>
</bean>
<!-- Enables the use of the
@AspectJ
style of Spring AOP -->
<aop:aspectj-autoproxy/>
<!-- ===============第二个数据源的配置=============== -->
<bean name=
"dataSource_2"
class
=
"com.alibaba.druid.pool.DruidDataSource"
init-method=
"init"
destroy-method=
"close"
>
<property name=
"url"
value=
"${jdbc_url_2}"
/>
<property name=
"username"
value=
"${jdbc_username_2}"
/>
<property name=
"password"
value=
"${jdbc_password_2}"
/>
<!-- 初始化连接大小 -->
<property name=
"initialSize"
value=
"0"
/>
<!-- 连接池最大使用连接数量 -->
<property name=
"maxActive"
value=
"20"
/>
<!-- 连接池最大空闲 -->
<property name=
"maxIdle"
value=
"20"
/>
<!-- 连接池最小空闲 -->
<property name=
"minIdle"
value=
"0"
/>
<!-- 获取连接最大等待时间 -->
<property name=
"maxWait"
value=
"60000"
/>
</bean>
<bean id=
"sqlSessionFactory_slave"
class
=
"org.mybatis.spring.SqlSessionFactoryBean"
>
<property name=
"dataSource"
ref=
"dataSource_2"
/>
<property name=
"configLocation"
value=
"classpath:config/mybatis-config-2.xml"
/>
<property name=
"mapperLocations"
value=
"classpath*:config/mappers2/**/*.xml"
/>
</bean>
<!-- Transaction manager
for
a single JDBC DataSource -->
<bean id=
"transactionManager_2"
class
=
"org.springframework.jdbc.datasource.DataSourceTransactionManager"
>
<property name=
"dataSource"
ref=
"dataSource_2"
/>
</bean>
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager=
"transactionManager_2"
/>
<bean
class
=
"org.mybatis.spring.mapper.MapperScannerConfigurer"
>
<property name=
"basePackage"
value=
"com.bosssoft.mapper2"
/>
<property name=
"sqlSessionFactoryBeanName"
value=
"sqlSessionFactory_2"
/>
</bean>
|
如上所示，我们分别配置了两个 dataSource，两个sqlSessionFactory，两个transactionManager，以及关键的地方在于MapperScannerConfigurer 的配置——使用sqlSessionFactoryBeanName属性，注入不同的sqlSessionFactory的名称，这样的话，就为不同的数据库对应的 mapper 接口注入了对应的 sqlSessionFactory。
需要注意的是，多个数据库的这种配置是不支持分布式事务的，也就是同一个事务中，不能操作多个数据库。这种配置方式的优点是很简单，但是却不灵活。对于master-slave类型的多数据源配置而言不太适应，master-slave性的多数据源的配置，需要特别灵活，需要根据业务的类型进行细致的配置。比如对于一些耗时特别大的select语句，我们希望放到slave上执行，而对于update,delete等操作肯定是只能在master上执行的，另外对于一些实时性要求很高的select语句。
所以对于master-slave类型的多数据源的配置，需要根据业务来进行灵活的配置，哪些select可以放到slave上，哪些select不能放到slave上。所以上面的那种所数据源的配置就不太适应了。
2. 基于 AbstractRoutingDataSource 和 AOP 的多数据源的配置
基本原理是，我们自己定义一个DataSource类ThreadLocalRountingDataSource，来继承AbstractRoutingDataSource，然后在配置文件中向ThreadLocalRountingDataSource注入 master 和 slave 的数据源，然后通过 AOP 来灵活配置，在哪些地方选择 master 数据源，在哪些地方需要选择 slave数据源。下面看代码实现：
1）先定义一个enum来表示不同的数据源：
package com.bosssoft.enums;
/**
* 数据源的类别：master/slave
*/
public enum DataSources {
MASTER, SLAVE
}
2）通过 TheadLocal 来保存每个线程选择哪个数据源的标志(key)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package
com.bosssoft.util;
import
com.bosssoft.enums.DataSources;
public
class
DataSourceTypeManager {
private
static
final
ThreadLocal<DataSources> dataSourceTypes =
new
ThreadLocal<DataSources>(){
@Override
protected
DataSources initialValue(){
return
DataSources.MASTER;
}
};
public
static
DataSources get(){
return
dataSourceTypes.get();
}
public
static
void
set(DataSources dataSourceType){
dataSourceTypes.set(dataSourceType);
}
public
static
void
reset(){
dataSourceTypes.set(DataSources.MASTER0);
}
}
|
3）定义 ThreadLocalRountingDataSource，继承AbstractRoutingDataSource：
package com.bosssoft.util;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class ThreadLocalRountingDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DataSourceTypeManager.get();
}
}
4）在配置文件中向 ThreadLocalRountingDataSource 注入 master 和 slave 的数据源：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
<context:component-scan base-
package
=
"com.bosssoft"
/>
<!-- 引入属性文件 -->
<context:property-placeholder location=
"classpath:config/db.properties"
/>
<!-- 配置数据源Master -->
<bean name=
"dataSourceMaster"
class
=
"com.alibaba.druid.pool.DruidDataSource"
init-method=
"init"
destroy-method=
"close"
>
<property name=
"url"
value=
"${jdbc_url}"
/>
<property name=
"username"
value=
"${jdbc_username}"
/>
<property name=
"password"
value=
"${jdbc_password}"
/>
<!-- 初始化连接大小 -->
<property name=
"initialSize"
value=
"0"
/>
<!-- 连接池最大使用连接数量 -->
<property name=
"maxActive"
value=
"20"
/>
<!-- 连接池最大空闲 -->
<property name=
"maxIdle"
value=
"20"
/>
<!-- 连接池最小空闲 -->
<property name=
"minIdle"
value=
"0"
/>
<!-- 获取连接最大等待时间 -->
<property name=
"maxWait"
value=
"60000"
/>
</bean>
<!-- 配置数据源Slave -->
<bean name=
"dataSourceSlave"
class
=
"com.alibaba.druid.pool.DruidDataSource"
init-method=
"init"
destroy-method=
"close"
>
<property name=
"url"
value=
"${jdbc_url_slave}"
/>
<property name=
"username"
value=
"${jdbc_username_slave}"
/>
<property name=
"password"
value=
"${jdbc_password_slave}"
/>
<!-- 初始化连接大小 -->
<property name=
"initialSize"
value=
"0"
/>
<!-- 连接池最大使用连接数量 -->
<property name=
"maxActive"
value=
"20"
/>
<!-- 连接池最大空闲 -->
<property name=
"maxIdle"
value=
"20"
/>
<!-- 连接池最小空闲 -->
<property name=
"minIdle"
value=
"0"
/>
<!-- 获取连接最大等待时间 -->
<property name=
"maxWait"
value=
"60000"
/>
</bean>
<bean id=
"dataSource"
class
=
"com.bosssoft.util.ThreadLocalRountingDataSource"
>
<property name=
"defaultTargetDataSource"
ref=
"dataSourceMaster"
/>
<property name=
"targetDataSources"
>
<map key-type=
"com.bosssoft.enums.DataSources"
>
<entry key=
"MASTER"
value-ref=
"dataSourceMaster"
/>
<entry key=
"SLAVE"
value-ref=
"dataSourceSlave"
/>
<!-- 这里还可以加多个dataSource -->
</map>
</property>
</bean>
<bean id=
"sqlSessionFactory"
class
=
"org.mybatis.spring.SqlSessionFactoryBean"
>
<property name=
"dataSource"
ref=
"dataSource"
/>
<property name=
"configLocation"
value=
"classpath:config/mybatis-config.xml"
/>
<property name=
"mapperLocations"
value=
"classpath*:config/mappers/**/*.xml"
/>
</bean>
<!-- Transaction manager
for
a single JDBC DataSource -->
<bean id=
"transactionManager"
class
=
"org.springframework.jdbc.datasource.DataSourceTransactionManager"
>
<property name=
"dataSource"
ref=
"dataSource"
/>
</bean>
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager=
"transactionManager"
/>
<bean
class
=
"org.mybatis.spring.mapper.MapperScannerConfigurer"
>
<property name=
"basePackage"
value=
"com.bosssoft.mapper"
/>
<!-- <property name=
"sqlSessionFactoryBeanName"
value=
"sqlSessionFactory"
/> -->
</bean>
|
上面spring的配置文件中，我们针对master数据库和slave数据库分别定义了dataSourceMaster和dataSourceSlave两个dataSource，然后注入到<bean id="dataSource" class="com.bosssoft.util.ThreadLocalRountingDataSource"> 中，这样我们的dataSource就可以来根据 key 的不同来选择dataSourceMaster和 dataSourceSlave了。
5）使用Spring AOP 来指定 dataSource 的 key ，从而dataSource会根据key选择 dataSourceMaster 和 dataSourceSlave：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@Aspect
// for aop
@Component
// for auto scan
public
class
DataSourceInterceptor {
@Pointcut
(
"execution(public * com.bosssoft.service..*.getUser(..))"
)
public
void
dataSourceSlave(){};
@Before
(
"dataSourceSlave()"
)
public
void
before(JoinPoint jp) {
DataSourceTypeManager.set(DataSources.SLAVE);
}
// ... ...
}
|
这里我们定义了一个 Aspect 类，我们使用 @Before 来在符合 @Pointcut("execution(public *
com.bosssoft
.service..*.getUser(..))") 中的方法被调用之前，调用 DataSourceTypeManager.set(DataSources.SLAVE) 设置了 key 的类型为 DataSources.SLAVE，所以 dataSource 会根据key=DataSources.SLAVE 选择 dataSourceSlave 这个dataSource。所以该方法对于的sql语句会在slave数据库上执行。
我们可以不断的扩充 DataSourceInterceptor 这个 Aspect，在中进行各种各样的定义，来为某个service的某个方法指定合适的数据源对应的dataSource。
这样我们就可以使用 Spring AOP 的强大功能来，十分灵活进行配置了。
6）AbstractRoutingDataSource原理剖析
ThreadLocalRountingDataSource继承了AbstractRoutingDataSource，实现其抽象方法protected abstract Object determineCurrentLookupKey(); 从而实现对不同数据源的路由功能。我们从
源码入手分析下其中原理：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
abstract
class
AbstractRoutingDataSource
extends
AbstractDataSource
implements
InitializingBean
AbstractRoutingDataSource 实现了 InitializingBean 那么spring在初始化该bean时，会调用InitializingBean的接口
void
afterPropertiesSet()
throws
Exception; 我们看下AbstractRoutingDataSource是如何实现这个接口的：
@Override
public
void
afterPropertiesSet() {
if
(
this
.targetDataSources ==
null
) {
throw
new
IllegalArgumentException(
"Property 'targetDataSources' is required"
);
}
this
.resolvedDataSources =
new
HashMap<Object, DataSource>(
this
.targetDataSources.size());
for
(Map.Entry<Object, Object> 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);
}
}
|
targetDataSources 是我们在xml配置文件中注入的 dataSourceMaster 和 dataSourceSlave. afterPropertiesSet方法就是使用注入的
dataSourceMaster 和 dataSourceSlave来构造一个HashMap——resolvedDataSources。方便后面根据 key 从该map 中取得对应的dataSource。
我们在看下 AbstractDataSource 接口中的 Connection getConnection() throws SQLException; 是如何实现的：
@Override
public Connection getConnection() throws SQLException {
return determineTargetDataSource().getConnection();
}
关键在于 determineTargetDataSource()，根据方法名就可以看出，应该此处就决定了使用哪个 dataSource ：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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;
}
|
Object lookupKey = determineCurrentLookupKey(); 该方法是我们实现的，在其中获取ThreadLocal中保存的 key 值。获得了key之后，
在从afterPropertiesSet()中初始化好了的resolvedDataSources这个map中获得key对应的dataSource。而ThreadLocal中保存的 key 值
是通过AOP的方式在调用service中相关方法之前设置好的。