在Spring boot中使用AOP实现多数据源读写分离

发表于 | 分类于

1、建项目，引入依赖：

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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hu</groupId>
    <artifactId>database-read-write-demo1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

2、项目配置：

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
# 主数据源，默认
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
  master:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://172.16.3.34:3306/fenxiao_test?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
    initialSize: 5
    minIdle: 5
    maxActive: 50
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20

# 从数据源
  slave:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://172.16.3.34:3306/fenxiao_test?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
    initialSize: 5
    minIdle: 5
    maxActive: 50
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20

3、数据源配置和注解及读写分离配置

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
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceType {
    String value() default "";
}

/**
 * 构建数据源对象
 */
@ConditionalOnClass({EnableTransactionManagement.class})
@Configuration
public class DataSourceConfig {
    private static Logger log = LoggerFactory.getLogger(DataSourceConfig.class);

    @Value("${spring.datasource.type}")
    public Class<? extends DataSource> type;

    @Bean(name = "masterDataSource", destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.master")
    public DataSource masterDataSource() {
        log.info("************ masterDataSource init ************");
        return DataSourceBuilder.create().type(type).build();
    }

    @Bean(name = "slaveDataSource", destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.slave")
    public DataSource slaveDataSource() {
        log.info("************ slaveDataSource init ************");
        return DataSourceBuilder.create().type(type).build();
    }

    /**
     * 注册的bean放入一个map里面,后面就可以动态从这个map里面获取对应的数据源
     */
    @Bean
    public RoutingDataSource routingDataSource() {
        RoutingDataSource routingDataSource = new RoutingDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("write", masterDataSource());
        dataSourceMap.put("read", slaveDataSource());
        routingDataSource.setTargetDataSources(dataSourceMap);
        //默认数据源
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        return routingDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //这里直接写上面生成的Bean，不然@Value("${spring.datasource.type}")获取不到，就会走默认的连接池
        sqlSessionFactoryBean.setDataSource(routingDataSource());
        //sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/**/*.xml"));
        sqlSessionFactoryBean.setTypeAliasesPackage("com.hu.entity");
        sqlSessionFactoryBean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        return sqlSessionFactoryBean.getObject();
    }

}
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
/**
 * 根据ThreadLocal来实现数据源的动态改变
 */
public class DataSourceContextHolder {
    private static Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);

    private static ThreadLocal<String> datasourceContext = new ThreadLocal<>();

    public static void switchDataSource(String datasource) {
        log.info("数据源: {}", datasource);
        datasourceContext.set(datasource);
    }

    public static String getDataSource() {
        return datasourceContext.get();
    }

    public static void clear() {
        datasourceContext.remove();
    }
}

/**
 * AbstractRoutingDataSource提供了程序运行时动态切换数据源的方法 *
 * 在dao类或方法上标注需要访问数据源的关键字，路由到指定数据源，获取连接。
 *
 * 这里通过配置注解方式
 */
public class RoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

/**
 * 利用springAOP对方法的切入,在方法执行前判断使用哪个数据源
 */
@Aspect
@Component
public class DataSourceAop {
    private static Logger log = LoggerFactory.getLogger(DataSourceAop.class);

    @Pointcut("@annotation(com.hu.aop.DataSourceType)")
    public void cutMethod() {
    }

    @Before("cutMethod()")
    public void beforeRead(JoinPoint point) {
        String className = point.getTarget().getClass().getName();
        String methodName = point.getSignature().getName();
        log.info("执行" + className + "." + methodName + "()方法");
        Method method = ((MethodSignature) point.getSignature()).getMethod();
        DataSourceType annotation = method.getAnnotation(DataSourceType.class);
        if (null == annotation) {
            annotation = point.getTarget().getClass().getAnnotation(DataSourceType.class);        }
        if (null != annotation) {
            // 切换数据源
            DataSourceContextHolder.switchDataSource(annotation.value());
        }
    }
    @After("cutMethod()")
    public void afterExecute() {
        DataSourceContextHolder.clear();
    }
}

4、业务demo

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
public class Student implements Serializable {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }
    public Student(){}
    @Override
    public String toString() {
        return "\n{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

@Mapper
public interface StudentMapper {
    @Insert("insert into Student(name) values(#{name})")
    int insertStudent(Student student);

    @Select("select * from Student")
    List<Student> selectStudent();
}


@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    @DataSourceType("write")
    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @DataSourceType("read")
    @Transactional(propagation= Propagation.REQUIRED,isolation= Isolation.DEFAULT,readOnly=true)
    public List<Student> getStudents(){
        return studentMapper.selectStudent();
    }
}

5、测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RunWith(SpringRunner.class)
@SpringBootTest(classes = APP.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){
        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        System.out.println(studentService.saveStudent(student));

        System.out.println(Arrays.toString(studentService.getStudents().toArray()));
    }
}

结果：
数据源初始化

20200423140011

测试执行结果：

20200423135940

demo完成，还可以增加多个读库数据源，详见代码
https://github.com/huingsn/tech-point-record中的 database-read-write-demo1和database-read-write-demo

分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多