实现原理

Spring内置了一个AbstractRoutingDataSource类,它可以把多个数据源配置成一个Map,然后根据不同的key返回不同的数据源(通过实现抽象方法determineCurrentLookupKey)。

我们在使用AbstractRoutingDataSource时,主要涉及两个操作:

  1. 生成数据源相关map,并赋值给AbstractRoutingDataSource的targetDataSources
  2. 实现determineCurrentLookupKey方法(方法的用途为:获取要使用数据源的key)

配置多数据源

首先,我们在SpringBoot中配置两个数据源,其中第二个数据源是slave-datasource:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
spring:
datasource:
jdbc-url: jdbc:mysql://localhost/master?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
username: root #master
password: dreamlyn #master_password
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
pool-name: HikariCP
auto-commit: false

slave-datasource:
jdbc-url: jdbc:mysql://localhost/slave?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
username: root #slave
password: dreamlyn #slave_password
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
pool-name: HikariCP
auto-commit: false

在SpringBoot的配置代码中,初始化两个数据源:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* Master data source.
*/
@Bean("masterDataSource")
@ConfigurationProperties(prefix = "spring.datasource")
DataSource masterDataSource() {
return DataSourceBuilder.create().build();
}

/**
* Slave data source.
*/
@Bean("slaveDataSource")
@ConfigurationProperties(prefix = "spring.slave-datasource")
DataSource slaveDataSource() {
return DataSourceBuilder.create().build();
}

生成数据源相关map

将两个数据源生成相关map,并赋值给AbstractRoutingDataSource的targetDataSources

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Bean
@Primary
DataSource primaryDataSource(
@Autowired @Qualifier("masterDataSource") DataSource masterDataSource,
@Autowired @Qualifier("slaveDataSource") DataSource slaveDataSource
) {
Map<Object, Object> map = new HashMap<>();
map.put("master", masterDataSource);
map.put("slave", slaveDataSource);
DynamicDataSource routing = new DynamicDataSource();
routing.setTargetDataSources(map);
routing.setDefaultTargetDataSource(masterDataSource);
return routing;
}

实现determineCurrentLookupKey方法

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 动态数据源
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
/**
* 指定路由Key
*/
@Override
protected Object determineCurrentLookupKey() {
return DynamicDataSourceContextHolder.getDataSource();
}
}

大家可能会好奇DynamicDataSourceContextHolder是个什么鬼:

在Servlet的线程模型中,使用ThreadLocal存储key最合适,因此,我们编写一个DynamicDataSourceContextHolder来设置并动态存储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
25
26
27
28
/**
* 根据当前线程来选择具体的数据源
*/
@UtilityClass
public class DynamicDataSourceContextHolder {
private final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

/**
* 提供给AOP去设置当前的线程的数据源的信息
*/
public void setDataSource(String dataSourceType) {
CONTEXT_HOLDER.set(dataSourceType);
}

/**
* 提供给AbstractRoutingDataSource的实现类,通过key选择数据源
*/
public String getDataSource() {
return CONTEXT_HOLDER.get();
}

/**
* 清除数据源
*/
public void clearDataSource() {
CONTEXT_HOLDER.remove();
}
}

这样,在某个地方,就可以动态设置DataSource的Key:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
@MapperScan("com.dreamlyn.dynamic.mapper")
class DynamicApplicationTests {
@Autowired
private MenuMapper menuMapper;
@Autowired
private UserMapper userMapper;

@Test
void dynamic() {
//设置数据源
DynamicDataSourceContextHolder.setDataSource("master");
List<User> users = userMapper.selectList(null);
log.info("user count:{}", users.size());

DynamicDataSourceContextHolder.setDataSource("slave");
List<Menu> menus = menuMapper.selectList(null);
log.info("menu count:{}", menus.size());
}
}

至此,我们已经成功实现了数据库的动态路由访问。

拓展

如果需要更方便一些,可以自己手动编写aop,通过注解来区分使用哪个数据源将更加方便,这种方法留给读者自己思考。

思考不出来可以参考代码:https://gitee.com/dreamlyn/dynamic