SpringBoot3动态切换数据源

     背景

        随着公司业务战略的发展，相关的软件服务也逐步的向多元化变革，之前是单纯的拿项目，赚人工钱，现在开始向产物化\服务化变革。迩来雷袭又接到一项新的挑战：相识SAAS模型，思量怎么将公司的产物转换成多租户架构。
        经过一番百度，雷袭对多租户架构总算有了一番相识，以下是整理的笔记。
        多租户架构是一种软件架构，用于实现多用户环境下，使用相同的系统或步伐组件时，能保证用户之间数据的隔离性。简单说就是使用共用的数据中心，通过单一系统架构与服务提供多数客户端相同甚至可定制化的服务，并且保障客户的数据隔离。一个支持多租户架构的系统需要在设计上对它的数据和设置举行虚拟分区，从而使系统的每个租户或组织都能够使用一个单独的系统实例，每个租户都可以根据本身的需求对租用的系统实例举行个性化设置。

        多租户技能的实现重点在于差异租户间应用步伐环境的隔离以及数据的隔离，使得差异租户间应用步伐不会相互干扰。应用步伐可通过历程隔离大概多种运维工具实现，数据存储上的隔离方案则是有三种：
        1、独立数据库：优点是独立性最高，缺点是数据库较多，购置和维护成本高。
        2、共享数据库，隔离数据架构：同一个数据库实例内多个用户/schema来对应多个租户，优点是单实例可以支持更多租户，缺点是数据恢复比较困难。
        3、共享数据库，共享数据布局：物理分表，表分区，大概在表中通过字段区分，优点是成本最低，实现难度低，缺点是数据隔离水平低。
        第三种其实雷袭已经试过了，之前的博客里就提到了表分区，分表的实现方式，这里不多缀述，今天雷袭想试试前面两种，因此不得不办理的一个问题：如何实现同一个项目中，数据源的动态切换？

     代码实践

        雷袭在网上查阅了许多资料，最终找到了两种合适的方式实现，一种是通过AOP来实现，另一种是通过Filter实现，以下是实现的方式说明。
       一、通过切面实现

        1、准备工作，创建数据库模式，添加测试数据：

1. --先创建三个用户，设置密码
2. SAAS_MASTER   leixi123
3. SAAS_DEV   leixi123
4. SAAS_UAT   leixi123
6. --再用sysdba给用户授权
7. grant dba to SAAS_MASTER;
8. grant resource to SAAS_MASTER;
9. grant dba to SAAS_DEV;
10. grant resource to SAAS_DEV;
11. grant dba to SAAS_UAT;
12. grant resource to SAAS_UAT;
15. CREATE TABLE SAAS_MASTER."sys_db_info"
16. (
17.     "id" VARCHAR2(32) NOT NULL,
18.     "url" VARCHAR2(255) NOT NULL,
19.     "username" VARCHAR2(255) NOT NULL,
20.     "password" VARCHAR2(255) NOT NULL,
21.     "driver_class_name" VARCHAR2(255) NOT NULL,
22.     "db_name" VARCHAR2(255) NOT NULL,
23.     "db_key" VARCHAR2(255) NOT NULL,
24.     "status" INT DEFAULT '0' NOT NULL,
25.     "remark" VARCHAR2(255) DEFAULT NULL,
26.      PRIMARY KEY("id")) ;
28. COMMENT ON TABLE SAAS_MASTER."sys_db_info" IS '数据库配置信息表';
29. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."db_key" IS '数据库key，即保存Map中的key(保证唯一，并且和DataSourceType中的枚举项保持一致，包括大小写)';
30. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."db_name" IS '数据库名称';
31. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."driver_class_name" IS '数据库驱动';
32. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."id" IS '主键ID';
33. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."password" IS '密码';
34. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."remark" IS '备注说明';
35. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."status" IS '是否停用';
36. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."url" IS '数据库URL';
37. COMMENT ON COLUMN SAAS_MASTER."sys_db_info"."username" IS '用户名';
39. --添加数据源信息
40. insert into SAAS_MASTER."sys_db_info" ("id","url","username","password","driver_class_name","db_name","db_key","status","remark")
41. values ('1', 'jdbc:dm://127.0.0.1:5236/SAAS_DEV', 'SAAS_DEV', 'leixi123', 'dm.jdbc.driver.DmDriver', 'DEV', 'DEV', 0, '连接DEV数据库');
42. insert into SAAS_MASTER."sys_db_info" ("id","url","username","password","driver_class_name","db_name","db_key","status","remark")
43. values ('2', 'jdbc:dm://127.0.0.1:5236/SAAS_UAT', 'SAAS_UAT', 'leixi123', 'dm.jdbc.driver.DmDriver', 'UAT', 'UAT', 0, '连接UAT数据库');
45. --添加测试数据库
46. CREATE TABLE SAAS_MASTER.leixi_test (
47.   id VARCHAR2(32) NOT NULL,
48.   name VARCHAR2(255) NOT NULL,
49.   PRIMARY KEY (id)
50. ) ;
52. CREATE TABLE SAAS_DEV.leixi_test (
53.     id VARCHAR2(32) NOT NULL,
54.     name VARCHAR2(255) NOT NULL,
55.     PRIMARY KEY (id)
56. ) ;
58. CREATE TABLE SAAS_UAT.leixi_test (
59.      id VARCHAR2(32) NOT NULL,
60.      name VARCHAR2(255) NOT NULL,
61.      PRIMARY KEY (id)
62. ) ;
65. insert into SAAS_MASTER.leixi_test(id, name) values('', '这里是leixi_test 的MASTER库数据');
66. insert into SAAS_DEV.leixi_test(id, name) values('1', '这里是leixi_test 的DEV库数据');
67. insert into SAAS_UAT.leixi_test(id, name) values('1', '这里是leixi_test 的UAT数据');

复制代码

        2、创建一个springboot项目，项目环境为JDK17，以下是相关设置和代码：
        pom.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
3.     <modelVersion>4.0.0</modelVersion>
4.     <packaging>jar</packaging>
5.     <parent>
6.         <groupId>org.springframework.boot</groupId>
7.         <artifactId>spring-boot-starter-parent</artifactId>
8.         <version>3.3.2</version> <!-- lookup parent from repository -->
9.     </parent>
10.     <groupId>com.leixi.hub.saasdb</groupId>
11.     <artifactId>leixi-saas-db</artifactId>
12.     <version>1.0-SNAPSHOT</version>
13.     <name>leixi-saas-db</name>
14.     <description>用于动态切换数据源</description>
15.     <properties>
16.         <maven.compiler.source>17</maven.compiler.source>
17.         <maven.compiler.target>17</maven.compiler.target>
18.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
20.         <hutool.version>5.8.15</hutool.version>
21.         <mysql.version>8.0.28</mysql.version>
22.         <druid.version>1.2.16</druid.version>
23.         <mybatis-plus.version>3.5.3.1</mybatis-plus.version>
24.         <lombok-mapstruct-binding.version>0.2.0</lombok-mapstruct-binding.version>
25.     </properties>
26.     <dependencies>
27.         <!-- Lombok -->
28.         <dependency>
29.             <groupId>org.projectlombok</groupId>
30.             <artifactId>lombok</artifactId>
31.             <!--编译测试环境，不打包在lib-->
32.             <scope>provided</scope>
33.         </dependency>
34.         <!-- 允许使用Lombok的Java Bean类中使用MapStruct注解 (Lombok 1.18.20+) -->
35.         <dependency>
36.             <groupId>org.projectlombok</groupId>
37.             <artifactId>lombok-mapstruct-binding</artifactId>
38.             <version>${lombok-mapstruct-binding.version}</version>
39.             <scope>provided</scope>
40.         </dependency>
42.         <!--    hutool工具包    -->
43.         <dependency>
44.             <groupId>cn.hutool</groupId>
45.             <artifactId>hutool-all</artifactId>
46.             <version>${hutool.version}</version>
47.         </dependency>
49.         <!-- web支持 -->
50.         <dependency>
51.             <groupId>org.springframework.boot</groupId>
52.             <artifactId>spring-boot-starter-web</artifactId>
53.         </dependency>
55.         <!-- aop -->
56.         <dependency>
57.             <groupId>org.springframework.boot</groupId>
58.             <artifactId>spring-boot-starter-aop</artifactId>
59.         </dependency>
62.         <!-- DM驱动 -->
63.         <dependency>
64.             <groupId>com.dameng</groupId>
65.             <artifactId>DmJdbcDriver18</artifactId>
66.             <version>8.1.1.193</version>
67.         </dependency>
69.         <!--    阿里druid工具包    -->
70.         <dependency>
71.             <groupId>com.alibaba</groupId>
72.             <artifactId>druid-spring-boot-starter</artifactId>
73.             <version>${druid.version}</version>
74.         </dependency>
76.         <dependency>
77.             <groupId>com.alibaba</groupId>
78.             <artifactId>fastjson</artifactId>
79.             <version>2.0.40</version>
80.         </dependency>
82.         <!-- mybatis-plus -->
83.         <dependency>
84.             <groupId>com.baomidou</groupId>
85.             <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
86.             <version>3.5.5</version>
87.         </dependency>
90.     </dependencies>
92.     <build>
93.         <plugins>
94.             <plugin>
95.                 <groupId>org.springframework.boot</groupId>
96.                 <artifactId>spring-boot-maven-plugin</artifactId>
97.             </plugin>
98.             <plugin>
99.                 <groupId>org.apache.maven.plugins</groupId>
100.                 <artifactId>maven-archetype-plugin</artifactId>
101.                 <version>3.0.0</version>
102.             </plugin>
103.         </plugins>
104.     </build>
106. </project>

复制代码

        application.yml

1. server:
2.   port: 19200
3.   servlet:
4.     context-path: /leixi
6. spring:
7.   jackson:
8.     ## 默认序列化时间格式
9.     date-format: yyyy-MM-dd HH:mm:ss
10.     ## 默认序列化时区
11.     time-zone: GMT+8
12.   datasource:
13.     type: com.alibaba.druid.pool.DruidDataSource
14.     driver-class-name: dm.jdbc.driver.DmDriver
15.     url: jdbc:dm://127.0.0.1:5236/SAAS_MASTER
16.     username: SAAS_MASTER
17.     password: leixi123
18.     druid:
19.       slave: false
20.       initial-size: 15
21.       min-idle: 15
22.       max-active: 200
23.       max-wait: 60000
24.       time-between-eviction-runs-millis: 60000
25.       min-evictable-idle-time-millis: 300000
26.       validation-query: ""
27.       test-while-idle: true
28.       test-on-borrow: false
29.       test-on-return: false
30.       pool-prepared-statements: false
31.       connection-properties: false
32.   task:
33.     execution:
34.       thread-pool:
35.         core-size: 10
36.         max-size: 20
37.         queue-capacity: 100
38. mybatis-plus:
39.   mapper-locations: classpath:/mapper/**/*Mapper.xml
40.   global-config:
41.     db-config:
42.       #主键类型  0:"数据库ID自增",1:"该类型为未设置主键类型", 2:"用户输入ID",3:"全局唯一ID (数字类型唯一ID)", 4:"全局唯一ID UUID";
43.       id-type: assign_uuid
44.       # 默认数据库表下划线命名
45.       table-underline: true
46.   configuration:
47.     # 返回类型为Map,显示null对应的字段
48.     call-setters-on-nulls: true
49.     map-underscore-to-camel-case: true #开启驼峰和下划线互转
50.     # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
51.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
52. leixi:
53.   saas:
54.     data_source_key: data_source_key
55.     load_source_form_db: true

复制代码

        以下是设置数据源的核心代码，其原理为：在项目启动时先通过LoadDataSourceRunner从数据库中查询相关的数据连接，存储在内存中，对Controller中的方法添加@DataSource注解，执行方法时，通过注解中的静态摆列切换对应的数据源，对指定的数据库举行操作。

1. package com.leixi.hub.saasdb.config;
3. import com.alibaba.druid.pool.DruidDataSource;
4. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
5. import com.leixi.hub.saasdb.entity.SysDbInfo;
6. import lombok.extern.slf4j.Slf4j;
7. import org.springframework.beans.BeanUtils;
8. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
10. import javax.sql.DataSource;
11. import java.sql.DriverManager;
12. import java.sql.SQLException;
13. import java.util.List;
14. import java.util.Map;
15. import java.util.Objects;
18. /**
19. * 实现动态数据源，根据AbstractRoutingDataSource路由到不同数据源中
20. *
21. * @author 雷袭月启
22. * @since 2024/12/5 19:39
23. */
24. @Slf4j
25. public class DynamicDataSource extends AbstractRoutingDataSource {
27.     // 数据源列表，多数据源情况下，具体使用哪一个数据源，由此获取
28.     private final Map<Object, Object> targetDataSourceMap;
30.     /**
31.      * 构造方法，设置默认数据源和目标多数据源
32.      *
33.      * @param defaultDataSource 默认主数据源，只能有一个
34.      * @param targetDataSources 从数据源，可以是多个
35.      */
36.     public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSources) {
37.         super.setDefaultTargetDataSource(defaultDataSource);
38.         super.setTargetDataSources(targetDataSources);
39.         this.targetDataSourceMap = targetDataSources;
40.     }
42.     /**
43.      * 动态数据源的切换（核心）
44.      * 决定使用哪个数据源
45.      *
46.      * @return Object
47.      */
48.     @Override
49.     protected Object determineCurrentLookupKey() {
50.         return DynamicDataSourceContextHolder.getDataSource();
51.     }
53.     /**
54.      * 添加数据源信息
55.      *
56.      * @param dataSources 数据源实体集合
57.      */
58.     public void createDataSource(List<SysDbInfo> dataSources) {
59.         try {
60.             if (CollectionUtils.isNotEmpty(dataSources)) {
61.                 for (SysDbInfo ds : dataSources) {
62.                     //校验数据库是否可以连接
63.                     Class.forName(ds.getDriverClassName());
64.                     DriverManager.getConnection(ds.getUrl(), ds.getUsername(), ds.getPassword());
65.                     //定义数据源
66.                     DruidDataSource dataSource = new DruidDataSource();
67.                     BeanUtils.copyProperties(ds, dataSource);
68.                     //申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
69.                     dataSource.setTestOnBorrow(true);
70.                     //建议配置为true，不影响性能，并且保证安全性。
71.                     //申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
72.                     dataSource.setTestWhileIdle(true);
73.                     //用来检测连接是否有效的sql，要求是一个查询语句。
74.                     dataSource.setValidationQuery("select 1 ");
75.                     dataSource.init();
76.                     // 将数据源放入Map中，key为数据源名称，要和DataSourceType中的枚举项对应，包括大小写，并且保证唯一
77.                     this.targetDataSourceMap.put(ds.getDbKey(), dataSource);
78.                 }
79.                 // 更新数据源配置列表，这里主要是从数据源
80.                 super.setTargetDataSources(this.targetDataSourceMap);
81.                 // 将TargetDataSources中的连接信息放入resolvedDataSources管理
82.                 super.afterPropertiesSet();
83.             }
84.         } catch (ClassNotFoundException | SQLException e) {
85.             log.error("---解析数据源出错---：{}", e.getMessage());
86.         }
87.     }
89.     /**
90.      * 校验数据源是否存在
91.      *
92.      * @param key 数据源保存的key
93.      * @return 返回结果，true：存在，false：不存在
94.      */
95.     public boolean existsDataSource(String key) {
96.         return Objects.nonNull(this.targetDataSourceMap) && Objects.nonNull(this.targetDataSourceMap.get(key));
97.     }
98. }

复制代码

1. package com.leixi.hub.saasdb.config;
2. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
3. import org.springframework.boot.context.properties.ConfigurationProperties;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.context.annotation.Primary;
8. import javax.sql.DataSource;
9. import java.util.HashMap;
10. import java.util.Map;
12. /**
13. * 设置数据源
14. *
15. * @author 雷袭月启
16. * @since 2024/12/5 19:39
17. */
18. @Configuration
19. public class DataSourceConfig {
21.     private static final String MASTER_SOURCE_KEY = "MASTER";
23.     /**
24.      * 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
25.      *
26.      * @return DataSource
27.      * @description 该数据源是在application配置文件master中所配置的
28.      */
29.     @Bean
30.     @ConfigurationProperties("spring.datasource")
31.     public DataSource masterDataSource() {
32.         return DruidDataSourceBuilder.create().build();
33.     }
35.     /**
36.      * 配置动态数据源的核心配置项
37.      *
38.      * @return DynamicDataSource
39.      */
40.     @Primary
41.     @Bean(name = "dynamicDataSource")
42.     public DynamicDataSource createDynamicDataSource() {
43.         Map<Object, Object> dataSourceMap = new HashMap<>();
44.         // 默认的数据源（主数据源）
45.         DataSource defaultDataSource = masterDataSource();
46.         // 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
47.         dataSourceMap.put(MASTER_SOURCE_KEY, defaultDataSource);
48.         // 配置动态数据源，默认使用主数据源，如果有从数据源配，则使用从数据库中读取源，并加载到dataSourceMap中
49.         return new DynamicDataSource(defaultDataSource, dataSourceMap);
50.     }
51. }

复制代码

1. package com.leixi.hub.saasdb.config;
2. /**
3. * 动态数据源类型
4. *
5. * @author 雷袭月启
6. * @since 2024/12/5 19:39
7. */
8. public enum DataSourceType {
9.     // 注意：枚举项要和 DataSourceConfig 中的 createDynamicDataSource()方法dataSourceMap的key保持一致
10.     /**
11.      * 主库
12.      */
13.     MASTER,
14.     /**
15.      * 从库
16.      */
17.     UAT,
18. }

复制代码

1. package com.leixi.hub.saasdb.config;
3. import lombok.extern.slf4j.Slf4j;
5. /**
6. * 创建一个类用于实现ThreadLocal，主要是通过get，set，remove方法来获取、设置、删除当前线程对应的数据源。
7. *
8. * @author 雷袭月启
9. * @since 2024/12/5 19:39
10. */
11. @Slf4j
12. public class DynamicDataSourceContextHolder {
13.     //此类提供线程局部变量。这些变量不同于它们的正常对应关系是每个线程访问一个线程(通过get、set方法),有自己的独立初始化变量的副本。
14.     private static final ThreadLocal<String> DATASOURCE_HOLDER = new ThreadLocal<>();
16.     /**
17.      * 设置数据源
18.      *
19.      * @param dataSourceName 数据源名称
20.      */
21.     public static void setDataSource(String dataSourceName) {
22.         log.info("切换数据源到：{}", dataSourceName);
23.         DATASOURCE_HOLDER.set(dataSourceName);
24.     }
26.     /**
27.      * 获取当前线程的数据源
28.      *
29.      * @return 数据源名称
30.      */
31.     public static String getDataSource() {
32.         return DATASOURCE_HOLDER.get();
33.     }
35.     /**
36.      * 删除当前数据源
37.      */
38.     public static void removeDataSource() {
39.         log.info("删除当前数据源：{}", getDataSource());
40.         DATASOURCE_HOLDER.remove();
41.     }
42. }

复制代码

1. package com.leixi.hub.saasdb.config;
3. import cn.hutool.core.util.StrUtil;
4. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
5. import com.leixi.hub.saasdb.dao.SysDbInfoMapper;
6. import com.leixi.hub.saasdb.entity.SysDbInfo;
7. import jakarta.annotation.Resource;
8. import lombok.extern.slf4j.Slf4j;
9. import org.springframework.beans.factory.annotation.Value;
10. import org.springframework.boot.CommandLineRunner;
11. import org.springframework.stereotype.Component;
12. import org.springframework.util.CollectionUtils;
14. import java.util.ArrayList;
15. import java.util.List;
18. /**
19. *  CommandLineRunner 项目启动时执行
20. *
21. * @author 雷袭月启
22. * @since 2024/12/5 19:39
23. */
24. @Slf4j
25. @Component
26. public class LoadDataSourceRunner implements CommandLineRunner {
27.     /**
28.      * 是否启用从库多数据源配置
29.      */
30.     @Value("${leixi.saas.load_source_form_db:false}")
31.     private boolean enabled;
32.     @Resource
33.     private DynamicDataSource dynamicDataSource;
34.     @Resource
35.     private SysDbInfoMapper dbInfoMapper;
37.     /**
38.      * 项目启动时加载数据源
39.      */
40.     @Override
41.     public void run(String... args) {
42.         if (!enabled) return;
43.         refreshDataSource();
44.     }
46.     /**
47.      * 刷新数据源
48.      */
49.     public void refreshDataSource() {
50.         List<SysDbInfo> dbInfos = dbInfoMapper.selectList(new LambdaQueryWrapper<SysDbInfo>().eq(SysDbInfo::getStatus, 0));
51.         if (CollectionUtils.isEmpty(dbInfos)) return;
52.         List<SysDbInfo> ds = new ArrayList<>();
53.         log.info("====开始加载数据源====");
54.         for (SysDbInfo info : dbInfos) {
55.             if (StrUtil.isAllNotBlank(
56.                     info.getUrl(), // 数据库连接地址
57.                     info.getDriverClassName(), // 数据库驱动
58.                     info.getUsername(), // 数据库用户名
59.                     info.getPassword(), // 数据库密码
60.                     info.getDbKey() // 数据源key
61.             )) {
62.                 ds.add(info);
63.                 log.info("加载到数据源 ---> dbName：{}、dbKey：{}、remark：{}", info.getDbName(), info.getDbKey(), info.getRemark());
64.             }
65.         }
66.         dynamicDataSource.createDataSource(ds);
67.         log.info("====数据源加载完成====");
68.     }
69. }

复制代码

1. package com.leixi.hub.saasdb.config;
3. import java.lang.annotation.*;
6. /**
7. * 自定义多数据源切换注解
8. * <p>
9. * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
10. * @author 雷袭月启
11. * @since 2024/12/5 19:39
12. */
14. @Inherited
15. @Documented
16. @Retention(RetentionPolicy.RUNTIME)
17. @Target({ElementType.METHOD, ElementType.TYPE})
18. public @interface DataSource {
19.     /**
20.      * 切换数据源名称（默认是主数据源test01）
21.      */
22.     public DataSourceType value() default DataSourceType.MASTER;
23. }

复制代码

1. package com.leixi.hub.saasdb.config;
3. import io.micrometer.common.util.StringUtils;
4. import org.aspectj.lang.ProceedingJoinPoint;
5. import org.aspectj.lang.annotation.Around;
6. import org.aspectj.lang.annotation.Aspect;
7. import org.aspectj.lang.annotation.Pointcut;
8. import org.springframework.core.annotation.AnnotationUtils;
9. import org.springframework.core.annotation.Order;
10. import org.springframework.stereotype.Component;
11. import org.aspectj.lang.reflect.MethodSignature;
12. import java.util.Objects;
15. /**
16. * 多数据源切换
17. * @author 雷袭月启
18. * @since 2024/12/5 19:39
19. */
20. @Aspect
21. @Order(1)
22. @Component
23. public class DataSourceAspect {
24.     // 配置织入点，为DataSource 注解
25.     @Pointcut("@annotation(com.leixi.hub.saasdb.config.DataSource)"
26.             + "|| @within(com.leixi.hub.saasdb.config.DataSource)")
27.     public void dsPointCut() {
28.     }
30.     /**
31.      * * 环绕通知
32.      *
33.      * @param point 切入点
34.      * @return Object
35.      * @throws Throwable 异常
36.      */
37.     @Around("dsPointCut()")
38.     public Object around(ProceedingJoinPoint point) throws Throwable {
39.         DataSource dataSource = getDataSource(point);
40.         if (Objects.nonNull(dataSource) && StringUtils.isNotEmpty(dataSource.value().name())) {
41.             // 将用户自定义配置的数据源添加到线程局部变量中
42.             DynamicDataSourceContextHolder.setDataSource(dataSource.value().name());
43.         }
44.         try {
45.             return point.proceed();
46.         } finally {
47.             // 在执行完方法之后，销毁数据源
48.             DynamicDataSourceContextHolder.removeDataSource();
49.         }
50.     }
52.     /**
53.      * 获取需要切换的数据源
54.      * 注意：顺序为：方法>类，方法上加了注解后类上的将不会生效
55.      * 注意：当类上配置后，方法上没有该注解，那么当前类中的所有方法都将使用类上配置的数据源
56.      */
57.     public DataSource getDataSource(ProceedingJoinPoint point) {
58.         MethodSignature signature = (MethodSignature) point.getSignature();
59.         // 从方法上获取注解
60.         DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
61.         // 方法上不存在时，再从类上匹配
62.         return Objects.nonNull(dataSource) ? dataSource : AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
63.     }
64. }

复制代码

        接下来是测试的一些实体类，Controller方法：

1. package com.leixi.hub.saasdb.entity;
3. import com.baomidou.mybatisplus.annotation.TableField;
4. import com.baomidou.mybatisplus.annotation.TableName;
5. import lombok.Data;
6. import lombok.EqualsAndHashCode;
7. import lombok.NoArgsConstructor;
8. import lombok.ToString;
9. import lombok.experimental.Accessors;
11. import java.io.Serial;
12. import java.io.Serializable;
14. /**
15. *
16. * @author 雷袭月启
17. * @since 2024/12/5 19:39
18. */
19. @Data
20. @ToString
21. @EqualsAndHashCode
22. @NoArgsConstructor
23. @Accessors(chain = true)
24. @TableName(value = "sys_db_info")
25. public class SysDbInfo implements Serializable {
26.     @Serial
27.     @TableField(exist = false)
28.     private static final long serialVersionUID = 8115921127536664152L;
29.     /**
30.      * 数据库地址
31.      */
32.     private String url;
33.     /**
34.      * 数据库用户名
35.      */
36.     private String username;
37.     /**
38.      * 密码
39.      */
40.     private String password;
41.     /**
42.      * 数据库驱动
43.      */
44.     private String driverClassName;
45.     /**
46.      * 数据库key，即保存Map中的key(保证唯一)
47.      * 定义一个key用于作为DynamicDataSource中Map中的key。
48.      * 这里的key需要和DataSourceType中的枚举项保持一致
49.      */
50.     private String dbKey;
51.     /**
52.      * 数据库名称
53.      */
54.     private String dbName;
55.     /**
56.      * 是否停用：0-正常，1-停用
57.      */
58.     private Integer status;
59.     /**
60.      * 备注
61.      */
62.     private String remark;
63. }

复制代码

1. package com.leixi.hub.saasdb.dao;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.leixi.hub.saasdb.entity.SysDbInfo;
5. import org.apache.ibatis.annotations.Mapper;
7. @Mapper
8. public interface SysDbInfoMapper extends BaseMapper<SysDbInfo> {}

复制代码

1. package com.leixi.hub.saasdb.dao;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import org.apache.ibatis.annotations.Mapper;
5. import org.apache.ibatis.annotations.Param;
7. import java.util.List;
8. import java.util.Map;
10. /**
11. *
12. * @author 雷袭月启
13. * @since 2024/12/5 19:39
14. */
15. @Mapper
16. public interface CommonMapper extends BaseMapper {
18.     List<Map<String, Object>> getDataBySql(@Param("sql") String sql);
20.     void updateDataBySql(@Param("sql") String sql);
22. }

复制代码

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3. <mapper namespace="com.leixi.hub.saasdb.dao.CommonMapper">
5.     <select id="getDataBySql" resultType="java.util.Map">
6.         ${sql}
7.     </select>
9.     <update id="updateDataBySql">
10.         ${sql}
11.     </update>
12. </mapper>

复制代码

1. package com.leixi.hub.saasdb.controller;
3. import com.leixi.hub.saasdb.config.DataSource;
4. import com.leixi.hub.saasdb.config.DataSourceType;
5. import com.leixi.hub.saasdb.dao.CommonMapper;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.web.bind.annotation.GetMapping;
8. import org.springframework.web.bind.annotation.RequestParam;
9. import org.springframework.web.bind.annotation.RestController;
11. /**
12. *
13. * @author 雷袭月启
14. * @since 2024/12/5 19:39
15. */
16. @RestController
17. public class DemoController {
19.     @GetMapping("/demo")
20.     public Object demo() {
21.         return "Hello World";
22.     }
24.     @Autowired
25.     private CommonMapper commonMapper;
28.     @GetMapping("/getDataBySqlFromMaster")
29.     @DataSource(DataSourceType.MASTER)
30.     public Object getDataBySqlFromMaster(@RequestParam(value = "sql") String sql) {
31.         return commonMapper.getDataBySql(sql);
32.     }
34.     @GetMapping("/getDataBySqlFromUat")
35.     @DataSource(DataSourceType.UAT)
36.     public Object getDataBySqlFromSlave(@RequestParam(value = "sql") String sql) {
37.         return commonMapper.getDataBySql(sql);
38.     }
40.     @GetMapping("/getDataBySql")
41.     public Object getDataBySql(@RequestParam(value = "sql") String sql) {
42.         return commonMapper.getDataBySql(sql);
43.     }
46. }

复制代码

        3、启动项目，通过Postman测试，效果和预期同等：

        
      

       二、通过Filter实现

        上述的方法固然有用，但多少有些固化了，为何？一：只有添加了注解的类或方法才气动态切换数据源，需要对已有代码举行修改，那就多少会有漏改，少改的位置，二来，可选的数据源在摆列或代码中写死了，假设在数据库里新增了一个数据源，则步伐中必须要做相应的调解，可扩展性不高，综合思量后，我决定再用过滤器的方式试试。
        过滤器的原理其实和AOP相似，只是在Header中添加一个数据库的Key，在过滤器中根据这个Key来指定数据源，实现代码如下：

1. package com.leixi.hub.saasdb.filter;
3. import com.leixi.hub.saasdb.config.DynamicDataSourceContextHolder;
4. import io.micrometer.common.util.StringUtils;
5. import jakarta.servlet.Filter;
6. import jakarta.servlet.FilterChain;
7. import jakarta.servlet.ServletException;
8. import jakarta.servlet.ServletRequest;
9. import jakarta.servlet.ServletResponse;
10. import jakarta.servlet.http.HttpServletRequest;
11. import org.springframework.core.annotation.Order;
13. import java.io.IOException;
15. /**
16. *
17. * @author 雷袭月启
18. * @since 2024/12/5 19:39
19. */
20. @Order(1)
21. public class DataSourceChangeFilter implements Filter {
23.     private String dataSourceKey;
25.     public DataSourceChangeFilter(String dataSourceKey) {
26.         this.dataSourceKey = dataSourceKey;
27.     }
30.     @Override
31.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
32.         HttpServletRequest httpRequest = (HttpServletRequest) request;
33.         String dataSource = httpRequest.getHeader(dataSourceKey);
34.         if (StringUtils.isNotEmpty(dataSource)) {
35.             DynamicDataSourceContextHolder.setDataSource(dataSource);
36.             chain.doFilter(request, response);
37.             destroy();
38.         } else {
39.             chain.doFilter(request, response);
40.         }
41.     }
43.     @Override
44.     public void destroy() {
45.         DynamicDataSourceContextHolder.removeDataSource();
46.     }
48. }

复制代码

1. package com.leixi.hub.saasdb.filter;
2. import org.springframework.beans.factory.annotation.Value;
3. import org.springframework.boot.web.servlet.FilterRegistrationBean;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
7. /**
8. *
9. * @author 雷袭月启
10. * @since 2024/12/5 19:39
11. */
12. @Configuration
13. public class FilterConfig {
15.     @Value("${leixi.saas.data_source_key:data_source_key}")
16.     private String dataSourceKey;
18.     @Bean
19.     public FilterRegistrationBean<DataSourceChangeFilter> licenseValidationFilterRegistration() {
20.         FilterRegistrationBean<DataSourceChangeFilter> registration = new FilterRegistrationBean<>();
21.         registration.setFilter(new DataSourceChangeFilter(dataSourceKey));
22.         registration.addUrlPatterns("/*"); // 应用于所有URL /* 应用于登陆 /login
23.         return registration;
24.     }
25. }

复制代码

        测试过程如下：

        而不传Header时，默认查询的是Master库：

      三、推广使用

        当前这个项目是已经实现了多数据源的动态切换，那么假如想让其他项目也支持，应该怎么办呢？咱可以把这个项目打成一个jar包，然后让其他项目引入依靠即可，改动如下：
        1、删除Application.java文件。
        2、在pom中用以下打包语法举行打包。

1.     <!--可以打成供其他包依赖的包-->
2.     <build>
3.         <plugins>
4.             <plugin>
5.                 <groupId>org.apache.maven.plugins</groupId>
6.                 <artifactId>maven-archetype-plugin</artifactId>
7.                 <version>3.0.0</version>
8.             </plugin>
10.             <plugin>
11.                 <groupId>org.apache.maven.plugins</groupId>
12.                 <artifactId>maven-compiler-plugin</artifactId>
13.                 <version>3.11.0</version>
14.                 <configuration>
15.                     <source>17</source>
16.                     <target>17</target>
17.                     <encoding>UTF-8</encoding>
18.                 </configuration>
19.             </plugin>
20.         </plugins>
21.         <resources>
22.             <resource>
23.                 <directory>src/main/resources/config</directory>
24.                 <filtering>true</filtering>
25.                 <excludes>
26.                     <exclude>*</exclude>
27.                 </excludes>
28.             </resource>
29.         </resources>
30.     </build>

复制代码

        3、打包完成后可以在target中看到对应的jar文件，也可以在其他项目中引用该文件，如下：

      跋文与致谢

        以上就是我今天的全部门享了， Demo比较简单，手法也相对稚嫩，希望不会贻笑大方，也希望新手看到这个Demo能有所启发。这次实践也并非一蹴而就的，离不开大佬们的支持和点拨，雷袭在网上找了许多资料，以下这篇博客是最有代价的，可以说雷袭完全是照抄了他的成果，这里附上原文链接，拜谢大佬！
        SpringBoot3多数据源动态切换-陌路



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。