一、读写分离介绍

当使用Spring Boot开发数据库应用时，读写分离是一种常见的优化策略。读写分离将读操作和写操作分别分配给不同的数据库实例，以提高系统的吞吐量和性能。

读写分离实现主要是通过动态数据源功能实现的，动态数据源是一种通过在运行时动态切换数据库连接的机制。它允许应用程序根据不同的条件或配置选择不同的数据源，以实现更灵活和可扩展的数据库访问。

二、实现读写分离-基础

1. 配置主数据库和从数据库的连接信息

1# 主库配置
2spring.datasource.master.jdbc-url=jdbc:mysql://ip:port/master?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
3spring.datasource.master.username=master
4spring.datasource.master.password=123456
5spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
6
7# 从库配置
8spring.datasource.slave.jdbc-url=jdbc:mysql://ip:port/slave?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
9spring.datasource.slave.username=slave
10spring.datasource.slave.password=123456
11spring.datasource.slave.driver-class-name=com.mysql.jdbc.Driver 
12

2. 创建主数据库和从数据库的数据源配置类

通过不同的条件限制和配置文件前缀可以完成不同数据源的创建工作，不止是主从也可以是多个不同的数据库

主库数据源配置

1@Configuration
2@ConditionalOnProperty("spring.datasource.master.jdbc-url")
3public class MasterDataSourceConfiguration {
4    @Bean("masterDataSource")
5    @ConfigurationProperties(prefix = "spring.datasource.master")
6    public DataSource masterDataSource() {
7        return DataSourceBuilder.create().build();
8    }
9}
10

从库数据源配置

1@Configuration
2@ConditionalOnProperty("spring.datasource.slave.jdbc-url")
3public class SlaveDataSourceConfiguration {
4    @Bean("slaveDataSource")
5    @ConfigurationProperties(prefix = "spring.datasource.slave")
6    public DataSource slaveDataSource() {
7        return DataSourceBuilder.create().build();
8    }
9}
10
11
12

3. 创建主从数据源枚举

1public enum DataSourceTypeEnum {
2    /**
3     * 主库
4     */
5    MASTER,
6
7    /**
8     * 从库
9     */
10    SLAVE,
11   ;
12  
13}
14

4. 创建动态路由数据源

这儿做了一个开关，可以控制读写分离的开启和关闭工作，可以讲操作全部切换到主库进行。然后根据上下文中的数据源类型来返回不同的数据源类型枚举

1@Slf4j
2public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
3
4    @Value("${DB_RW_SEPARATE_SWITCH:false}")
5    private boolean dbRwSeparateSwitch;
6    @Override
7    protected Object determineCurrentLookupKey() {
8        if(dbRwSeparateSwitch && DataSourceTypeEnum.SLAVE.equals(DataSourceContextHolder.getDataSourceType())) {
9            log.info("DynamicRoutingDataSource 切换数据源到从库");
10            return DataSourceTypeEnum.SLAVE;
11        }
12        log.info("DynamicRoutingDataSource 切换数据源到主库");
13        // 根据需要指定当前使用的数据源，这里可以使用ThreadLocal或其他方式来决定使用主库还是从库
14        return DataSourceTypeEnum.MASTER;
15    }
16}
17

5. 创建动态数据源配置类

将主数据库和从数据库的数据源添加到动态数据源中，并可以通过枚举创建一个数据源 map，这样就可以通过上面的路由返回的枚举来切换数据源

1@Configuration
2@ConditionalOnProperty("spring.datasource.master.jdbc-url")
3public class DynamicDataSourceConfiguration {
4    @Bean("dataSource")
5    @Primary
6    public DataSource dynamicDataSource(DataSource masterDataSource, DataSource slaveDataSource) {
7        Map<Object, Object> targetDataSources = new HashMap<>();
8        targetDataSources.put(DataSourceTypeEnum.MASTER, masterDataSource);
9        targetDataSources.put(DataSourceTypeEnum.SLAVE, slaveDataSource);
10
11        DynamicRoutingDataSource dynamicDataSource = new DynamicRoutingDataSource();
12        dynamicDataSource.setTargetDataSources(targetDataSources);
13        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
14        return dynamicDataSource;
15    }
16}
17

6. 创建DatasourceContextHolder类使用ThreadLocal存储当前线程的数据源类型

注意这儿有个潜在风险就是创建新的线程时会导致 ThreadLocal 中的数据无法正确读取，如果涉及到在开启新线程可以使用 TransmittableThreadLocal 来进行父子线程数据的同步，git 地址： https://github.com/alibaba/transmittable-thread-local

1public class DataSourceContextHolder {
2    private static final ThreadLocal<DataSourceTypeEnum> contextHolder = new ThreadLocal<>();
3
4    public static void setDataSourceType(DataSourceTypeEnum dataSourceType) {
5        contextHolder.set(dataSourceType);
6    }
7
8    public static DataSourceTypeEnum getDataSourceType() {
9        return contextHolder.get();
10    }
11
12    public static void clearDataSourceType() {
13        contextHolder.remove();
14    }
15}
16

7. 创建自定义注解，用于标记主和从数据源

1@Retention(RetentionPolicy.RUNTIME)
2@Target(ElementType.METHOD)
3public @interface MasterDataSource {
4}
5

1@Retention(RetentionPolicy.RUNTIME)
2@Target(ElementType.METHOD)
3public @interface SlaveDataSource {
4}
5

8. 创建切面类，拦截数据库操作，并根据注解设置切换数据源参数

1@Aspect
2@Component
3public class DataSourceAspect {
4
5    @Before("@annotation(xxx.MasterDataSource)")
6    public void setMasterDataSource(JoinPoint joinPoint) {
7        DataSourceContextHolder.setDataSourceType(DataSourceTypeEnum.MASTER);
8    }
9
10    @Before("@annotation(xxx.SlaveDataSource)")
11    public void setSlaveDataSource(JoinPoint joinPoint) {
12        DataSourceContextHolder.setDataSourceType(DataSourceTypeEnum.SLAVE);
13    }
14
15    @After("@annotation(xxx.MasterDataSource) || @annotation(xxx.SlaveDataSource)")
16    public void clearDataSource(JoinPoint joinPoint) {
17        DataSourceContextHolder.clearDataSourceType();
18    }
19}
20

9. 在Service层的方法上使用自定义注解标记查询数据源

1@Service
2public class TestService {
3    @Autowired
4    private TestDao testDao;
5
6    @SlaveDataSource
7    public Test test() {
8        return testDao.queryByPrimaryKey(11L);
9    }
10}
11

10. 排除掉数据源自动配置类

如果不排除自动配置类会导致初始化多个 dataSource 对象导致出现问题

1SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
2

三、实现读写分离-进阶

1. 使用链接池，以Hikari为例

修改链接配置，加入链接池相关配置即可

1# 主库配置
2spring.datasource.master.jdbc-url=jdbc:mysql://ip:port/master?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
3spring.datasource.master.username=master
4spring.datasource.master.password=123456
5spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
6spring.datasource.master.type=com.zaxxer.hikari.HikariDataSource
7spring.datasource.master.hikari.name=master
8spring.datasource.master.hikari.minimum-idle=5
9spring.datasource.master.hikari.idle-timeout=30
10spring.datasource.master.hikari.maximum-pool-size=10
11spring.datasource.master.hikari.auto-commit=true
12spring.datasource.master.hikari.pool-name=DatebookHikariCP
13spring.datasource.master.hikari.max-lifetime=1800000
14spring.datasource.master.hikari.connection-timeout=30000
15spring.datasource.master.hikari.connection-test-query=SELECT 1
16
17# 从库配置
18spring.datasource.slave.jdbc-url=jdbc:mysql://ip:port/slave?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
19spring.datasource.slave.username=root
20spring.datasource.slave.password=123456
21spring.datasource.slave.driver-class-name=com.mysql.jdbc.Driver
22spring.datasource.slave.type=com.zaxxer.hikari.HikariDataSource
23spring.datasource.slave.hikari.name=master
24spring.datasource.slave.hikari.minimum-idle=5
25spring.datasource.slave.hikari.idle-timeout=30
26spring.datasource.slave.hikari.maximum-pool-size=10
27spring.datasource.slave.hikari.auto-commit=true
28spring.datasource.slave.hikari.pool-name=DatebookHikariCP
29spring.datasource.slave.hikari.max-lifetime=1800000
30spring.datasource.slave.hikari.connection-timeout=30000
31spring.datasource.slave.hikari.connection-test-query=SELECT 1
32

2. 集成 mybatis 并在写入时强制切换到主库

不需要做任何配置，正常集成 mybatis 即可使用读写分离功能

可以通过 mybatis 的拦截器在写入操作时强制切换到主库

1@Intercepts({
2        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
3})
4@Component
5public class WriteInterceptor implements Interceptor {
6    @Override
7    public Object intercept(Invocation invocation) throws Throwable {
8        // 获取 SQL 类型
9        DataSourceTypeEnum dataSourceType = DataSourceContextHolder.getDataSourceType();
10        if(DataSourceTypeEnum.SLAVE.equals(dataSourceType)) {
11            DataSourceContextHolder.setDataSourceType(DataSourceTypeEnum.MASTER);
12        }
13        try {
14            // 执行 SQL
15            return invocation.proceed();
16        } finally {
17            // 恢复数据源  考虑到写入后可能会反查，后续都走主库
18            // DataSourceContextHolder.setDataSourceType(dataSourceType);
19        }
20    }
21}
22

作者：京东健康苏曼

来源：京东云开发者社区转发请注明来源

SpringBoot 项目优雅实现读写分离 | 京东云技术团队