利用Spring的AbstractRoutingDataSource解决多数据源的问题

在互联网的服务端开发的时候,我们很经常要在一个项目中去调用不同的数据库。在这种情况下,必然要涉及到多数据源问题。那么,我们该如何解决多数据源问题呢?有没有一种方法来动态切换数据源呢?

答案是有的。万能的Spring已经给了我们解决方案——利用AbstractRoutingDataSource。在AbstractRoutingDataSource类中,发现getConnection()方法,从名字上可以知道它是获得connection连接的。跟踪getConnection()方法,determineTargetDataSource()就这么进入我们的视线,继续下去,我们发现了重点——determineCurrentLookupKey()determineCurrentLookupKey方法是一个抽象方法,它的返回值就是我们要用到的数据源dataSource的key,然后根据这个key从resolvedDataSources这个map中取出dataSource,如果找不到就使用默认的dataSource。

知道了这些,我们就来用代码实现吧!以下的代码是基于Spring Boot,所以需要建立一个Spring Boot项目,然后引入spring-boot-starter-jdbc。项目中又有用到AOP,肯定的,我们必须引入spring-boot-starter-aop。

接下来,我们需要建一个DynamicDataSource。

1
2
3
4
5
6
7
8
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
String dataSourceName = DynamicDataSourceContextHolder.getDataSourceName();
return dataSourceName;
}
}

DynamicDataSource继承了抽象类AbstractRoutingDataSource,实现了determineCurrentLookupKey()。在DynamicDataSourceContextHolder中,我们使用ThreadLocal维护dataSouceName这个变量。这样,每一个线程都可以独立改变自己的副本,而不会影响其他线程所对应的副本。

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
/**
* 动态数据源上下文
*/
public class DynamicDataSourceContextHolder {
private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
public static List<String> dataSourceNames = new ArrayList<>();
public static void setDataSourceName(String name) {
contextHolder.set(name);
}
public static String getDataSourceName() {
return contextHolder.get();
}
public static void clearDataSourceName() {
contextHolder.remove();
}
public static boolean containsDataSource(String dataSourceName) {
return dataSourceNames.contains(dataSourceName);
}
}

OK,我们已经有了动态数据源DynamicDataSource,也有了DynamicDataSourceContextHolder,我们怎么使用呢?让我们看下DataSourceConfig

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
@Configuration
public class DataSourceConfig {
@Bean(name = "primaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource.primary")
@Primary
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "secondaryDataSource")
@ConfigurationProperties(prefix = "spring.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}
@Autowired
@Qualifier("primaryDataSource")
private DataSource primaryDataSource;
@Autowired
@Qualifier("secondaryDataSource")
private DataSource secondaryDataSource;
@Bean
public DynamicDataSource dataSource() {
Map<Object, Object> targetDataSources = new HashMap<>();
targetDataSources.put("primaryDataSource", primaryDataSource);
targetDataSources.put("secondaryDataSource", secondaryDataSource);
DynamicDataSourceContextHolder.dataSourceNames.add("primaryDataSource");
DynamicDataSourceContextHolder.dataSourceNames.add("secondaryDataSource");
DynamicDataSource dataSource = new DynamicDataSource();
//设置数据源映射
dataSource.setTargetDataSources(targetDataSources);
//设置默认数据源,当无法映射到数据源时会使用默认数据源
dataSource.setDefaultTargetDataSource(primaryDataSource);
dataSource.afterPropertiesSet();
return dataSource;
}
}

当然,上面的DataSourceConfig还得搭配application.properties配置文件。

1
2
3
4
5
6
7
8
9
10
#
spring.datasource.primary.jdbcUrl=jdbc:mysql://localhost/test1?useSSL=false
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver
#
spring.datasource.secondary.jdbcUrl=jdbc:mysql://localhost/test2?useSSL=false
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver

到现在为止,我们已经配置了动态的数据源,将我们的多个数据源设置给了DynamicDataSource。这样,我们就可以在Service或者是Dao中使用DynamicDataSourceContextHolder.setDataSourceName("primaryDataSource")方法来动态切换数据源了。但是,这样的写法会不会感到很不爽呢?其实,我们可以在方法上使用注解来切换数据源。

自定义一个注解TargetDataSource:

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 在方法上使用,用于指定使用哪个数据源
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
String value();
}

这样,我们就可以在Service上如以下使用:

1
2
3
4
5
6
7
8
9
10
11
@TargetDataSource(value = "primaryDataSource")
public List<Customer> findAll() {
//TODO
return null;
}
@TargetDataSource(value = "secondaryDataSource")
public void addCustomer(String name, String email) {
}

很明显的,到目前为止还不能完成我们的切换需求。我们还需要一段代码,来实现动态调用DynamicDataSourceContextHolder.setDataSourceName("xxx"),比较好的实现就是AOP啦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Aspect
@Component
@Order(-1)// 保证该AOP在@Transactional之前执行
public class DynamicDataSourceChangeAspect {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceChangeAspect.class);
@Before("@annotation(targetDataSource)")
public void changeDataSource(JoinPoint joinPoint, TargetDataSource targetDataSource) {
String dsName = targetDataSource.value();
if (!DynamicDataSourceContextHolder.containsDataSource(dsName)) {
System.err.println("数据源[{}]不存在,使用默认数据源 > {}" + targetDataSource.value() + joinPoint.getSignature());
} else {
DynamicDataSourceContextHolder.setDataSourceName(targetDataSource.value()); //设置到动态数据源上下文中
}
}
@After("@annotation(targetDataSource)")
public void restoreDataSource(JoinPoint point, TargetDataSource targetDataSource) {
//方法执行完毕之后,销毁当前数据源信息,进行垃圾回收。
DynamicDataSourceContextHolder.clearDataSourceName();
}
}

到现在为止,我们就实现了动态切换数据源了。