52.Spring实现数据库读写分离

1、背景

大多数系统都是读多写少，为了降低数据库的压力，可以对主库创建多个从库，从库自动从主库同步数据，程序中将写的操作发送到主库，将读的操作发送到从库去执行。

今天的主要目标：通过spring实现读写分离。

读写分离需实现下面2个功能：

1、由调用者通过参数来控制走主库还是从库

2、未指定走哪个库的，默认走主库

2、思考3个问题

1、控制具体是读从库还是主库，如何实现？

可以给方法添加一个参数，控制走从库还是主库。

2、数据源如何路由？

spring-jdbc 包中提供了一个抽象类：AbstractRoutingDataSource，实现了javax.sql.DataSource接口，我们用这个类来作为数据源类，重点是这个类可以用来做数据源的路由，可以在其内部配置多个真实的数据源，最终用哪个数据源，由开发者来决定。

AbstractRoutingDataSource中有个map，用来存储多个目标数据源

1. private Map<Object, DataSource> resolvedDataSources;

比如主从库可以这么存储

1. resolvedDataSources.put("master",主库数据源);
2. resolvedDataSources.put("salave",从库数据源);

AbstractRoutingDataSource中还有抽象方法determineCurrentLookupKey，将这个方法的返回值作为key到上面的resolvedDataSources中查找对应的数据源，作为当前操作db的数据源

1. protected abstract Object determineCurrentLookupKey();

3、读写分离在哪控制？

读写分离属于一个通用的功能，可以通过spring的aop来实现，添加一个拦截器，拦截目标方法的之前，在目标方法执行之前，获取一下当前需要走哪个库，将这个标志存储在ThreadLocal中，将这个标志作为AbstractRoutingDataSource.determineCurrentLookupKey()方法的返回值，截器中在目标方法执行完毕之后，将这个标志还原。

3、代码实现

3.1、工程结构图

3.2、DsType

表示数据源类型，有2个值，用来区分是主库还是从库。

1. package com.javacode2018.readwritesplit.base;
3. public enum DsType {
4. MASTER, SLAVE;
5. }

3.3、DsTypeHolder

内部有个ThreadLocal，用来记录当前走主库还是从库，将这个标志放在dsTypeThreadLocal中

1. package com.javacode2018.readwritesplit.base;
3. public class DsTypeHolder {
4. private static ThreadLocal<DsType> dsTypeThreadLocal = new ThreadLocal<>();
6. public static void setDsType(DsType dsType) {
7. dsTypeThreadLocal.set(dsType);
8. }
10. public static void master() {
11. setDsType(DsType.MASTER);
12. }
14. public static void slave() {
15. setDsType(DsType.SLAVE);
16. }
18. public static DsType getDsType() {
19. return dsTypeThreadLocal.get();
20. }
22. }

3.4、IService接口

这个接口起到标志的作用，当某个类需要启用读写分离的时候，需要实现这个接口，实现这个接口的类都会被读写分离拦截器拦截。

1. package com.javacode2018.readwritesplit.base;
3. //需要实现读写分离的service需要实现该接口
4. public interface IService {
5. }

3.5、ReadWriteDataSource

读写分离数据源，继承ReadWriteDataSource，注意其内部的determineCurrentLookupKey方法，从上面的ThreadLocal中获取当前需要走主库还是从库的标志。

1. package com.javacode2018.readwritesplit.base;
3. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
4. import org.springframework.lang.Nullable;
6. public class ReadWriteDataSource extends AbstractRoutingDataSource {
7. @Nullable
8. @Override
9. protected Object determineCurrentLookupKey() {
10. return DsTypeHolder.getDsType();
11. }
12. }

3.6、ReadWriteInterceptor

读写分离拦截器，需放在事务拦截器前面执行，通过@1代码我们将此拦截器的顺序设置为Integer.MAX_VALUE - 2，稍后我们将事务拦截器的顺序设置为Integer.MAX_VALUE - 1，事务拦截器的执行顺序是从小到达的，所以，ReadWriteInterceptor会在事务拦截器org.springframework.transaction.interceptor.TransactionInterceptor之前执行。

下面方法中会获取当前目标方法的最后一个参数，最后一个参数可以是DsType类型的，开发者可以通过这个参数来控制具体走主库还是从库。

1. package com.javacode2018.readwritesplit.base;
3. import org.aspectj.lang.ProceedingJoinPoint;
4. import org.aspectj.lang.annotation.Around;
5. import org.aspectj.lang.annotation.Aspect;
6. import org.aspectj.lang.annotation.Pointcut;
7. import org.springframework.core.annotation.Order;
8. import org.springframework.stereotype.Component;
10. import java.util.Objects;
12. @Aspect
13. @Order(Integer.MAX_VALUE - 2) //@1
14. @Component
15. public class ReadWriteInterceptor {
17. @Pointcut("target(IService)")
18. public void pointcut() {
19. }
21. //获取当前目标方法的最后一个参数
22. private Object getLastArgs(final ProceedingJoinPoint pjp) {
23. Object[] args = pjp.getArgs();
24. if (Objects.nonNull(args) && args.length > 0) {
25. return args[args.length - 1];
26. } else {
27. return null;
28. }
29. }
31. @Around("pointcut()")
32. public Object around(final ProceedingJoinPoint pjp) throws Throwable {
33. //获取当前的dsType
34. DsType oldDsType = DsTypeHolder.getDsType();
35. try {
36. //获取最后一个参数
37. Object lastArgs = getLastArgs(pjp);
38. //lastArgs为SLAVE，走从库，其他的走主库
39. if (DsType.SLAVE.equals(lastArgs)) {
40. DsTypeHolder.slave();
41. } else {
42. DsTypeHolder.master();
43. }
44. return pjp.proceed();
45. } finally {
46. //退出的时候，还原dsType
47. DsTypeHolder.setDsType(oldDsType);
48. }
49. }
50. }

3.7、ReadWriteConfiguration

spring配置类，作用

1、@3：用来将com.javacode2018.readwritesplit.base包中的一些类注册到spring容器中，比如上面的拦截器ReadWriteInterceptor

2、@1：开启spring aop的功能

3、@2：开启spring自动管理事务的功能，@EnableTransactionManagement的order用来指定事务拦截器org.springframework.transaction.interceptor.TransactionInterceptor顺序，在这里我们将order设置为Integer.MAX_VALUE - 1，而上面ReadWriteInterceptor的order是Integer.MAX_VALUE - 2，所以ReadWriteInterceptor会在事务拦截器之前执行。

1. package com.javacode2018.readwritesplit.base;
3. import org.springframework.context.annotation.ComponentScan;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
6. import org.springframework.transaction.annotation.EnableTransactionManagement;
8. @Configuration
9. @EnableAspectJAutoProxy //@1
10. @EnableTransactionManagement(proxyTargetClass = true, order = Integer.MAX_VALUE - 1) //@2
11. @ComponentScan(basePackageClasses = IService.class) //@3
12. public class ReadWriteConfiguration {
13. }

3.8、@EnableReadWrite

这个注解用来开启读写分离的功能，@1通过@Import将ReadWriteConfiguration导入到spring容器了，这样就会自动启用读写分离的功能。业务中需要使用读写分离，只需要在spring配置类中加上@EnableReadWrite注解就可以了。

1. package com.javacode2018.readwritesplit.base;
3. import org.springframework.context.annotation.Import;
5. import java.lang.annotation.*;
7. @Target(ElementType.TYPE)
8. @Retention(RetentionPolicy.RUNTIME)
9. @Documented
10. @Import(ReadWriteConfiguration.class) //@1
11. public @interface EnableReadWrite {
12. }

4、案例

读写分离的关键代码写完了，下面我们来上案例验证一下效果。

4.1、执行sql脚本

下面准备2个数据库：javacode2018_master（主库）、javacode2018_slave（从库）

2个库中都创建一个t_user表，分别插入了一条数据，稍后用这个数据来验证走的是主库还是从库。

1. DROP DATABASE IF EXISTS javacode2018_master;
2. CREATE DATABASE IF NOT EXISTS javacode2018_master;
4. USE javacode2018_master;
5. DROP TABLE IF EXISTS t_user;
6. CREATE TABLE t_user (
7. id INT PRIMARY KEY AUTO_INCREMENT,
8. name VARCHAR(256) NOT NULL DEFAULT ''
9. COMMENT '姓名'
10. );
12. INSERT INTO t_user (name) VALUE ('master库');
14. DROP DATABASE IF EXISTS javacode2018_slave;
15. CREATE DATABASE IF NOT EXISTS javacode2018_slave;
17. USE javacode2018_slave;
18. DROP TABLE IF EXISTS t_user;
19. CREATE TABLE t_user (
20. id INT PRIMARY KEY AUTO_INCREMENT,
21. name VARCHAR(256) NOT NULL DEFAULT ''
22. COMMENT '姓名'
23. );
24. INSERT INTO t_user (name) VALUE ('slave库');

4.2、spring配置类

@1：启用读写分离

masterDs()方法：定义主库数据源

slaveDs()方法：定义从库数据源

dataSource()：定义读写分离路由数据源

后面还有2个方法用来定义JdbcTemplate和事务管理器，方法中都通过@Qualifier(“dataSource”)限定了注入的bean名称为dataSource：即注入了上面dataSource()返回的读写分离路由数据源。

1. package com.javacode2018.readwritesplit.demo1;
3. import com.javacode2018.readwritesplit.base.DsType;
4. import com.javacode2018.readwritesplit.base.EnableReadWrite;
5. import com.javacode2018.readwritesplit.base.ReadWriteDataSource;
6. import org.springframework.beans.factory.annotation.Qualifier;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.context.annotation.ComponentScan;
9. import org.springframework.context.annotation.Configuration;
10. import org.springframework.jdbc.core.JdbcTemplate;
11. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
12. import org.springframework.transaction.PlatformTransactionManager;
14. import javax.sql.DataSource;
15. import java.util.HashMap;
16. import java.util.Map;
18. @EnableReadWrite //@1
19. @Configuration
20. @ComponentScan
21. public class MainConfig {
22. //主库数据源
23. @Bean
24. public DataSource masterDs() {
25. org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
26. dataSource.setDriverClassName("com.mysql.jdbc.Driver");
27. dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018_master?characterEncoding=UTF-8");
28. dataSource.setUsername("root");
29. dataSource.setPassword("root123");
30. dataSource.setInitialSize(5);
31. return dataSource;
32. }
34. //从库数据源
35. @Bean
36. public DataSource slaveDs() {
37. org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
38. dataSource.setDriverClassName("com.mysql.jdbc.Driver");
39. dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018_slave?characterEncoding=UTF-8");
40. dataSource.setUsername("root");
41. dataSource.setPassword("root123");
42. dataSource.setInitialSize(5);
43. return dataSource;
44. }
46. //读写分离路由数据源
47. @Bean
48. public ReadWriteDataSource dataSource() {
49. ReadWriteDataSource dataSource = new ReadWriteDataSource();
50. //设置主库为默认的库，当路由的时候没有在datasource那个map中找到对应的数据源的时候，会使用这个默认的数据源
51. dataSource.setDefaultTargetDataSource(this.masterDs());
52. //设置多个目标库
53. Map<Object, Object> targetDataSources = new HashMap<>();
54. targetDataSources.put(DsType.MASTER, this.masterDs());
55. targetDataSources.put(DsType.SLAVE, this.slaveDs());
56. dataSource.setTargetDataSources(targetDataSources);
57. return dataSource;
58. }
60. //JdbcTemplate，dataSource为上面定义的注入读写分离的数据源
61. @Bean
62. public JdbcTemplate jdbcTemplate(@Qualifier("dataSource") DataSource dataSource) {
63. return new JdbcTemplate(dataSource);
64. }
66. //定义事务管理器，dataSource为上面定义的注入读写分离的数据源
67. @Bean
68. public PlatformTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource) {
69. return new DataSourceTransactionManager(dataSource);
70. }
71. }

4.3、UserService

这个类就相当于我们平时写的service，我是为了方法，直接在里面使用了JdbcTemplate来操作数据库，真实的项目操作db会放在dao里面，这个类实现了IService接口，调用每个方法的时候，都会被ReadWriteInterceptor拦截器处理，根据方法最后一个参数路由到对应的库。

1. package com.javacode2018.readwritesplit.demo1;
3. import com.javacode2018.readwritesplit.base.DsType;
4. import com.javacode2018.readwritesplit.base.IService;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.jdbc.core.JdbcTemplate;
7. import org.springframework.stereotype.Component;
8. import org.springframework.transaction.annotation.Propagation;
9. import org.springframework.transaction.annotation.Transactional;
11. import java.util.List;
13. @Component
14. public class UserService implements IService {
16. @Autowired
17. private JdbcTemplate jdbcTemplate;
19. @Autowired
20. private UserService userService;
22. @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
23. public String getUserNameById(long id, DsType dsType) {
24. String sql = "select name from t_user where id=?";
25. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
26. return (list != null && list.size() > 0) ? list.get(0) : null;
27. }
29. //这个insert方法会走主库，内部的所有操作都会走主库
30. @Transactional
31. public void insert(long id, String name) {
32. System.out.println(String.format("插入数据{id:%s, name:%s}", id, name));
33. this.jdbcTemplate.update("insert into t_user (id,name) values (?,?)", id, name);
34. String userName = this.userService.getUserNameById(id, DsType.SLAVE);
35. System.out.println("查询结果：" + userName);
36. }
38. @Transactional(propagation = Propagation.REQUIRED)
39. public void test1(long id, DsType dsType) {
40. {
41. String sql = "select name from t_user where id=?";
42. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
43. System.out.println(list);
44. }
45. this.userService.test2(id, DsType.MASTER);
46. {
47. String sql = "select name from t_user where id=?";
48. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
49. System.out.println(list);
50. }
51. }
53. //propagation为REQUIRES_NEW，开启一个新的事务
54. @Transactional(propagation = Propagation.REQUIRES_NEW)
55. public void test2(long id, DsType dsType) {
56. String sql = "select name from t_user where id=?";
57. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
58. System.out.println(list);
59. }
61. }

4.4、测试用例

1. package com.javacode2018.readwritesplit.demo1;
3. import com.javacode2018.readwritesplit.base.DsType;
4. import org.junit.Before;
5. import org.junit.Test;
6. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
8. import javax.sql.DataSource;
9. import java.sql.Connection;
10. import java.sql.SQLException;
12. public class Demo1Test {
14. UserService userService;
16. @Before
17. public void before() {
18. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
19. context.register(MainConfig.class);
20. context.refresh();
21. this.userService = context.getBean(UserService.class);
22. }
24. @Test
25. public void test1() {
26. System.out.println(this.userService.getUserNameById(1, DsType.MASTER));
27. System.out.println(this.userService.getUserNameById(1, DsType.SLAVE));
28. }
30. @Test
31. public void test2() {
32. long id = System.currentTimeMillis();
33. System.out.println(id);
34. this.userService.insert(id, "张三");
35. }
37. @Test
38. public void test3() throws SQLException {
39. this.userService.test1(1, DsType.SLAVE);
40. }
41. }

test1方法执行2次查询，分别查询主库和从库，输出：

1. master库
2. slave库

是不是很爽，由开发者自己控制具体走主库还是从库。

test2执行结果如下，可以看出查询到了刚刚插入的数据，说明insert中所有操作都走的是主库。

1. 1604905117467
2. 插入数据{id:1604905117467, name:张三}
3. 查询结果：张三

重点来了，运行一下test3，输出

1. [slave库]
2. [master库]
3. [slave库]

test3方法中会调用this.userService.test1(1, DsType.SLAVE)，要求走从库，再来看看userService.test1的方法，如下，比较特殊，有事务嵌套，有3次查询，第1次和第3次都在test1这个事务中运行，用的是同一个连接，都走的从库，而中间的一次查询调用的是this.userService.test2(id, DsType.MASTER);，注意这个test2方法上面标注了@Transactional(propagation = Propagation.REQUIRES_NEW)，会重新开启一个事务，又由于第2个参数的值是DsType.MASTER，所以其内部会走主库。

1. @Transactional(propagation = Propagation.REQUIRED)
2. public void test1(long id, DsType dsType) {
3. {
4. String sql = "select name from t_user where id=?";
5. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
6. System.out.println(list);
7. }
8. //这里会调用this.userService.test2,会开启一个新事务，test2内部会走主库
9. this.userService.test2(id, DsType.MASTER);
10. {
11. String sql = "select name from t_user where id=?";
12. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
13. System.out.println(list);
14. }
15. }
17. //propagation为REQUIRES_NEW，开启一个新的事务
18. @Transactional(propagation = Propagation.REQUIRES_NEW)
19. public void test2(long id, DsType dsType) {
20. String sql = "select name from t_user where id=?";
21. List<String> list = this.jdbcTemplate.queryForList(sql, String.class, id);
22. System.out.println(list);
23. }

5、案例源码

1. git地址：
2. https://gitee.com/javacode2018/spring-series
4. 本文案例对应源码：
5. spring-series\lesson-004-readwritesplit