SpringBoot3多数据源动态切换

已于 2024-01-04 18:31:11 修改
阅读量1.1k 收藏 19
点赞数 17
分类专栏： Java SpringBoot3.x MyBatisPlus 文章标签： java spring boot mybatis mysql spring maven
于 2024-01-04 18:30:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51076413/article/details/135385130
版权

demo使用的时SpringBoot3.x、JDK17、MybatisPlus3.5.x、MySQL8

从数据中加载数据源
在这里插入图片描述
定义接口，指定数据源，从不同数据库获取数据
在这里插入图片描述
创建数据源表，用于指定不同数据源，程序自动动态获取
在这里插入图片描述

项目版本依赖关系

demo中所用到的工具以及版本号如下：

pom文件

<?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>cn.molu</groupId>
    <artifactId>mgzyf-api</artifactId>
    <version>2.4.1</version>
    <description>基于 Java 17 + SpringBoot 3 。</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.5</version> <!-- lookup parent from repository -->
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <hutool.version>5.8.15</hutool.version>
        <mysql.version>8.0.28</mysql.version>
        <druid.version>1.2.16</druid.version>
        <mybatis-plus.version>3.5.3.1</mybatis-plus.version>
        <lombok-mapstruct-binding.version>0.2.0</lombok-mapstruct-binding.version>
    </properties>

    <dependencies>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <!--编译测试环境，不打包在lib-->
            <scope>provided</scope>
        </dependency>
        <!-- 允许使用Lombok的Java Bean类中使用MapStruct注解 (Lombok 1.18.20+) -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok-mapstruct-binding</artifactId>
            <version>${lombok-mapstruct-binding.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--    hutool工具包    -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>

		<!-- web支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

		<!-- aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

		<!-- 连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

		<!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!--    阿里druid工具包    -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.40</version>
        </dependency>

		<!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

		<!-- 自定义配置类支持 -->
        <dependency>
        	<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-configuration-processor</artifactId>
        	<optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

一、配置文件配置类型

1.1、配置文件配置

配置两个数据源：tets01 数据库和 test02 数据库
默认使用 master 主数据源，切换时只需要配置 @DataSource 注解来切换即可

application.yml

server:
  port: 8989

spring:
  jackson:
    ## 默认序列化时间格式
    date-format: yyyy-MM-dd HH:mm:ss
    ## 默认序列化时区
    time-zone: GMT+8
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      # 主数据源（test01数据库）
      master:
        url: jdbc:mysql://127.0.0.1:3306/test01?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true
        username: xxx
        password: 123
        driver-class-name: com.mysql.cj.jdbc.Driver
      # 从数据源（test02数据库）
      slave:
        # 是否开启从库（多数据源情况下，请打开）
        enable: true
        # 如果时SQL server、Oracle等数据库，这里需要改成对应的驱动配置
        url: jdbc:mysql://127.0.0.1:3306/test02?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true
        username: xxx
        password: 123
        driver-class-name: com.mysql.cj.jdbc.Driver
      initial-size: 15
      min-idle: 15
      max-active: 200
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: ""
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: false
      connection-properties: false

1.2、数据源配置类

读取 application 配置文件中的数据源信息，并由Spring统一管理，以便后续使用

DataSourceConfig

import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;

/**
 * @author 陌路
 * @apiNote 设置数据源
 * @date 2023/12/31 10:16
 * @tool Created by IntelliJ IDEA
 */
@Configuration
public class DataSourceConfig {
    /*
        通过配置类，将配置文件中配置的数据库信息转换成datasource，
        并添加到DynamicDataSource中，同时通过@Bean将DynamicDataSource注入Spring中进行管理，
        后期在进行动态数据源添加时，会用到。
     */

    /**
     * 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
     *
     * @return DataSource
     * @description 该数据源是在application配置文件master中所配置的
     */
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置从数据源，可以配置多个（目前只配置了一个test02）
     *
     * @return DataSource
     * @description 该数据源是在application配置文件slave中所配置的
     */
    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置动态数据源的核心配置项
     *
     * @return DynamicDataSource
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource createDynamicDataSource() {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        // 默认的数据源（主数据源）
        DataSource defaultDataSource = masterDataSource();
        // 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
        dataSourceMap.put(DataSourceType.MASTER.name(), defaultDataSource);
        // 配置从数据源，可以配置多个（目前只配置了一个test02）
        dataSourceMap.put(DataSourceType.SLAVE.name(), slaveDataSource());
        // 配置动态数据源，默认使用主数据源，如果有从数据源配，则使用从数据库中读取源，并加载到dataSourceMap中
        return new DynamicDataSource(defaultDataSource, dataSourceMap);
    }
}

1.3、配置数据源枚举类

该枚举类主要用于数据源的指定，使用 MASTER 库还是使用 SLAVE 库，
如果有多个数据源，可以在这里继续指定即可

DataSourceType

/**
 * @author 陌路
 * @apiNote 动态数据源类型
 * @date 2023/12/31 10:23
 * @tool Created by IntelliJ IDEA
 */
public enum DataSourceType {
    // 注意：枚举项要和 DataSourceConfig 中的 createDynamicDataSource()方法dataSourceMap的key保持一致
     
    /**
     * 主库
     */
    MASTER,
    /**
     * 从库
     */
    SLAVE,
}

1.4、线程局部变量

线程局部变量，不同于普通变量，每个线程都有自己的副本，互不影响。
多线程情况下也能保证数据源能够有序的切换，而不会造成数据的混乱

DynamicDataSourceContextHolder

import lombok.extern.slf4j.Slf4j;

/**
 * @author 陌路
 * @apiNote 线程局部变量，不同于普通变量，每个线程都有自己的副本，互不影响。
 * @date 2023/12/31 10:05
 * @tool Created by IntelliJ IDEA
 * @description 创建一个类用于实现ThreadLocal，主要是通过get，set，remove方法来获取、设置、删除当前线程对应的数据源。
 */
@Slf4j
public class DynamicDataSourceContextHolder {
    //此类提供线程局部变量。这些变量不同于它们的正常对应关系是每个线程访问一个线程(通过get、set方法),有自己的独立初始化变量的副本。
    private static final ThreadLocal<String> DATASOURCE_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源
     *
     * @param dataSourceName 数据源名称
     */
    public static void setDataSource(String dataSourceName) {
        log.info("切换数据源到：{}", dataSourceName);
        DATASOURCE_HOLDER.set(dataSourceName);
    }

    /**
     * 获取当前线程的数据源
     *
     * @return 数据源名称
     */
    public static String getDataSource() {
        return DATASOURCE_HOLDER.get();
    }

    /**
     * 删除当前数据源
     */
    public static void removeDataSource() {
        log.info("删除当前数据源：{}", getDataSource());
        DATASOURCE_HOLDER.remove();
    }
}

1.5、添加切换的数据源（核心）

定义一个动态数据源类实现AbstractRoutingDataSource，通过determineCurrentLookupKey方法与上述实现的ThreadLocal类中的get方法进行关联，实现动态切换数据源。

切换数据源后，具体查询哪个数据库，由此类决定

DynamicDataSource

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * @author 陌路
 * @apiNote 实现动态数据源，根据AbstractRoutingDataSource路由到不同数据源中
 * @date 2023/12/31 10:08
 * @tool Created by IntelliJ IDEA
 * @description 定义一个动态数据源类实现AbstractRoutingDataSource，通过determineCurrentLookupKey方法与上述实现的ThreadLocal类中的get方法进行关联，实现动态切换数据源。
 */
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {
    /*
        代码中，还实现了一个动态数据源类的构造方法，主要是为了设置默认数据源，以及以Map保存的各种目标数据源。
        其中Map的key是设置的数据源名称，value则是对应的数据源（DataSource）
    */

    // 数据源列表，多数据源情况下，具体使用哪一个数据源，由此获取
    private final Map<Object, Object> targetDataSourceMap;

    /**
     * 构造方法，设置默认数据源和目标多数据源
     *
     * @param defaultDataSource 默认主数据源，只能有一个
     * @param targetDataSources 从数据源，可以是多个
     */
    public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultDataSource);
        super.setTargetDataSources(targetDataSources);
        this.targetDataSourceMap = targetDataSources;
        // 配置完成后，更新数据源配置列表，将TargetDataSources中的连接信息放入resolvedDataSources管理
        super.afterPropertiesSet();
    }

    /**
     * 动态数据源的切换（核心）
     * 决定使用哪个数据源
     *
     * @return Object
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSource();
    }

    /**
     * 校验数据源是否存在
     *
     * @param key 数据源保存的key
     * @return 返回结果，true：存在，false：不存在
     */
    public boolean existsDataSource(String key) {
        return Objects.nonNull(this.targetDataSourceMap) && Objects.nonNull(this.targetDataSourceMap.get(key));
    }
}

1.6、数据源注解类

此注解可以配置在类上，也可以配置在方法上
优先级：方法 > 类
当方法上加了此注解时，类上配置的注解将会失效
当类中所有方法都没有此注解，而类上存在时，那么该类中所有方法都将使用该类上的数据源
方法和类上都不添加该注解时，默认使用 master 数据源

DataSource

import java.lang.annotation.*;

/**
 * 自定义多数据源切换注解
 * <p>
 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
 */
@Inherited
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface DataSource {
    /**
     * 切换数据源名称（默认是主数据源test01）
     */
    public DataSourceType value() default DataSourceType.MASTER;
}

1.7、动态数据源切面（核心）

是否需要切换数据源，或者具体使用哪个数据源，由此类通过解析 DataSource 注解来决定
不添加或者解析不到该注解时，则使用默认的数据源（master）

DataSourceAspect

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.aspectj.lang.reflect.MethodSignature;
import java.util.Objects;

/**
 * @author 陌路
 * @apiNote 多数据源切换
 * @date 2023/12/31 13:06
 * @tool Created by IntelliJ IDEA
 */
@Aspect
@Order(1)
@Component
public class DataSourceAspect {
	// 配置织入点，为DataSource 注解
    @Pointcut("@annotation(cn.molu.system.common.datasource.DataSource)"
            + "|| @within(cn.molu.system.common.datasource.DataSource)")
    public void dsPointCut() {
    }

    /**
     * * 环绕通知
     *
     * @param point 切入点
     * @return Object
     * @throws Throwable 异常
     */
    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource dataSource = getDataSource(point);
        if (Objects.nonNull(dataSource) && StringUtils.isNotEmpty(dataSource.value().name())) {
        	// 将用户自定义配置的数据源添加到线程局部变量中
            DynamicDataSourceContextHolder.setDataSource(dataSource.value().name());
        }
        try {
            return point.proceed();
        } finally {
            // 在执行完方法之后，销毁数据源 
            DynamicDataSourceContextHolder.removeDataSource();
        }
    }

    /**
     * 获取需要切换的数据源
     * 注意：顺序为：方法>类，方法上加了注解后类上的将不会生效
     * 注意：当类上配置后，方法上没有该注解，那么当前类中的所有方法都将使用类上配置的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        // 从方法上获取注解
        DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
        // 方法上不存在时，再从类上匹配
        return Objects.nonNull(dataSource) ? dataSource : AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

1.8、启动类修改

上述中，我们自定义了数据源的配置，这里据需要将 DataSourceAutoConfiguration 自动配置的数据源排除，否则项目启动时可能会出现异常，导致项目无法正常运行

SystemApplication

// 排除数据源自动配置，使用自定义数据源，否则会出现循环依赖报错
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SystemApplication {
    public static void main(String[] args) {
        SpringApplication.run(SystemApplication.class, args);
        log.info("项目启动成功：http://127.0.0.1:8989");
    }
}

到此，配置类型的多数据源的切换就完成了

不足和缺陷：

  • 每次添加数据源时都需要在 application 配置文件中添加
  • 线上环境时，每次都需要替换新的 application 文件
  • 当数据库密码修改或者切换服务器时，维护成本高，不够便利

以上不足和缺陷，将在以下内容中逐一解决

二、数据库动态获取类型

数据源信息配置在数据库中，便于维护

在以上代码的基础上，进行修改，所新增的代码以及变更的代码将会给出具体的说明

在以上代码的基础上新增：SysDbInfo、LoadDataSourceRunner【2个新增】
修改变更的类：DataSourceConfig、DynamicDataSource【2个改动】
以下类不做任何改动：DynamicDataSourceContextHolder、DataSourceType、DataSourceAspect、DataSource、SystemApplication【5个未作改动】

修改配置文件

改动内容：仅去除了从数据库的配置信息（不再需要在配置文件中配置从库数据）

server:
  port: 8989

spring:
  jackson:
    ## 默认序列化时间格式
    date-format: yyyy-MM-dd HH:mm:ss
    ## 默认序列化时区
    time-zone: GMT+8
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      master:
        url: jdbc:mysql://127.0.0.1:3306/test01?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true
        username: xxx
        password: 123
        driver-class-name: com.mysql.cj.jdbc.Driver
      slave:
        # 是否开启从库（多数据源情况下，请打开，并且将配置信息配置到sys_db_info表中，项目启动时会自动加载）
        enable: true
      initial-size: 15
      min-idle: 15
      max-active: 200
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: ""
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: false
      connection-properties: false

2.1、数据源实体类

SysDbInfo

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;
import java.io.Serial;
import java.io.Serializable;

/**
 * @author 陌路
 * @apiNote 数据源实体类
 * @date 2023/12/31 10:29
 * @tool Created by IntelliJ IDEA
 */
@Data
@ToString
@EqualsAndHashCode
@NoArgsConstructor
@Accessors(chain = true)
@TableName(value = "sys_db_info")
public class SysDbInfo implements Serializable {
    @Serial
    @TableField(exist = false)
    private static final long serialVersionUID = 8115921127536664152L;
/*
-- 建表语句
CREATE TABLE `sys_db_info` (
  `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT '主键Id',
  `url` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库URL',
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '用户名',
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '密码',
  `driver_class_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库驱动',
  `db_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库名称',
  `db_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库key，即保存Map中的key(保证唯一，并且和DataSourceType中的枚举项保持一致，包括大小写)',
  `status` int NOT NULL DEFAULT '0' COMMENT '是否停用：0-正常，1-停用',
  `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '备注说明',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `UNI_DB_INFO_DBKEY` (`db_key`) USING BTREE COMMENT '数据库的key必须唯一，并且要和DataSourceType中的枚举项保持一致'
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin ROW_FORMAT=DYNAMIC;

 */
    /**
     * 数据库地址
     */
    private String url;
    /**
     * 数据库用户名
     */
    private String username;
    /**
     * 密码
     */
    private String password;
    /**
     * 数据库驱动
     */
    private String driverClassName;
    /**
     * 数据库key，即保存Map中的key(保证唯一)
     * 定义一个key用于作为DynamicDataSource中Map中的key。
     * 这里的key需要和DataSourceType中的枚举项保持一致
     */
    private String dbKey;
    /**
     * 数据库名称
     */
    private String dbName;
    /**
     * 是否停用：0-正常，1-停用
     */
    private Integer status;
    /**
     * 备注
     */
    private String remark;
}

以下是实体类所对应的SQL语句：

CREATE TABLE `sys_db_info` (
  `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT '主键Id',
  `url` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库URL',
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '用户名',
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '密码',
  `driver_class_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库驱动',
  `db_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库名称',
  `db_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '数据库key，即保存Map中的key(保证唯一，并且和DataSourceType中的枚举项保持一致，包括大小写)',
  `status` int NOT NULL DEFAULT '0' COMMENT '是否停用：0-正常，1-停用',
  `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '备注说明',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `UNI_DB_INFO_DBKEY` (`db_key`) USING BTREE COMMENT '数据库的key必须唯一，并且要和DataSourceType中的枚举项保持一致'
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin ROW_FORMAT=DYNAMIC;


-- 添加数据库配置信息（此处按照自己的需求配置对应的数据库即可）
INSERT INTO `sys_db_info` (`id`, `url`, `username`, `password`, `driver_class_name`, `db_name`, `db_key`, `status`, `remark`) VALUES (1, 'jdbc:mysql://127.0.0.1:3306/test02?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true', 'xxx', '123', 'com.mysql.cj.jdbc.Driver', 'test02', 'SLAVE', 0, '连接test02数据库');
INSERT INTO `sys_db_info` (`id`, `url`, `username`, `password`, `driver_class_name`, `db_name`, `db_key`, `status`, `remark`) VALUES (2, 'jdbc:mysql://127.0.0.1:3306/test03?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true', 'xxx', '123', 'com.mysql.cj.jdbc.Driver', 'test03', 'SLAVE2', 1, '链接test03数据库');

2.2、初始化加载数据源

项目启动时，执行此代码，访问数据库加载数据库中配置的数据源信息

LoadDataSourceRunner

import cn.hutool.core.util.StrUtil;
import cn.molu.system.mapper.SysDbInfoMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 陌路
 * @apiNote 查询数据源
 * @date 2023/12/31 10:41
 * @tool Created by IntelliJ IDEA
 * CommandLineRunner 项目启动时执行
 */
@Slf4j
@Component
public class LoadDataSourceRunner implements CommandLineRunner {
    /**
     * 是否启用从库多数据源配置
     */
    @Value("${spring.datasource.druid.slave.enable}")
    private boolean enabled;
    @Resource
    private DynamicDataSource dynamicDataSource;
    @Resource
    private SysDbInfoMapper dbInfoMapper;

    /**
     * 项目启动时加载数据源
     */
    @Override
    public void run(String... args) {
        if (enabled) return;
        refreshDataSource();
    }

    /**
     * 刷新数据源
     */
    public void refreshDataSource() {
        List<SysDbInfo> dbInfos = dbInfoMapper.selectList(new LambdaQueryWrapper<SysDbInfo>().eq(SysDbInfo::getStatus, 0));
        if (CollectionUtils.isEmpty(dbInfos)) return;
        List<SysDbInfo> ds = new ArrayList<>();
        log.info("====开始加载数据源====");
        for (SysDbInfo info : dbInfos) {
            if (StrUtil.isAllNotBlank(
                    info.getUrl(), // 数据库连接地址
                    info.getDriverClassName(), // 数据库驱动
                    info.getUsername(), // 数据库用户名
                    info.getPassword(), // 数据库密码
                    info.getDbKey() // 数据源key
            )) {
                ds.add(info);
                log.info("加载到数据源 ---> dbName：{}、dbKey：{}、remark：{}", info.getDbName(), info.getDbKey(), info.getRemark());
            }
        }
        dynamicDataSource.createDataSource(ds);
        log.info("====数据源加载完成====");
    }
}

2.3、数据源配置类（改动）

该配置类稍作改动，去除了从配置文件中加载从数据源（slave），只加载主数据源（master）

DataSourceConfig

import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;

/**
 * @author 陌路
 * @apiNote 设置数据源
 * @date 2023/12/31 10:16
 * @tool Created by IntelliJ IDEA
 */
@Configuration
public class DataSourceConfig {
    /*
        通过配置类，将配置文件中的配置的数据库信息转换成datasource，
        并添加到DynamicDataSource中，同时通过@Bean将DynamicDataSource注入Spring中进行管理，
        后期在进行动态数据源添加时，会用到。
     */

    /**
     * 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
     *
     * @return DataSource
     * @description 该数据源是在application配置文件master中所配置的
     */
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置从数据源，可以配置多个
     * <p>现在已经改为数据库配置，如果有多个数据源，请在sys_db_info表中添加即可，
     * 不需要在application中配置（此方法已注释，配置也不会生效）<p/>
     *
     * @return DataSource
     * @description 该数据源是在application配置文件slave中所配置的
     */
//    @Bean
//    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置动态数据源的核心配置项
     *
     * @return DynamicDataSource
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource createDynamicDataSource() {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        // 默认数据源
        DataSource defaultDataSource = masterDataSource();
        // 配置主数据源，默认使用该数据源，并且主数据源只能配置一个
        dataSourceMap.put(DataSourceType.MASTER.name(), defaultDataSource);
        // 配置从数据源，可以配置多个，目前已注释，不需要application中配置，如果有多个数据源，请在sys_db_info表中添加即可
//        dataSourceMap.put(DataSourceType.SLAVE.name(), slaveDataSource());
        // 配置动态数据源，默认使用主数据源，如果有从数据源配，则使用从数据库中读取源，并加载到dataSourceMap中
        return new DynamicDataSource(defaultDataSource, dataSourceMap);
    }
}

2.4、添加读取到的数据源

改动添加切换的数据源类，将数据库中读取出来的数据源列表逐一添加，以便后续使用

DynamicDataSource

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * @author 陌路
 * @apiNote 实现动态数据源，根据AbstractRoutingDataSource路由到不同数据源中
 * @date 2023/12/31 10:08
 * @tool Created by IntelliJ IDEA
 * @description 定义一个动态数据源类实现AbstractRoutingDataSource，通过determineCurrentLookupKey方法与上述实现的ThreadLocal类中的get方法进行关联，实现动态切换数据源。
 */
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {
    /*
        代码中，还实现了一个动态数据源类的构造方法，主要是为了设置默认数据源，以及以Map保存的各种目标数据源。
        其中Map的key是设置的数据源名称，value则是对应的数据源（DataSource）
    */

    // 数据源列表，多数据源情况下，具体使用哪一个数据源，由此获取
    private final Map<Object, Object> targetDataSourceMap;

    /**
     * 构造方法，设置默认数据源和目标多数据源
     *
     * @param defaultDataSource 默认主数据源，只能有一个
     * @param targetDataSources 从数据源，可以是多个
     */
    public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultDataSource);
        super.setTargetDataSources(targetDataSources);
        this.targetDataSourceMap = targetDataSources;
        // 配置完成后，更新数据源配置列表，将TargetDataSources中的连接信息放入resolvedDataSources管理
//        super.afterPropertiesSet();
    }

    /**
     * 动态数据源的切换（核心）
     * 决定使用哪个数据源
     *
     * @return Object
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSource();
    }

    /**
     * 添加数据源信息
     *
     * @param dataSources 数据源实体集合
     */
    public void createDataSource(List<SysDbInfo> dataSources) {
        try {
            if (CollectionUtils.isNotEmpty(dataSources)) {
                for (SysDbInfo ds : dataSources) {
                    //校验数据库是否可以连接
                    Class.forName(ds.getDriverClassName());
                    DriverManager.getConnection(ds.getUrl(), ds.getUsername(), ds.getPassword());
                    //定义数据源
                    DruidDataSource dataSource = new DruidDataSource();
                    BeanUtils.copyProperties(ds, dataSource);
                    //申请连接时执行validationQuery检测连接是否有效，这里建议配置为TRUE，防止取到的连接不可用
                    dataSource.setTestOnBorrow(true);
                    //建议配置为true，不影响性能，并且保证安全性。
                    //申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
                    dataSource.setTestWhileIdle(true);
                    //用来检测连接是否有效的sql，要求是一个查询语句。
                    dataSource.setValidationQuery("select 1 ");
                    dataSource.init();
                    // 将数据源放入Map中，key为数据源名称，要和DataSourceType中的枚举项对应，包括大小写，并且保证唯一
                    this.targetDataSourceMap.put(ds.getDbKey(), dataSource);
                }
                // 更新数据源配置列表，这里主要是从数据源
                super.setTargetDataSources(this.targetDataSourceMap);
                // 将TargetDataSources中的连接信息放入resolvedDataSources管理
                super.afterPropertiesSet();
            }
        } catch (ClassNotFoundException | SQLException e) {
            log.error("---解析数据源出错---：{}", e.getMessage());
        }
    }

    /**
     * 校验数据源是否存在
     *
     * @param key 数据源保存的key
     * @return 返回结果，true：存在，false：不存在
     */
    public boolean existsDataSource(String key) {
        return Objects.nonNull(this.targetDataSourceMap) && Objects.nonNull(this.targetDataSourceMap.get(key));
    }
}

2.5、SysDbInfo相关

用于向数据库查询数据

import cn.molu.system.common.datasource.SysDbInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface SysDbInfoMapper extends BaseMapper<SysDbInfo> {}

到此，动态数据源相关就完成了，可以启动项目试一下

注意说明：

1、master主数据库一定要有，并且可以连接，否则项目无法启动
2、slave从数据库可以有也可以没有，也可以时很多个，
3、slave从数据库可以是其他数据库：Oracle、SQL serve等，对应修改配置即可
4、DataSourceType枚举中的枚举项一定要和数据库中配置的dbkey保持一致
5、使用的时候之间使用DataSource注解指定数据源即可

2.6、使用用例

动态数据源的使用

/**
 * 用户控制器
 *
 * @author 陌路
 * @since 2023/12/31
 */
@RestController
@RequiredArgsConstructor
 // 此注解用于指定具体使用哪个数据源
@DataSource(DataSourceType.SLAVE)
@RequestMapping("/api/v1/users")
public class SysUserController {

    private final SysUserService userService;

    /**
     * 用户分页列表
     * @param queryParams 查询参数
     * @return 用户分页列表
     */
    @GetMapping("/page") // 使用类上的数据源SLAVE
    public PageResult<UserPageVO> getUserPage(UserPageQuery queryParams) {
        IPage<UserPageVO> result = userService.getUserPage(queryParams);
        return PageResult.success(result);
    }
    /**
     * 删除用户
     *
     * @param ids 用户ID，多个以英文逗号(,)分割
     * @return 删除结果
     */
    @DeleteMapping("/{ids}")
    @DataSource(DataSourceType.MASTER) // 在方法上，则类上的配置失效
    public Result<Boolean> deleteUsers(@PathVariable String ids) {
        boolean result = userService.deleteUsers(ids);
        return Result.judge(result);
    }
 }

不切换数据源，使用默认
不加@DataSource注解，使用默认数据源

```java
/**
 * 用户控制器
 *
 * @author 陌路
 * @since 2023/12/31
 */
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/users")
public class SysUserController {

    private final SysUserService userService;

    /**
     * 用户分页列表
     * @param queryParams 查询参数
     * @return 用户分页列表
     */
    @GetMapping("/page")
    public PageResult<UserPageVO> getUserPage(UserPageQuery queryParams) {
        IPage<UserPageVO> result = userService.getUserPage(queryParams);
        return PageResult.success(result);
    }
    /**
     * 删除用户
     *
     * @param ids 用户ID，多个以英文逗号(,)分割
     * @return 删除结果
     */
    @DeleteMapping("/{ids}")
    public Result<Boolean> deleteUsers(@PathVariable String ids) {
        boolean result = userService.deleteUsers(ids);
        return Result.judge(result);
    }
 }

以上就是配置动态数据源的过程了，可以根据不同需求使用配置文件的形式，或者使用数据库配置的形式

我这里没有将测试过程以及结果贴出来，请自行测试使用。。。

.陌路
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot多数据源切换.zip
11-24
SpringBoot多数据源切换.zip
SpringBoot多数据源动态切换源码
07-07
SpringBoot的jpa多数据源的动态切换项目源代码，适用于不同的用户操作不同的数据库，但是其对应的repository是一样的，可以进行http请求的动态数据源切换
springboot3.2.3集成shardingsphere5.4.1及动态数据源
最新发布
robotABC的博客
04-15 396
说明1：上次记录了升级中踩坑的点，但是关于shardingsphere5.4.1版本适配的问题没有详细说明，此处提供demo项目（同时集成了集成了动态数据源）供后续参考（按照官方推荐的改动进行修改了，将会在官方的5.5.0版本包含改代码）。shardingsphere的个人不建议作为主数据源，主要原始是对sql的适配问题，即部分sql是不支持的。免费下载地址：https://download.csdn.net/download/robotABC/89125097。
SpringBoot Jpa 多数据源动态切换
天行健，君子以自强不息；地势坤，君子以厚德载物。
01-22 3286
在大型应用程序中，配置主从数据库并使用读写分离是常见的设计模式。常用的实现方式是使用数据库中间件，此文介绍如何通过编写代码的方式实现多数据源的配置和动态切换。核心是使用Spring 内置的...
SpringBoot动态切换数据源
逛窑子的李靖的博客
08-03 505
SpringBoot动态切换数据源，并且可以实现数据源的动态增删。
springboot，多数据源切换
zifengye520的专栏
07-23 1211
需求介绍：要求做一个平台，有其他第三方系统接入；每个系统有自己的数据源配置，通过调用平台接口，实现将数据保存到第三方自己的数据库中；实现过程：1.在平台项目运行时，通过接口获取每个第三方系统的数据源；以key-value的形式保存到全局变量中；2.在调用接口的时候，会通过拦截器获取到每个请求中的第三方系统标识；3.根据标识来切换对应的数据源。
项目要实现多数据源动态切换，咋搞？
ibigboy
10-19 984
文章首发于公众号：编程大道 在做项目的时候，几乎都会用到数据库，很多时候就只连一个数据库，但是有时候我们需要一个项目操作多个数据库，不同的业务功能产生的数据存到不同的数据库，那怎么来实现数据源的动态、灵活的切换呢？今天我们就来实现这个功能。 前期准备工作 我们需要有一台联网的电脑（用于maven自动下载依赖），并且电脑安装JDK 8、IDEA、MySQL数据库、maven，首先创建一个springboot项目（SSM也行）。springboot版本和SSM版本的代码都已经放到码云托管。感兴趣的可.
【数据库与事务系列】多数据源切换
qq_35789269的博客
12-03 3182
多数据源
Spring实现多数据源切换
SSL 的博客
03-26 1283
使用Druid+myBatis+Spring AOP实现多数据源切换。
多数据源切换(一)
weixin_49604576的博客
03-12 1057
自定义注解**@DS**实现动态数据源切换且支持单体事务，并集成为springboot的starter启动项
SpringBoot实现多数据源（一）【普通版切换】
Vinjcent
11-27 2728
在实际开发中，经常可能遇到在一个应用中可能需要访问多个数据库的情况。以下是两种典型场景数据分布在不同的数据库中，数据库拆了，应用没拆。一个公司多个子项目，各用各的数据库，设计数据共享…为解决 数据库的读性能瓶颈（读比写性能更高，写锁会影响读阻塞，从而影响读的性能）很多数据库拥有主从架构，也就是说，一台主数据库服务器，是对外提供增删改业务的生产服务；另一（多）台从数据库服务器，主要进行读的操作可以通过中间件（ShardingSphere、mycat、mysql-proxy、TDDL…），但是有一些规模较小的公
SpringBoot配置多数据源实现动态切换数据源
06-29
通过简单的demo实现SpingBoot多数据源配置并动态切换多数据源
SpringBoot Mybatis动态数据源切换方案实现过程
08-19
主要介绍了SpringBoot+Mybatis实现动态数据源切换方案过程,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Springboot集成多数据源实现动态切换数据源
qq_38885821的博客
10-10 548
在需要集成多数据源的业务场景下使用AbstractRoutingDataSource来动态切换数据库
JAVA项目实现多数据源动态切换
吴某某人的笔记
03-21 1478
3、创建切换数据源的AOP，我这边的规则是根据目录来切换，还有别的规则可以自行切换，主要是这个DynamicDataSourceContextHolder（dynamic-datasource-spring-boot-starter中自带类可直接使用），用来切换数据源。4、根据目录创建一个mysql连接、oracle连接，具体代码我就不贴了，主要是第3步骤的AOP起主要作用。1、先引入动态数据源涉及的包，我这边用的是gradle，maven也有相关对应的。6 、完事了~~~~~~
【Java】SpringBoot中实现多数据源切换
Syals的博客
04-28 4207
在SpringBoot中对数据源进行动态的切换
Spring Boot 如何动态切换多数据源
chenzoff的专栏
06-09 537
本篇文章讲了Spring Boot与单数据源、Mybatis、多数据源之间的整合，希望这篇文章能够帮助读者理解多数据源的整合，虽说用的不多，但是在有些领域仍然是比较重要的。
springBoot如何动态切换数据源
爪哇人的博客
01-18 1609
mybatisplus提供的有插件用@DS注解就能够实现，但是这种在mysql服务宕机的情况下不能够进行自动切换，于是就想着用aop+自定义注解的方式来实现。此时你在代码层面用注解指定了一个增删改方法到从数据源，但是碰巧此时从数据源失效了，那么就会自动的切换到其它服务器。DynamicDataSourceHolder类主要是设置当前线程的数据源名称，移除数据源名称，以及获取当前数据源的名称，便于动态切换。我在这个方法上指定的是从数据库，如果此时从数据库发生宕机，那么就会自动切换到主数据库进行操作。
手把手教你玩多数据源动态切换
江南一点雨的专栏
05-16 4152
为了提高应用的可靠性，多数据源现在也很常见，数据库可以搭建双 M 结构，这个松哥之前也发文和大家分享过如何搭建双 M 结构的主从备份？，那么 Java 代码里该如何操作多数据源呢？ 我在 19 年的时候写过几篇文章教大家配置 JdbcTemplate、MyBatis 以及 JPA 中的多数据源（公众号江南一点雨后台回复 666 有相关的资料），不过那几篇文章的整体思路都是弄多个 Dao 层实例，然后手动选择用哪个实例，这样总感觉不太方便。 MyBatis-Plus 也提供了相应的工具，感兴趣的小伙伴可以自行
Springboot mongodb 多数据源动态切换
05-25
在Springboot中使用MongoDB多数据源并动态切换，可以通过以下步骤实现： 1. 添加MongoDB的依赖 在pom.xml文件中加入对spring-boot-starter-data-mongodb和mongodb-driver的依赖。 2. 配置多数据源 在application.yml或application.properties中配置多个数据源，如下所示： ``` spring: data: mongodb: uri: mongodb://localhost:27017/test1 database: test1 seconddata: mongodb: uri: mongodb://localhost:27017/test2 database: test2 ``` 其中第一个数据源是默认的数据源，第二个数据源是自定义的数据源。 3. 配置数据源切换组件 在Springboot中使用MongoDB多数据源需要使用MongoDbFactory和MongoTemplate两个组件。我们可以通过自定义MongoTemplate的方式来实现数据源的切换。具体实现可以参考以下代码： ```java @Configuration public class MultipleMongoConfig { @Bean(name = "firstMongoTemplate") @Primary public MongoTemplate firstMongoTemplate() throws Exception { return new MongoTemplate(firstFactory()); } @Bean(name = "secondMongoTemplate") public MongoTemplate secondMongoTemplate() throws Exception { return new MongoTemplate(secondFactory()); } @Bean @Primary public MongoDbFactory firstFactory() throws Exception { return new SimpleMongoDbFactory(new MongoClientURI( env.getProperty("spring.data.mongodb.uri"))); } @Bean public MongoDbFactory secondFactory() throws Exception { return new SimpleMongoDbFactory(new MongoClientURI( env.getProperty("seconddata.mongodb.uri"))); } } ``` 4. 动态切换数据源 在需要切换数据源的地方，可以通过注入MongoTemplate来实现。具体实现可以参考以下代码： ```java @Service public class UserServiceImpl implements UserService { @Autowired @Qualifier("firstMongoTemplate") private MongoTemplate firstMongoTemplate; @Autowired @Qualifier("secondMongoTemplate") private MongoTemplate secondMongoTemplate; public void save(User user) { if (user.isUseSecondDataSource()) { secondMongoTemplate.save(user); } else { firstMongoTemplate.save(user); } } public User findById(String id, boolean useSecondDataSource) { if (useSecondDataSource) { return secondMongoTemplate.findById(id, User.class); } else { return firstMongoTemplate.findById(id, User.class); } } } ``` 在上面的示例中，我们可以通过isUseSecondDataSource()方法来判断是否需要使用第二个数据源。如果需要使用第二个数据源，则使用secondMongoTemplate；否则使用firstMongoTemplate。 以上就是在Springboot中使用MongoDB多数据源并动态切换的全部步骤。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值