springboot 中动态切换数据源（多数据源应用设计）

已于 2022-02-03 21:20:38 修改
阅读量4.8k 收藏 23
点赞数 3
分类专栏： Java MySQL 文章标签： spring boot 数据库 spring
于 2021-09-26 01:17:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QiuHaoqian/article/details/120479890
版权
Java 同时被 2 个专栏收录
32 篇文章 11 订阅
订阅专栏
MySQL
9 篇文章 7 订阅
订阅专栏

目录



最近在做一个租户隔离的项目，要求不同租户数据放入不同的数据库实现物理隔离，涉及到多个数据库的应用，除了使用数据库中间件，还想到了一个不错的解决方案，就是动态切换当前请求线程的数据源。所以写篇文章来记录一下。

本文使用了 springboot + mybatis-plus

项目源码可以参考
https://gitee.com/qiu_yunzhao/daily_function_test/tree/master/dynamic_dataSource

哔站有个不错的视频教程：
https://www.bilibili.com/video/BV11Z4y1f7cT?p=1

原理图

请添加图片描述

数据库

创建两个数据库 ds0与ds1
在这里插入图片描述
在这里插入图片描述

项目结构

在这里插入图片描述

下边这些都是平时最常用的就不在多做介绍

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DynamicDataSourceApplication {

    public static void main(String[] args) {
        SpringApplication.run(DynamicDataSourceApplication.class, args);
    }

}

entity

package com.haoqian.dynamic_data_dource.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * @author haoqian
 * @since 2021-08-22
 */
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("tbl_employee")
public class Employee implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    private String lastName;

    private String email;

    private String gender;

    private Integer age;

}

controller

package com.haoqian.dynamic_data_dource.controller;

import com.haoqian.dynamic_data_dource.entity.Employee;
import com.haoqian.dynamic_data_dource.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author haoqian
 * @since 2021-08-22
 */
@RestController
@RequestMapping("/employee")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    @GetMapping("/{id}")
    public Employee select(@PathVariable("id") Integer id) {
        return employeeService.getEmpById(id);
    }

}

service

import com.haoqian.dynamic_data_dource.entity.Employee;
import com.baomidou.mybatisplus.extension.service.IService;

public interface EmployeeService extends IService<Employee> {
    Employee getEmpById(int id);
}

import com.haoqian.dynamic_data_dource.entity.Employee;
import com.haoqian.dynamic_data_dource.mapper.EmployeeMapper;
import com.haoqian.dynamic_data_dource.service.EmployeeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService {

    @Override
    public Employee getEmpById(int id) {
        return this.baseMapper.getEmpById(id);
    }
}

mapper

import com.haoqian.dynamic_data_dource.entity.Employee;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;

public interface EmployeeMapper extends BaseMapper<Employee> {
    Employee getEmpById(int id);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.haoqian.dynamic_data_dource.mapper.EmployeeMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.haoqian.dynamic_data_dource.entity.Employee">
        <id column="id" property="id"/>
        <result column="last_name" property="lastName"/>
        <result column="email" property="email"/>
        <result column="gender" property="gender"/>
        <result column="age" property="age"/>
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        id, last_name, email, gender, age
    </sql>

    <select id="getEmpById" resultType="com.haoqian.dynamic_data_dource.entity.Employee">
      SELECT * FROM tbl_employee WHERE id=#{id}
   </select>

</mapper>


重点来了，下边是实现动态切换数据库的核心代码

配置文件

我们在配置文件中配置文章开头介绍的两个数据库

spring:
  # 设置druid数据源
  datasource:
    #配置ds0据库
    primary:
      jdbc-url: jdbc:mysql://192.168.0.150:3306/ds0?characterEncoding=UTF-8&serverTimezone=GMT%2B8
      username: root
      password: aaaaaa
      driver‐class‐name: com.mysql.cj.jdbc.Driver # 注意MySQL8.x的驱动
    #配置ds1数据库
    secondary:
      jdbc-url: jdbc:mysql://192.168.0.150:3306/ds1?characterEncoding=UTF-8&serverTimezone=GMT%2B8
      username: root
      password: aaaaaa
      driver‐class‐name: com.mysql.cj.jdbc.Driver # 注意MySQL8.x的驱动

# mybatis-plus配置（与mybatis配置项几乎一样，就是这里用mybatis-plus而不是mybatis）
# 可配置项见官网 https://mybatis.plus/config/#globalconfig-2
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 开启sql日志打印(支持配置文件和注解)
    map-underscore-to-camel-case: true # 驼峰下划线映射规则（默认true）

线程上下文 （DataSourceHolder）

线程上下文用于存储当前线程使用的数据源

package com.haoqian.dynamic_data_dource.datasource;

/**
 * @author qyz
 */
public class DataSourceHolder {

    /**
     * 线程本地环境 （存储数据库名称）
     */
    private static final ThreadLocal<String> DATA_SOURCES = new ThreadLocal<>();

    /**
     * 设置数据源(动态切换数据源),就是调用这个setDataSource方法
     */
    public static void setDataSource(String customerType) {
        DATA_SOURCES.set(customerType);
    }

    /**
     * 获取数据源
     */
    public static String getDataSource() {
        return DATA_SOURCES.get();
    }

    /**
     * 清除数据源
     */
    public static void clearDataSource() {
        DATA_SOURCES.remove();
    }
}

动态数据源 DynamicDataSource

核心是需要继承 AbstractRoutingDataSource 实现determineCurrentLookupKey()方法，通过该方法的返回值实现不同线程中动态切换数据源。

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @author qyz
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    /**
     * 每次请求动态请求哪一个数据源
     *
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceHolder.getDataSource();
    }

    /**
     * 此处数据库配置,可以来源于redis等,然后再初始化所有数据源
     * 重点说明:一个DruidDataSource数据源,它里面本身就是线程池了,所以我们不需要考虑线程池的问题
     *
     * 这里我们选择将数据源的配置放到了配置文件中
     * 
     * @param database 数据库名称
     * @return 数据源
     */
//    public DataSource druidDataSource(int database) {
//        DruidDataSource datasource = new DruidDataSource();
//        datasource.setUrl("jdbc:mysql://localhost:3306/" + database);
//        datasource.setUsername("root");
//        datasource.setPassword("aaaaaa");
//        datasource.setDriverClassName("com.mysql.jdbc.Driver");
//        datasource.setInitialSize(5);
//        datasource.setMinIdle(5);
//        datasource.setMaxActive(20);
//        //datasource.setDbType("com.alibaba.druid.pool.DruidDataSource");
//        datasource.setMaxWait(60000);
//        datasource.setTimeBetweenEvictionRunsMillis(60000);
//        datasource.setMinEvictableIdleTimeMillis(300000);
//        datasource.setValidationQuery("SELECT 1 FROM DUAL");
//        datasource.setTestWhileIdle(true);
//        datasource.setTestOnBorrow(false);
//        datasource.setTestOnReturn(false);
//        try {
//            datasource.setFilters("stat,wall,log4j");
//        } catch (SQLException e) {
//            e.printStackTrace();
//        }
//        return datasource;
//    }
}

数据源配置

编写数据源配置类，将数据源交由spring管理

package com.haoqian.dynamic_data_dource.datasource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

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

/**
 * @author qyz
 */
@Configuration
@MapperScan(basePackages = "com.haoqian.dynamic_data_dource.mapper", sqlSessionFactoryRef = "SqlSessionFactory")
public class DynamicDataSourceConfig {

    /**
     * 将第1个数据源对象放入Spring容器中
     *
     * @ConfigurationProperties 读取application.properties中的前缀为spring.datasource.primary的配置参数并映射成为一个对象
     */
    @Bean(name = "dateSource1")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource DateSource1() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 将第2个数据源对象放入Spring容器中
     */
    @Bean(name = "dateSource2")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource DateSource2() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 将动态代理数据源对象放入Spring容器中
     */
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource DynamicDataSource(@Qualifier("dateSource1") DataSource primaryDataSource,
                                               @Qualifier("dateSource2") DataSource secondaryDataSource) {
        // 这个地方是比较核心的targetDataSource 集合是我们数据库和名字之间的映射
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put("ds0", primaryDataSource);
        targetDataSource.put("ds1", secondaryDataSource);

        DynamicDataSource dataSource = new DynamicDataSource();
        // 设置所有的数据源
        dataSource.setTargetDataSources(targetDataSource);
        // 设置默认使用的数据源对象
        dataSource.setDefaultTargetDataSource(primaryDataSource);

        return dataSource;
    }


    @Bean(name = "SqlSessionFactory")
    public SqlSessionFactory SqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dynamicDataSource);
        bean.setMapperLocations(
                // 设置数据库mapper的xml文件路径
                new PathMatchingResourcePatternResolver()
                        .getResources("classpath*:com/haoqian/dynamic_data_dource/mapper/*/*.xml"));
        return bean.getObject();
    }
}

AOP

在aop中拦截controller请求，从请求头中获取使用的数据源库，然后讲当前请求使用的数据库配置到线程上下文中，实现动态数据源切换

import com.haoqian.dynamic_data_dource.datasource.DataSourceHolder;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.Objects;


/**
 * 拦截controller方法，从请求头中获取使用的数据库编号
 *
 * @author qyz
 */
@Aspect
@Order(1)
@Configuration
public class DataSourceAspect {

    /**
     * 数据库名称在请求头中的key（从header中取）
     */
    private static final String DSNO = "dsNo";

    /**
     * 切入点,放在controller的每个方法上进行切入,更新数据源
     */
    @Pointcut("execution(* com.haoqian.dynamic_data_dource.controller..*.*(..))")
    private void anyMethod() {
    }

    @Before("anyMethod()")
    public void dataSourceChange() {
        // 请求头head中获取对应数据库编号 name=dsNo
        String dsNo = ((ServletRequestAttributes) Objects
                .requireNonNull(RequestContextHolder.getRequestAttributes()))
                .getRequest()
                .getHeader(DSNO);
        System.out.println("当前数据源: " + dsNo);
        if (StringUtils.isBlank(dsNo)) {
            // TODO 根据业务抛异常
            throw new NullPointerException("请求头中没有" + DSNO);
        }
        // 根据请求头中数据库名称来更改对应的数据源（核心）
        DataSourceHolder.setDataSource(dsNo);
    }

    @After("anyMethod()")
    public void after() {
        // 数据源重置（必须在请求完成后清空ThreadLocal线程上下文，否则会内存溢出）
        DataSourceHolder.clearDataSource();
    }
}

测试验证

在这里插入图片描述
在这里插入图片描述

补充-不同场景中的应用

数据库的读写分离场景：

  1. 使用mybatis框架时可以使用mybatis的拦截器，在拦截其中获取要执行的sql，解析sql，根据sql语句的读写操作，来改变使用的数据库标识，进而动态切换到对应的数据库。

  2. 当然，如果项目有预算，且有人维护的话可以使用数据库中间件来实现，如mycat。

不同业务数据存储在不同数据库的场景：

  1. 使用多数据源应用的方案解决时，一般采用 “AOP+自定义注解” 的方式实现数据源的动态切换。在前置通知中改变使用的数据库标识，进而动态切换到对应的数据库。

  2. 可以使用微服务架构来进行解决。

  3. 可以使用mybatis框架提供的功能，直接配置多份mapper与sql映射文件，改设计详见
    https://blog.csdn.net/QiuHaoqian/article/details/122724818.

事务问题待解决

多数据源的事务处理是有问题的，一定要注意（可以使用分布式事务，但是很复杂）。

  1. spring自带的声明式事务无法实现多数据源的事务管理，因为 @Transactional只能指定一个事务管理器。
  2. spring的编程式事务可以实现，但是比较麻烦

补充：

Dynamic-Datasource (opens new window)- 一个基于 SpringBoot 的多数据源组件，功能强悍，支持 Seata 分布式事务。可以使用它实现多数据源系统。

该组件由 mybatis-plus 的团队开发。其实现原理同上边我们介绍的。并且提供了多数据源事务的支持

@DS

@DSTransactional

这里不在讲述，详见

https://github.com/baomidou/dynamic-datasource-spring-boot-starter

浩骞
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot之多数据源配置
qq_39940489的博客
08-21 3661
应用直接操作的是abstractRoutingDataSource的实现类，告诉AbstractRoutingDataSource访问哪个数据库，然后由AbstractRoutingDataSource从事先配置好的数据源 （ds1，ds2）选择哪一个 ，来访问对应的数据库。
SpringBoot3多数据源动态切换
qq_51076413的博客
01-04 1265
SpringBooot动态数据源；SpringBoot3.x多数据源切换；Springboot、MyBatisPlus实现动态数据源切换；Springboot动态数据源实现读写分离；
SpringBoot 动态数据源切换（Nacos做配置中心）
FBB360JAVA的博客
05-06 2916
文章目录前言1 项目文件结构2 配置文件和pom.xml文件2.1 pom.xml2.2 bootstrap.yml2.3 Nacos 中的配置3 Java文件内容3.1 org.feng.datasource 中3.1.1 DynamicDataSource3.1.2 DynamicDataSourceContextHolder3.1.3 DynamicDataSourceConfig3.1.4 DataSourceConstant3.1.5 DataSourceProperties3.1.6 DataS
Spring Boot实现多数据源！！！
最新发布
群群的博客
05-27 386
Spring Boot实现多数据源快速入门！！！
SpringBoot整合多数据源，动态添加新数据源并切换（保姆级教程）
m0_48420795的博客
08-27 9669
SpringBoot整合多数据源，动态添加新数据源并切换（保姆级教程）
Spring Boot多数据源配置并通过注解实现动态切换数据源
huangjhai的博客
07-31 5829
Spring Boot提供了AbstractRoutingDataSource 根据用户定义的规则选择使用的数据源，这样我们可以在每次数据库操作前设置使用的数据源，实现可动态路由的数据源，从而实现读写分离的功能。
SpringBoot 实现动态切换多数据源，这么做才叫优雅！
芋艿V
06-07 595
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT ...
SpringBoot实现动态切换数据源（含源码）
01-25
在Spring Boot应用中，动态切换数据源是一项关键功能，尤其在多数据库环境或者读写分离的架构中。这里我们将深入探讨如何使用`ThreadLocal`和`AbstractRoutingDataSource`来实现这一目标。 `ThreadLocal`是Java提供...
SpringBoot配置多数据源实现动态切换数据源
06-29
接下来是动态切换数据源的关键，这通常通过AOP（面向切面编程）和ThreadLocal来实现。创建一个自定义的`Aspect`，并在方法执行前根据业务逻辑选择合适的数据源： ```java @Aspect @Component public class ...
SpringBoot Mybatis动态数据源切换方案实现过程
08-19
3. 复杂业务系统：在复杂业务系统中，需要从多个数据源抽取数据，动态数据源切换方案可以解决这个问题。 SpringBoot Mybatis动态数据源切换方案实现过程是一种灵活、可扩展、 高效、可维护的解决方案，适用于大数据...
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务
01-05
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务。一个基于springboot的快速集成多数据源的启动器。支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持数据库...
SpringBoot整合Sharding-JDBC，实现从数据库加载sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换
03-22
SpringBoot整合Sharding-JDBC，实现从数据库读取sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换
基于springboot整理的分布式事务及动态数据源切换
04-17
整理的分布式事务 及动态数据源切换 基于数据库XA... @Transactional 正常标注在interface上即可 需在切换数据源之前启动事务 @DynamicDBSource("run") 可标注在server层也可以标注在Dao层 即可指定方法内使用的数据源
动态切换数据源
qq_47142993的博客
05-23 2682
思路 自定义一个注解 @DataSource，将来可以将该注解加在 service 层方法或者类上面，表示方法或者类中的所有方法都使用某一个数据源。 对于第一步，如果某个方法上面有 @DataSource 注解，那么就将该方法需要使用的数据源名称存入到 ThreadLocal。 自定义切面，在切面中解析 @DataSource 注解，当一个方法或者类上面有 @DataSource 注解的时候，将 @DataSource 注解所标记的数据源存入到 ThreadLocal 中。 最后，当 Mapper 执行的
SpringBoot动态切换数据源
qq_37634156的博客
08-24 4407
这里需要注意如果SpringBoot版本是2.0之后的版本，需要把【url】和【driverClassName】写成【jdbc-url】和【driver-class-name】，否则会报错【jdbcUrl is required with driverClassName.】自定义数据源枚举类，这里配置了两个数据源，则创建两个枚举。 3、注入数据源 生成bean。单一数据源与Mybatis整合时将DataSource数据源作为参数构建【SqlSessionFactory】，而多个数据源的话只需要将作为
springboot动态实现数据源的切换
q1252320343的博客
10-25 1091
springboot动态切换数据源
springboot动态切换数据源
qq_62770345的博客
06-24 728
*** 数据源信息*/return db;注：配置类这样定义，配置文件也要按照这个写，如@Override@Resource@Bean// 创建数据源// 设置数据源。
SpringBoot应用实现多数据源动态切换【一】
winnieEnchant的博客
06-05 986
由于工作需要，2020年便初步了解了多数据源切换，通过网上多个资料查询和学习，实现了初版的多数据源动态切换，最近又因为工作需要分库分表，考虑到想要成熟的分库分表的实现，自己并不打算重写，所以通过网上的资料学习，又升级了一套已经成熟的多数据源切换方案。此时的数据源配置已不符合springBoot自带的数据源读取configuration前缀匹配规范，因此无法获取到数据源，启动应用会报错。2、继承AbstractRoutingDataSource，定义多数据源，实现路由切换。六、定义多数据源切换实现。
springboot jdbctemplate 动态切换数据源
05-16
SpringBoot是一个非常流行并且易于使用的后端框架。在传统的数据库应用程序中，我们通常都需要使用JdbcTemplate来操作数据库。但是在某些情况下，我们需要动态切换数据源。比如，我们可能要从单一的应用程序中连接到不同的数据源（例如生产环境与测试环境）。 为了解决这一问题，我们可以在SpringBoot中使用DynamicDataSource这个开源项目来实现动态切换数据源。 在使用DynamicDataSource之前，我们需要先在application.properties文件中配置我们的数据源。比如，我们可以配置两个数据源： ``` spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1 spring.datasource.primary.username=root spring.datasource.primary.password=root spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2 spring.datasource.secondary.username=root spring.datasource.secondary.password=root ``` 然后我们在代码中实现DynamicDataSource的相关接口，实现动态切换数据源的功能。具体来说，我们需要实现AbstractRoutingDataSource这个类中的determineCurrentLookupKey()方法，这个方法的返回值决定了当前应该使用哪个数据源。 接下来，我们可以在代码中使用@Autowired注解来注入DynamicDataSource，然后根据需要调用DynamicDataSource的setDataSource()方法来切换数据源，从而实现动态切换数据源。 总之，使用SpringBoot和JdbcTemplate结合DynamicDataSource能够非常方便地实现动态切换数据源的功能，从而提高代码的灵活性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值