SpringBoot + 动态数据源切换实战：基于AOP与ThreadLocal的优雅实现

于 2025-04-23 10:46:13 发布
阅读量437 收藏 8
点赞数 9
CC 4.0 BY-SA版权
文章标签： spring boot 后端 java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41323045/article/details/147443190

动态数据源切换实战：基于AOP与ThreadLocal的优雅实现

一、应用场景

在多数据源架构中，我们常需要动态切换数据源。典型场景包括：

  1. 多租户系统：不同租户使用独立数据库
  2. 读写分离：写操作主库，读操作从库
  3. 分库分表：根据业务规则路由到不同数据库

本文将解析一个基于Spring AOP和ThreadLocal的动态数据源切换实现方案。

二、核心实现解析

1. 整体架构图

[HTTP请求] 
    |
    v
[拦截器/AOP] --> [数据源上下文] --> [路由决策]
    |
    v
[执行SQL] --> [清理上下文]

2. 关键代码解析

（1）AOP切面实现（DataSourceAspect）
@Before("datasourcePointcut()")
public void beforeAdvice(JoinPoint joinPoint) {
    // 优先级1：检查方法/类上的@DS注解
    DS dataSource = getClassAnnotation(joinPoint);
    if (Objects.isNull(dataSource)) {
        // 优先级2：线程上下文数据源
        String localDS = DataSourceContextHolder.getDataSource();
        if (StringUtils.isNotBlank(localDS)) {
            DynamicDataSourceContextHolder.push(localDS);
        } 
        // 优先级3：HTTP请求头
        else if (WebUtil.getRequest() != null) {
            String headerDS = request.getHeader("dataSourceName");
            DynamicDataSourceContextHolder.push(headerDS);
        }
    }
}

执行顺序：
方法注解 > 类注解 > 线程上下文 > 请求头

（2）上下文保持（DataSourceContextHolder）
public class DataSourceContextHolder {
    // 使用TTL解决线程池环境下的上下文传递
    private static final ThreadLocal<String> DATA_SOURCE = 
        new TransmittableThreadLocal<>();
    
    public static void setDataSource(String dataSource) {
        DATA_SOURCE.set(dataSource);
    }
}

三、使用示例

场景1：注解式切换

@Service
public class OrderService {
    
    @DS("master") // 强制使用主库
    @Transactional
    public void createOrder(Order order) {
        // 写操作...
    }
    
    @DS("slave") // 指定从库
    public Order getOrder(Long id) {
        return orderMapper.selectById(id);
    }
}

场景2：编程式切换

public void multiTenantOperation(String tenantId) {
    try {
        // 手动设置数据源
        DataSourceContextHolder.setDataSource("tenant_" + tenantId);
        // 执行数据库操作
        tenantService.processBusiness();
    } finally {
        DataSourceContextHolder.clear(); // 必须清理！
    }
}

场景3：通过HTTP请求动态切换

# 使用curl测试
curl -H "dataSourceName: slave-01" http://api.example.com/query/data

四、配置说明

1. 必要依赖

<!-- 动态数据源 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.6.1</version>
</dependency>

<!-- 上下文传递 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>transmittable-thread-local</artifactId>
    <version>2.14.2</version>
</dependency>

2. 配置文件

sto:
  datasource:
    dynamic:
      enable: true
      dataSourceName: master # 默认数据源
      datasources:
        master:
          url: jdbc:mysql://master-db:3306/db
          username: root
          password: 123456
        slave-01:
          url: jdbc:mysql://slave1-db:3306/db
          username: read_user
          password: 123456

五、注意事项

  1. 线程安全
    务必在finally块中执行DynamicDataSourceContextHolder.poll()清理上下文

  2. 事务管理
    @Transactional注解的方法需要在最外层声明@DS，否则会导致切换失效

  3. 性能优化
    建议为不同数据源配置独立的连接池：

    @Bean
@DS("slave")
public DataSource slaveDataSource() {
    return DataSourceBuilder.create().build();
}

六、总结

本文实现的动态数据源方案具有以下优势：

特性说明
多级优先级控制注解 > 编程式 > 请求头
异步线程支持通过TTL实现上下文传递
低入侵性只需添加注解即可切换数据源
灵活扩展轻松添加新数据源配置

七、附录

DataSourceAspect.java (完整版)

package com.coder.framework.datasource.core.aop;

import cn.hutool.core.util.StrUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
import com.coder.framework.common.util.http.WebUtil;
import com.coder.framework.datasource.core.context.DataSourceContextHolder;
import com.coder.framework.datasource.core.props.DataSourceProperties;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
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.aspectj.lang.reflect.MethodSignature;

import java.util.Objects;

/**
 * 动态数据源切面
 */
@Slf4j
@Aspect
public class DataSourceAspect {

    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional) " +
            "|| execution( * com.coder.module.*.service.*.*.*(..)) " +
            "|| execution( * com.coder.module.*.dal.*.*.*(..))")
    public void datasourcePointcut() {
    }

    /**
     * 前置操作
     */
    @Before("datasourcePointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        // 获取类上的数据源注解
        DS dataSource = getClassAnnotation(joinPoint);
        // 没有指定数据源
        if (Objects.isNull(dataSource)) {
            // 尝试从请求头获取
            HttpServletRequest request = WebUtil.getRequest();
            if (StringUtils.isNotBlank(DataSourceContextHolder.getDataSource())) {
                DynamicDataSourceContextHolder.push(DataSourceContextHolder.getDataSource());
            } else if (Objects.nonNull(request)) {
                String dataSourceName = request.getHeader(DataSourceProperties.DATA_SOURCE_NAME);
                if (StringUtils.isNotBlank(dataSourceName)) {
                    DynamicDataSourceContextHolder.push(dataSourceName);
                }
            }
        }
        if (StrUtil.isNotBlank(DynamicDataSourceContextHolder.peek())) {
            // 获取当前执行数据源
            log.info("执行SQL的数据源：{}", DynamicDataSourceContextHolder.peek());
        }
    }

    /**
     * 获取类、接口、注解
     */
    private DS getClassAnnotation(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        // 获取方法上的数据源注解
        DS methodAnnotation = methodSignature.getMethod().getAnnotation(DS.class);
        if (Objects.nonNull(methodAnnotation)) {
            return methodAnnotation;
        }
        // 获取目标类的类型
        Class<?> targetClass = joinPoint.getTarget().getClass();
        // 获取接口上的注解
        DS dataSource = targetClass.getAnnotation(DS.class);
        if (Objects.nonNull(dataSource)) {
            return dataSource;
        }
        // 目标类上没有注解 =》 检查其实现的接口
        for (Class<?> clazz : targetClass.getInterfaces()) {
            dataSource = clazz.getAnnotation(DS.class);
            if (Objects.nonNull(dataSource)) {
                return dataSource;
            }
        }
        // 检查其类所属的父类
        Class<?> superClass = targetClass.getSuperclass();
        while (Objects.nonNull(superClass) && superClass != Object.class) {
            dataSource = superClass.getAnnotation(DS.class);
            if (Objects.nonNull(dataSource)) {
                return dataSource;
            }
            superClass = superClass.getSuperclass();
        }
        return null;
    }

    /**
     * 后置操作
     */
    @After("datasourcePointcut()")
    public void afterAdvice() {
        DynamicDataSourceContextHolder.poll();
    }

}

DataSourceContextHolder.java

package com.coder.framework.datasource.core.context;

import com.alibaba.ttl.TransmittableThreadLocal;

/**
 * 本地线程数据源（用于特地情况下，需要指定某个数据源执行）
 */
public class DataSourceContextHolder {

    private static final ThreadLocal<String> DATA_SOURCE = new TransmittableThreadLocal<>();

    /**
     * 设置数据源
     *
     * @param dataSource 数据源名称
     */
    public static void setDataSource(String dataSource) {
        DATA_SOURCE.set(dataSource);
    }

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

    /**
     * 清空本地线程变量
     */
    public static void clear() {
        DATA_SOURCE.remove();
    }
}

DataSourceProperties.java

package com.coder.framework.datasource.core.props;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 动态数据源配置
 *
 * @author L.ty
 */
@ConfigurationProperties(prefix = DataSourceProperties.PREFIX)
@Data
public class DataSourceProperties {

    public static final String PREFIX = "sto.datasource.dynamic";

    /**
     * 默认数据源名称
     */
    public static final String DATA_SOURCE_NAME = "dataSourceName";

    /**
     * 是否开启动态数据源
     */
    private Boolean enable = false;

    /**
     * 数据源名称：如 master or salve
     */
    private String dataSourceName = DATA_SOURCE_NAME;

}
Liberty715
关注
Springboot 整合druid+mybatis+jta分布式事务+多数据源aop注解动态切换 （一篇到位）
默默不代表沉默
12-11 1万+
前言： springboot整合多数据源，大家肯定不陌生，方式不一，但是相信大家整合多数据源，如果涉及到事务，都会非常烦恼，多数据源的事务不是冲突就是失效，而如今网上千篇一律的老年博客，想找到真正解决问题的，非常少。所以我决定出来分享下可用的整合方案，而且是从头到尾的那种。 这一篇我选择的是以AOP注解的方式去进行数据源的动态切换，顺带整合jta-atomikos把烦人的事务问题解决调，持久层...
Springboot 从数据库读取数据库配置信息，动态切换多数据源 最详细实战教程
热门推荐
默默不代表沉默
10-23 5万+
以前写过一篇教程，Springboot AOP方式切换多数据源（主从两库类似情况使用最佳）： https://blog.csdn.net/qq_35387940/article/details/100122788 网上大多流传的springboot系列的切换多数据源都是以上那种写死在配置文件里的方式，这样如果我需要切换的数据源有10个，那么这种方式会不会显得稍微有点繁琐了。 现在这篇介绍...
threadlocal实战动态数据源
帝都的雁的博客
10-09 1180
一、思路 配置多个数据源。 将多个数据源放入map，map放入动态数据源，设定动态数据源的默认数据源。 sqlSessionFactory中设定动态数据源。 动态数据源从threadLocal中获取目标数据源的名称，进而切换数据源。 通过aop切入方法，并约定好方法命名（注意this会使aop失效），来区分读和写。 前置通知中，读操作，threadLocal中放入读数据源的key；写操作，threadLocal中放入写数据源的key。 后置通知中，清空threadLocal，防止内存泄漏。
Aop&ThreadLocal实现动态数据源切换
asdfasaa的博客
12-30 1149
文中介绍了spring-boot如何集成Aop进行使用，使用ThreadLocal与数据源进行绑定保障了安全性，Aop进行数据源的切换减少对程序的侵入，最后使用自定义注解简化了数据源切换的方法
动态数据源切换
qq_36022463的博客
05-22 1305
通过一个注解实现动态数据源切换 将要用的数据源名字，记录在threadLocal中 通过AbstractRoutingDataSource，重写方法，将threadLocal中的数据源名字设置进去 。（当这个系统需要获取数据源的时候，会自动调用AbstractRoutingDataSource中的determineCurrentLookupKey()方法，获取要用的数据源名字） aop拦截注解 网页上，传递你要使用的数据源名字，aop拦截修改threaLocal中的值 多个aop调用顺序 ...
ThreadLocal&&Reference
难得糊涂
05-17 591
序言 目前ThreadLocal使用场景最多的就是多数据源的切换了.我们在使用ThreadLocal在不同线程之间切换数据源的时候要其实有很多知识点需要注意[email protected] 线程的状态 线程入门的知识,但是在后续的设计中会应用到[email protected] 系统线程的状态 新建(NEW) 就绪(RUNNABLE) 运行(RUNNING) 阻塞(BLOCKING): sleep,wating,blocking 死亡(DEAD) Java线程状态
sprinboot多数据源动态切换？
瞬间的未来式的博客
03-24 962
在AOP切面中，可以通过切点匹配需要切换数据源的方法，然后在方法执行前根据数据源标识切换数据源。例如，可以在DAO层的方法上进行切面编程，实现在DAO层动态切换数据源。在Spring Boot应用中，可以通过配置多个数据源，并且动态地在这些数据源之间进行切换。实现动态切换数据源的核心原理是使用了ThreadLocal存储当前数据源的标识，在需要使用数据源的时候根据标识从多个数据源中选择一个进行使用。在该工具类的方法中，可以根据当前线程中保存的数据源标识，获取对应的数据源。3.实现数据源切换AOP。
SpringBoot动态切换数据源的终极指南：从入门到高可用实战
最新发布
hbh1001的博客
02-21 981
刚上线的系统突然要对接3个数据库，老板要求不重启服务随时切换！动态数据源切换，看似简单，实则暗藏玄机：事务失效、连接泄漏、配置冲突……：关注博主并私信“动态数据源”，免费领取《SpringBoot多数据源配置模板》+《Druid监控配置指南》：你在动态数据源切换中踩过哪些坑！三板斧，再结合连接池优化和监控，低配服务器也能扛住高并发。动态数据源切换不是炫技，而是应对复杂业务场景的刚需。参考实现：通过数据库表存储数据源配置，启动时自动加载。推荐使用Druid连接池，配置监控和防泄漏策略：！
SpringBoot多数据源动态切换实战教程
AOP实现动态数据源切换 利用Spring AOP创建一个切面，在切面中根据方法的注解或者类的注解来切换数据源。 ```java @Aspect @Component public class DataSourceAspect { @Before("@annotation(targetDataSource)...
Spring Boot 实现数据源动态切换的最佳姿势！
02-05 1010
在介绍动态数据源之前，我们先一起来看看多数据源在 Spring Boot 中的实现方式。
Spring定时任务中使用ThreadLocal的坑
04-24
NULL 博文链接：https://bijian1013.iteye.com/blog/2380233
【数据库与事务系列】多数据源切换
qq_35789269的博客
12-03 3486
多数据源
SpringBoot+ThreadLocal+AbstractRoutingDataSource实现动态切换数据源
weixin_54542328的博客
10-25 441
上述提到了ThreadLocal和AbstractRoutingDataSource，我们来对其进行简单介绍下。：想必大家必不会陌生，全称：thread local variable。主要是为解决多线程时由于并发而产生数据不一致问题。ThreadLocal为每个线程提供变量副本，确保每个线程在某一时间访问到的不是同一个对象，这样做到了隔离性，增加了内存，但大大减少了线程同步时的性能消耗，减少了线程并发控制的复杂程度。ThreadLocal作用：在一个线程中共享，不同线程间隔离。
mybatis 手把手配置多个数据源（多个数据库连接）
众纳百川的博客
08-18 1万+
需求：项目中特别是做一个项目的外挂时，我们不希望直接在原库中修改，而是从一个库（业务库）读取，然后存入另一个库中（本地库）。这种需求非常常见；那么如何解决这个问题呢！ 首先用原来的数据源配置文件指定是不行的（因为数据源配置机制决定）； 准备工作，配置一个Spring boot +mybatis出来。 项目结构如下： 其中confing/dds/用来实现AOP切面基础类 1.数据库准备 2.数据源配置：application.yml #运行端口 server: port: 8080 #数据库配置 sp
利用 ThreadLocal 和 AbstractRoutingDataSource 实现基于注解的动态数据源切换
name_sakura的博客
12-29 398
利用ThreadLocal和AbstractRoutingDataSource实现基于注解的动态数据源切换
动态切换数据源原理详解，以及Spring Boot + MyBatis-Plus 在实际开发中的快速切换方法
funnyCaoC的博客
03-27 1748
在一个实际的企业工程项目当中，我们的数据往往会来源于不同的数据库服务器，所以在调用数据访问层或者业务层的方法时，我们要指定本次访问的数据来源于哪个数据源，最好的方式就是通过注解的方式，直接切换当前方法的数据来源。所幸的是，MyBatis Plus基于Spring Boot项目开发了一个能够快速切换数据源的注解，在介绍它之前，我们先来了解一下动态切换数据源的原理，同时也可以让没有导入Mybatis Plus的小伙伴也能通过注解实现数据源的切换。
使用ThreadLocal进行多数据源的配置
weixin_42030357的博客
06-19 2875
文章目录关键类逻辑思路实现多数据源关于事务实现yml配置文件相关类代码实现DataSourceNamesDynamicDataSourceContextHolderDynamicDataSourceConfigDynamicDataSourceDataSourceAspectTargetDataSource使用测试 关键类 ThreadLocal 线程局部变量，所谓局本部变量，就是仅仅能在本线程访问，不能在线程之间进行共享访问的变量 AbstractRoutingDataSource getConn
springboot使用DynamicDataSource来动态切换数据源
weixin_46931883的博客
03-17 9156
在该类中重写**determineCurrentLookupKey()**方法，该方法返回一个字符串，用于指示当前要使用哪个数据源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值