• SpringBoot采用AOP基于注解的方式实现多JDBC数据源

    目录

    1. 多数据源解决方案

    1. 通过中间件ShardingSphere、mycat、mysql-proxy、TDDL等。客户端直接连中间件，由中间件去分发操作哪个数据库
    2. 自己自定义实现

    2. 操作数据库流程

    操作数据库流程

    1. 客户端连接Mybatis等持久层框架
    2. Mybatis等持久层框架通过spring-data-jdbc获取DataSource
    3. DataSource通过getConnection获取数据库连接的JDBC Connection
    4. 由JDBC Connection对数据库进行操作

    所以知道了上面的流程，我们可以根据不同的业务情况，提供不同的DataSource，动态的提供DataSource

    3. Mysql数据准备

    分别创建read_db.user和write_db.user，并向read_db.user写入数据

    mysql> create database read_db;
Query OK, 1 row affected (0.14 sec)

mysql> create database write_db;
Query OK, 1 row affected (0.01 sec)

mysql> create table read_db.user (
    -> id bigint(20) auto_increment not null comment '主键ID',
    -> name varchar(30) null default null comment '姓名',
    -> primary key (id)
    -> );
Query OK, 0 rows affected, 1 warning (0.29 sec)

mysql> 
mysql> insert into read_db.user (id, name) values
    -> (1, 'read_name1'),
    -> (2, 'read_name2'),
    -> (3, 'read_name3'),
    -> (4, 'read_name4'),
    -> (5, 'read_name5');
Query OK, 5 rows affected (0.16 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> 
mysql> create table write_db.user (
    -> id bigint(20) auto_increment not null comment '主键ID',
    -> name varchar(30) null default null comment '姓名',
    -> primary key (id)
    -> );
Query OK, 0 rows affected, 1 warning (0.04 sec)

mysql> 

    • 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

    4. 通过AbstractRoutingDataSource自定义多JDBC数据源

    4.1 AbstractRoutingDataSource作用和原理

    我们可以通过org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource来帮我们实现动态数据源的切换，而且AbstractRoutingDataSource实现了很多DataSource的方法，稳定性更好

    AbstractRoutingDataSource需要给如下三个属性赋值：

    • targetDataSources：需要动态切换的所有DataSource
    • defaultTargetDataSource：默认DataSource
    • resolvedDataSources：内部在afterPropertiesSet方法中自动从targetDataSources传递

    动态选择DataSource的实现逻辑如下：

    1. 根据key从resolvedDataSources获取DataSource
    2. 如果没获取到，则获取defaultTargetDataSource
    3. 如果还是没获取到，则抛出异常
    ......省略部分......
    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = this.determineCurrentLookupKey();
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }

        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        } else {
            return dataSource;
        }
    }
......省略部分......

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    而这个determineCurrentLookupKey是由我们自定义的DynamicDataSourceConfig进行设置的

    所以我们的MyDynamicDataSourceConfig只需要继承AbstractRoutingDataSource，并完成上面的三个属性值设置，再做一些简单的配置即可

    4.2 pom.xml依赖

            
            mysql
            mysql-connector-java
            8.0.31
        

        
            com.alibaba
            druid
            1.2.15
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.5.2
        

        
        
            org.springframework.boot
            spring-boot-starter-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

    4.3 AbstractRoutingDataSource自定义多数据源实现

    4.3.1 application.properties配置

    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 用于读的数据库
spring.datasource.datasource1.url=jdbc:mysql://192.168.28.12:3306/read_db
spring.datasource.datasource1.username=root
spring.datasource.datasource1.password=Root_123
spring.datasource.datasource1.driver-class-name=com.mysql.cj.jdbc.Driver

# 用于写的数据库
spring.datasource.datasource2.url=jdbc:mysql://192.168.28.12:3306/write_db
spring.datasource.datasource2.username=root
spring.datasource.datasource2.password=Root_123
spring.datasource.datasource2.driver-class-name=com.mysql.cj.jdbc.Driver

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    4.3.2 多个DataSource实现

    实现功能：

    • 将spring.datasource.datasource1开头的配置，绑定到name = datasource1的DataSource组件上
    • 将spring.datasource.datasource2开头的配置，绑定到name = datasource2的DataSource组件上
    package com.hh.springboottest.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * @Author 贺欢
 * @Date 2022/11/24
 * @Description
 */
@Configuration
public class MyDataSourceConfig {

    @ConfigurationProperties(prefix = "spring.datasource.datasource1")
    // 向IOC容器添加name = dataSource1的DataSource
    @Bean
    public DataSource dataSource1() {
        DruidDataSource druidDataSource = new DruidDataSource();

        return druidDataSource;
    }

    @ConfigurationProperties(prefix = "spring.datasource.datasource2")
    // 向IOC容器添加name = dataSource2的DataSource
    @Bean
    public DataSource dataSource2() {
        DruidDataSource druidDataSource = new DruidDataSource();

        return druidDataSource;
    }
}

    • 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

    4.3.3 动态数据源DynamicDataSource的实现

    不使用AbstractRoutingDataSource。implement DataSource, InitializingBean说明：

    1. 在afterPropertiesSet方法中，初始化readOrWrite的值
    2. 重写getConnection方法，根据readOrWrite的值的不同，获取不同的dataSource返回Connection
    3. 重写DataSource的抽象方法。方法的返回对象测试时返回null等

    继承AbstractRoutingDataSource实现的功能：

    • 通过determineCurrentLookupKey方法获取当前读取标识
    • 通过determineCurrentLookupKey方法设置所有动态切换的DataSource和默认的DataSource
    package com.hh.springboottest.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/*
不使用AbstractRoutingDataSource。implement DataSource, InitializingBean说明：
1. 在afterPropertiesSet方法中，初始化readOrWrite的值
2. 重写getConnection方法，根据readOrWrite的值的不同，获取不同的dataSource返回Connection
3. 重写DataSource的抽象方法。方法的返回对象测试时返回null等
 */

@Component
// 当前IOC容器由dataSource1、dataSource2、当前DataSource
// Mapper获取DataSource时，优先获取当前DataSource
@Primary
public class MyDynamicDataSourceConfig extends AbstractRoutingDataSource {


    // 用于存放读写标识。ThreadLocal能保证多线程并发安全
    public static ThreadLocal readOrWrite = new ThreadLocal<>();

    // 从IOC容器获取name = dataSource1的DataSource
    @Autowired
    DataSource dataSource1;

    // 从IOC容器获取name = dataSource2的DataSource
    @Autowired
    DataSource dataSource2;

    // 返回当前的读写标识
    @Override
    protected Object determineCurrentLookupKey() {
        return readOrWrite.get();
    }

    // 初始化MyDynamicDataSourceConfig后，会调用该方法进行各种属性值的设置
    @Override
    public void afterPropertiesSet() {
        Map targetDataSources = new HashMap<>();
        targetDataSources.put("r", dataSource1);
        targetDataSources.put("w", dataSource2);

        super.setTargetDataSources(targetDataSources);

        super.setDefaultTargetDataSource(dataSource1);

        super.afterPropertiesSet();
    }
}

    • 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

    4.4 使用AOP基于注解实现动态数据源切换

    4.4.1 动态数据源注解

    说明：

    • 声明一个注解：MYDS，参数为字符串，用于指定datasource
    • @Target({ElementType.TYPE,ElementType.METHOD})：作用于类上和方法上
    • @Retention(RetentionPolicy.RUNTIME)：编译后会在Class文件中生成注解，运行时会通过反射进行加载。还有参数SOURCE: 编译后不会在Class文件中；参数CLASS: 编译后会在Class文件中生成注解，运行时不会通过反射进行加载
    package com.hh.springboottest.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MYDS {
    // 设置默认值
    String value() default "r";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    4.4.2 AOP实现

    说明：

    • 对MYDS注解设置的datasource进行拦截，然后设置到MyDynamicDataSourceConfig中
    • within指定要拦截的类，execution指定要拦截的方法
    • @annotation指定拦截的注解
    • 环绕通知包含了前置
    package com.hh.springboottest.aspect;

import com.hh.springboottest.annotation.MYDS;
import com.hh.springboottest.config.MyDynamicDataSourceConfig;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class DynamicDataSourceAspect {

    // 前置
    @Before("within(com.hh.springboottest.service.impl.*) && @annotation(myds)")
    public void before(JoinPoint point, MYDS myds) {
        String readOrWrite = myds.value();
        MyDynamicDataSourceConfig.readOrWrite.set(readOrWrite);

        System.out.println(readOrWrite);
    }

    // 环绕通知
}


    • 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

    4.5 动态数据源测试

    4.5.1 创建User类

    package com.hh.springboottest.myController;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class User {

    private Long id;
    private String name;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    4.5.2 Mapper接口实现

    package com.hh.springboottest.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hh.springboottest.myController.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper {

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4.5.3 Service实现

    Service接口实现

    package com.hh.springboottest.service;

import com.hh.springboottest.myController.User;

public interface UserService {

    public User getUser(Long id);

    public void saveUser(User user);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    ServiceImpl实现类

    package com.hh.springboottest.service.impl;

import com.hh.springboottest.mapper.UserMapper;
import com.hh.springboottest.myController.User;
import com.hh.springboottest.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    UserMapper userMapper;
    
    @MYDS("r")
    public User getUser(Long id) {
        return userMapper.selectById(id);
    }


    @MYDS("w")
    public void saveUser(User user) {
        userMapper.insert(user);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    4.5.4 测试

    package com.hh.springboottest;

import com.hh.springboottest.config.MyDynamicDataSourceConfig;
import com.hh.springboottest.myController.User;
import com.hh.springboottest.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
// 开启AOP功能
@EnableAspectJAutoProxy     
public class MyApplicationTest {

    @Autowired
    UserService userService;

    @Test
    public void readTest() {
        // 不使用AOP基于注解，手动切换数据源
        // MyDynamicDataSourceConfig.readOrWrite.set("r");

        User user = userService.getById(1);
        log.info("获取到的用户为：{}", user);
    }

    @Test
    public void writeTest() {
        // 不使用AOP基于注解，手动切换数据源
        // MyDynamicDataSourceConfig.readOrWrite.set("w");

        User user = new User(1L, "write_name1");
        userService.save(user);
    }
}

    • 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

    运行测试类，结果如下：

    r
2022-11-24 06:22:31.082  INFO 33932 --- [           main] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} inited
2022-11-24 06:22:31.082  INFO 33932 --- [           main] com.hh.springboottest.MyApplicationTest  : 获取到的用户为：User(id=1, name=read_name1)
2022-11-24 06:22:31.126  INFO 33932 --- [ionShutdownHook] com.alibaba.druid.pool.DruidDataSource   : {dataSource-0} closing ...
2022-11-24 06:22:31.126  INFO 33932 --- [ionShutdownHook] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closing ...
2022-11-24 06:22:31.131  INFO 33932 --- [ionShutdownHook] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} closed

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    同时查看write_db.user表，数据如下：

    mysql> select * from write_db.user;
+----+-------------+
| id | name        |
+----+-------------+
|  1 | write_name1 |
+----+-------------+
1 row in set (0.10 sec)

mysql>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    4.6 其他方式

    我们这里实现的，是使用AOP，适合复杂业务读写多数据源场景。还有另一种通过Mybatis插件的方式，适合读写分离业务

  • 相关阅读:
    webservice笔记
    60 个前端 Web 开发流行语你都知道哪些？
    tomcat
    JAVA的jdk1.8中文文档
    系统移植 串口输入ECHO点灯
    Java 学习笔记
    java-php-python-ssm学生综合测评系统计算机毕业设计
    Quartz核心原理之架构及基本元素介绍
    Python3操作Redis最新版|CRUD基本操作(保姆级)
    java中Runnable、Callable、Future、RunnableFuture、CompletionStage接口区别
  • 原文地址：https://blog.csdn.net/yy8623977/article/details/127993049