【mysql】使用AbstractRoutingDataSource实现多数据源 与 获取mapper上注解

于 2024-10-09 22:23:24 发布
阅读量401 收藏 19
点赞数 3
分类专栏： 电商 文章标签： mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34370153/article/details/142796578
版权

使用AbstractRoutingDataSource实现多数据源 与 获取mapper上注解

背景

        随着业务发展速度越来越快，数据的增长也呈现倍数级别增长，数据库的压力，对于查询和写入等所有操作，都依赖于主库，其实有一些对于时效性要求不高的场景，无需使用主库查询，可以使用从库来分摊主库的压力，提升数据库集群整体的吞吐量

处理思路

其实处理思路共有两种

1. 我们创建两个数据源，不同的数据源扫描不同的包.
        也就是查询从库或者查询主库，是通过不同的mapper文件物理隔离的，优势就是开发简单，快速搭建，不用担心侵入原有逻辑。缺点也是显而易见的，如果一个sql在某些场景下需要主库查询，另外场景需要从库查询，那么我们要写两套sql，如果有新增字段等ddl操作时，我们要改两遍sql，由于比较简单，本文不做描述。

2. 使用动态数据源配置
        在多个数据源之上，抽象出来一个虚拟的动态数据源，等到执行sql的前一步，我们才会选择哪个数据源执行，优点是能够更精细化的管控sql执行，缺点的话就是开发稍微复杂些

动态数据源的执行逻辑

我们需要先了解下spring的AbstractRoutingDataSource ，spring提供了一套数据库路由方案，我们重写determineCurrentLookupKey 方法，将想要的数据库返回即可。

以spring boot 为例

一、 mysql的基本配置

  1. 首先配置主库和从库的数据源，这个是前提

    @Bean(name = "mysqlDataSource")
@Primary
public DataSource mysqlDataSource() {
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName(driverClass);
    dataSource.setUrl(url);
    dataSource.setUsername(user);
    dataSource.setPassword(password);
    dataSource.setMaxActive(300);
    dataSource.setKeepAlive(true);
    dataSource.setMaxWait(60000);
    dataSource.setValidationQuery("SELECT 'x'");
    dataSource.setMinEvictableIdleTimeMillis(300000);
    dataSource.setTestWhileIdle(true);
    dataSource.setTestOnBorrow(true);
    dataSource.setTestOnReturn(false);
    return dataSource;
}
/**
 * 从库主库数据源
 */
@Bean(name = "mysqlSlaveDataSource")
public DataSource mysqlSlaveDataSource() {
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName(driverClass);
    dataSource.setUrl(url);
    dataSource.setUsername(readUser);
    dataSource.setPassword(passwordRead);
    dataSource.setMaxActive(300);
    dataSource.setKeepAlive(true);
    dataSource.setMaxWait(60000);
    dataSource.setValidationQuery("SELECT 'x'");
    dataSource.setMinEvictableIdleTimeMillis(300000);
    dataSource.setTestWhileIdle(true);
    dataSource.setTestOnBorrow(true);
    dataSource.setTestOnReturn(false);
    return dataSource;
}

  2. 配置动态数据源，将多数据源注入进动态数据源，并设置默认的数据源

    @Bean(name = "dynamicDataSource")
public DynamicDataSource dynamicDataSource(@Qualifier("mysqlDataSource") DataSource mysqlDataSource,
                                           @Qualifier("mysqlSlaveDataSource") DataSource mysqlSlaveDataSource) {
    Map<Object, Object> targetDataSources = Maps.newHashMap();
    targetDataSources.put(DataSourceEnum.MASTER, mysqlDataSource);
    targetDataSources.put(DataSourceEnum.SLAVE, mysqlSlaveDataSource);
    return new DynamicDataSource(mysqlDataSource, targetDataSources);
}

  3. 将动态数据源设置到sql的sessionFactory

    @Bean(name = "mysqlSqlSessionFactory")
@Primary
public SqlSessionFactory masterSqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource) throws Exception {

    final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
    sessionFactory.setDataSource(dynamicDataSource);
    sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MysqlDataSourceConfig.MAPPER_LOCATION));
    // 配置
    org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
    configuration.setMapUnderscoreToCamelCase(true);
    configuration.setDefaultStatementTimeout(30);
    configuration.addInterceptor(new MybatisUMPInterceptor());
    sessionFactory.setConfiguration(configuration);
    return sessionFactory.getObject();
}

二、 新增的配置

  1. 新增加库的枚举定义
package com.common.enums;

/**
 * 数据源配置枚举
 *
 * @author wangzym
 */
public enum DataSourceEnum {

    /**
     * 使用主库
     */
    MASTER(1, "主库"),
    /**
     * 使用从库
     */
    SLAVE(2, "从库");
    /**
     * /**
     * 编码
     */
    private Integer code;
    /**
     * 描述
     */
    private String desc;

    DataSourceEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public Integer getCode() {
        return this.code;
    }

    public String getDesc() {
        return this.desc;
    }

    public static DataSourceEnum getByCode(Integer code) {
        if (code == null) {
            return null;
        }
        for (DataSourceEnum dataSourceEnum : DataSourceEnum.values()) {
            if (dataSourceEnum.getCode().equals(code)) {
                return dataSourceEnum;
            }
        }
        return null;
    }
}
  1. 动态数据源的定义，需要继承spring的AbstractRoutingDataSource
package com.test.datasource;

import com.alibaba.fastjson.JSON;
import com.test.SettleCheckException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

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

/**
 * 动态切换数据源类
 *
 * @author wangzym
 */
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        //不符合配置条件直接中断启动流程
        if (defaultTargetDataSource == null || targetDataSources == null || targetDataSources.isEmpty()) {
            throw new SettleCheckException("默认数据源和可切换的数据源不允许为空!请检查 spring-config-datasource-druid.xml - dynamicDataSource 对应配置");
        }
        //设置默认数据源
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        //设置用于切换的数据源
        super.setTargetDataSources(targetDataSources);
        //初始化本地的数据源记录
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        log.debug("当前线程使用SQL的数据库是:{}", JSON.toJSONString(DynamicDataSourceHolder.getDataSource()));
        return DynamicDataSourceHolder.getDataSource();
    }

}

  1. 新增注解

    package com.test.datasource;


import com.test.DataSourceEnum;

import java.lang.annotation.*;

/**
 * 切换数据源注解，默认连接主库
 * 要在mapper上加此注解才可以
 * <p>

 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface SwitchDataSource {
    DataSourceEnum name() default DataSourceEnum.MASTER;
}

  2. 拦截器改造需要拦截sql，此方法可以直接拦截sql执行，此方法要重点理解，是mybatis的拦截方案，其中Intercepts可以通过不同的类型，来进行不同的拦截，此处拦截所有执行的sql，直接获取mapper上的注解会获取不到，需要通过反射的方式，来获取，需要重点注意，此处不是本文的重点，有兴趣可以了解mybatis源码。

    package com.test.interceptor;

import com.test.DuccConstants;
import com.test.enums.DataSourceEnum;
import com.test.datasource.DynamicDataSourceHolder;

@Intercepts({@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),})
@Slf4j
public class MybatisUMPInterceptor implements Interceptor {

    @Value("${test.current.env:pre}")
    private static String env;

    static {
        env = System.getProperty("current.env", "pre");
        log.info("当前切面的环境为:{}", env);
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        CallerInfo callerInfo = null;
        try {
            //1.处理数据源切换
            SwitchDataSource chooseDataSource = getSwitchDbAnnotation((MappedStatement) invocation.getArgs()[0]);
            if (null != chooseDataSource && DuccConstants.allowedMultiDb()) {
                //默认会使用MASTER数据源 如果开启事务了,而且当前数据源不是MASTER，会强制切换为MASTER
                DynamicDataSourceHolder.setDataSource(chooseDataSource.name());
                if (TransactionSynchronizationManager.isActualTransactionActive() && DataSourceEnum.SLAVE.equals(chooseDataSource.name())) {
                    DynamicDataSourceHolder.setDataSource(DataSourceEnum.MASTER);
                }
            } else {
                DynamicDataSourceHolder.setDataSource(DataSourceEnum.MASTER);
            }
            //2.埋点监控
            Object[] args = invocation.getArgs();
            MappedStatement ms = (MappedStatement) args[0];
            //ump key可以自定义
            String jKey = String.format("%s_MyBatis.%s", env, ms.getId());
            if (DynamicDataSourceHolder.getDataSource() != null && DynamicDataSourceHolder.getDataSource().equals(DataSourceEnum.SLAVE)) {
                jKey = jKey + "_slave";
            }
            callerInfo = Profiler.registerInfo(jKey, false, true);
        } catch (Exception ignore) {
            //ignore
            log.warn("切面执行出现异常:{}", ignore.getStackTrace(), ignore);
        }
        try {
            return invocation.proceed();
        } catch (Throwable e) {
            try {
                if (null != callerInfo) {
                    Profiler.functionError(callerInfo);
                }
            } catch (Exception ignore) {
                //ignore
            }
            throw e;
        } finally {
            try {
                if (null != callerInfo) {
                    Profiler.registerInfoEnd(callerInfo);
                }
            } catch (Exception ignore) {
                //ignore
            }
        }
    }
    private SwitchDataSource getSwitchDbAnnotation(MappedStatement mappedStatement) {
        SwitchDataSource annotation = null;
        try {
            String id = mappedStatement.getId();
            String className = id.substring(0, id.lastIndexOf("."));
            String methodName = id.substring(id.lastIndexOf(".") + 1);
            final Method[] method = Class.forName(className).getMethods();
            for (Method me : method) {
                if (me.getName().equals(methodName) && me.isAnnotationPresent(SwitchDataSource.class)) {
                    return me.getAnnotation(SwitchDataSource.class);
                }
            }
        } catch (Exception ex) {
            log.error("", ex);
        }
        return annotation;
    }


    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

  3. 在mapper上打注解标记

    @SwitchDataSource(name = DataSourceEnum.SLAVE)
Long queryTaskOfShopCount(GeneralFeeDetailDTO generalFeeDetailDTO);

    至此，mysql 动态路由到指定数据库就讲解完成。

wangzy-nice
关注
专栏目录
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
最后，在业务代码中，使用`@Resource`注解来注入对应数据源的Mapper，例如： ```java @Service public class UserService { @Resource private PrimaryUserMapper primaryUserMapper; @Resource private ...
springboot实现多数据源而且加上事务不会使aop切换数据源失效
04-03
最后，使用MyBatis的`@MapperScan`注解扫描Mapper接口，并在需要使用特定数据源的方法上添加`@UseSecondaryDataSource`注解： ```java @SpringBootApplication @MapperScan(basePackages = "com.example.mapper", ...
SpringBoot+AbstractRoutingDataSource实现多数据源以及事务处理
qq_22772699的博客
04-27 2254
spring框架中，spring-jdbc模块提供了AbstractRoutingDataSource，其内部可以包含了多个DataSource，然后在运行时来动态的访问哪个数据库。这种方式访问数据库的架构图如下所示：应用直接操作的是AbstractRoutingDataSource的实现类，告诉AbstractRoutingDataSource访问哪个数据库，然后由AbstractRoutingDataSource从事先配置好的数据源(ds1、ds2)选择一个，来访问对应的数据库。
AbstractRoutingDataSource实现多数据源切换以及事务中无法切换问题
weixin_50348837的博客
04-25 2087
为了实现数据源的动态切换，我们采用了AbstractRoutingDataSource结合AOP+反射来自定义注解。通过这种机制，我们可以在运行时根据自定义注解自动选择不同的数据源，从而实现灵活高效的数据访问策略。具体来说，我们首先创建了一个继承自AbstractRoutingDataSource的动态数据源类，该类能够管理多个数据源并根据线程上下文中的特定键值来选择使用哪一个数据源。接着，我们定义了一个自定义注解，用于标记需要切换数据源的方法或类。
Mybatis多数据源（二）使用AbstractRoutingDataSource实现动态数据源切换
白羊座的橙子
05-07 1607
一、原理 Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行数据库操作之前，设置使用的数据源， 即可实现数据源的动态路由。它的抽象方法determineCurrentLookupKey() 决定使用哪个数据源。 二、具体实现 具体的业务代码不贴了，就放一下构造动态数据源的部分 1、DynamicDataSour......
AbstractRoutingDataSource实现多数据源动态切换和事务处理
nuoya989的博客
10-01 3421
定义一个DynamicDataSource 类继承AbstractRoutingDataSource实现动态数据源，在类中定义一个ThreadLocal 变量存储当前线程使用的数据源名称，用于方法determineCurrentLookupKey()获取当前数据源名称。/*** 自定义动态数据源*/@Override}}}//bean对象初始化操作@Override}}
spring boot使用AbstractRoutingDataSource实现动态数据源切换
热门推荐
愿风裁尽尘中沙
06-06 7万+
一、AbstractRoutingDataSource Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。 org.springframework...
Spring boot 使用AbstractRoutingDataSource实现数据源动态切换
Isonion的博客
06-11 1125
Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。
Spring 多数据源方法级别注解实现
东皋长歌的专栏
07-25 826
Spring框架提供了多种数据源管理方式，其中多数据源管理是其中之一。多数据源管理允许应用程序使用多个数据源，而不是只使用一个数据源，从而提高了应用程序的灵活性和可靠性。 多数据源管理的主要目的是让应用程序能够在不同的数据库之间切换，以满足不同的业务需求。例如，如果应用程序需要访问一个高可用性的数据库，但是该数据库当前不可用，那么应用程序可以自动切换到备用数据库，以保证业务的连续性。 在多数据源管理中，Spring框架通过使用JNDI（Java命名和目录接口）来管理数据源。JNDI允许应用程序在运行时动
SpringBoot+自定义注解实现多数据源配置
一恍过去
06-15 2万+
SpringBoot+自定义注解实现多数据源配置
【Spring Boot】使用 AbstractRoutingDataSource 结合 AOP 实现通过注解动态切换数据源
关于一个程序员在成长过程中不断学习的一些记录与思考。
05-29 772
使用 AbstractRoutingDataSource 结合 AOP 实现通过注解动态切换数据源
MySQL表的增删改查(基础)
weixin_63965017的博客
10-02 688
语法表名values(值，值......);值与列相匹配。
基于微信小程序的生鲜订购小程序系统(SpringBoot+Vue+Uniapp+MySQL)
源码好优多
10-06 1782
开发者不再需要手动配置大量的 XML 文件或繁琐的注解，框架提供了默认的配置，根据项目的依赖关系和约定，自动完成配置。系统测试主要是为了避免用户在使用时发生问题，增强用户体验感，为了不影响用户的使用，我们需要从多角度、多思路去考虑系统可能遇到的问题，通过不同的模拟场景来发现缺陷并解决问题。添加用户时，必填项不填，检验系统是否有非空检验；登录功能测试方案：当需要登入该系统时，通过账户密码等功能点进行验证，用户在输入时需要输入与数据库内存储的数据匹配的内容，当其中某项输入错误时系统将提示输入错误。
【MySQL】MySQL 数据库主从复制详解
人生苦短，睡觉要紧，睡醒再说
10-01 1351
MySQL 主从复制是实现高可用性和负载均衡的重要手段。通过合理配置和监控，可以显著提升数据库的可用性和性能，有效地管理数据同步，实现系统的弹性和鲁棒性。在实际应用中，应根据业务需求和系统架构来合理设计部署方案，并定期监控复制状态，以确保数据的一致性和完整性。了解主从复制的工作原理及其配置过程，对数据库管理员至关重要。希望本文能帮助您深入理解 MySQL 主从复制的相关知识。
MySQL 联合索引底层存储结构及索引查找过程解读
最新发布
lizi88888的博客
10-09 363
大家好，我是 Lorin ，联合索引（Composite Index）又称复合索引，它包括两个或更多列。与单列索引不同，联合索引可以覆盖多个列，这有助于加速复杂查询和过滤条件的检索。联合索引的列顺序非常重要，因为查询优化器会按照索引列的顺序执行搜索。本文将从联合索引基本概念、底层存储结构、索引查找过程、实践建议几个方面图文并茂进行详细介绍。
滚雪球学MySQL[1.3讲]：MySQL客户端工具：详解与实践
**My Coding Family**
10-01 1460
在上期文章中，我们深入探讨了MySQL的安装与配置，这为我们顺利使用MySQL打下了基础。具体来说，我们介绍了如何正确安装MySQL、配置环境变量、调整字符集，并确保数据库可以正常运行。这些基础配置是后续操作的前提，理解并掌握这些技能能够帮助你在未来的开发工作中减少不必要的麻烦。然而，安装与配置仅仅是迈出了使用MySQL的第一步。真正的工作是如何高效地与数据库交互，并对数据进行增删改查。这时候就需要借助强大的MySQL客户端工具。
滚雪球学MySQL[3.3讲]：MySQL复杂查询详解：CASE语句、自连接与视图管理
**My Coding Family**
10-01 1190
在上一期的学习中，我们详细讲解了MySQL中的聚合函数与分组操作（3.2），包括使用COUNTSUMAVG等聚合函数对数据进行统计，并通过GROUP BY进行分组，结合HAVING进一步对聚合后的结果进行筛选。这些操作是数据统计与分析的重要工具，尤其在处理大规模数据时，能够帮助我们轻松生成有用的报告和结果。本期内容将带你进入MySQL的复杂查询（3.3）领域。相比基本的SELECT语句，复杂查询可以在更灵活的场景中应用，处理更复杂的业务逻辑和数据需求。我们将深入探讨CASE。
AbstractRoutingDataSource+Mybatis拦截器实现动态切换数据源代码
05-20
下面是使用 AbstractRoutingDataSource 和 MyBatis 拦截器实现动态切换数据源的示例代码： 首先，需要自定义一个继承 AbstractRoutingDataSource 的类，并实现 determineCurrentLookupKey 方法，该方法用于返回当前数据源的 key： ```java public class DynamicDataSource extends AbstractRoutingDataSource { private static final ThreadLocal<String> dataSourceKey = new InheritableThreadLocal<>(); public static void setDataSourceKey(String key) { dataSourceKey.set(key); } @Override protected Object determineCurrentLookupKey() { return dataSourceKey.get(); } } ``` 在 Spring 配置文件中需要配置两个数据源，并将 DynamicDataSource 设置为默认数据源： ```xml <bean id="dataSource1" class="org.apache.commons.dbcp2.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/db1"/> <property name="username" value="root"/> <property name="password" value="123456"/> </bean> <bean id="dataSource2" class="org.apache.commons.dbcp2.BasicDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/db2"/> <property name="username" value="root"/> <property name="password" value="123456"/> </bean> <bean id="dynamicDataSource" class="com.example.DynamicDataSource"> <property name="defaultTargetDataSource" ref="dataSource1"/> <property name="targetDataSources"> <map> <entry key="db1" value-ref="dataSource1"/> <entry key="db2" value-ref="dataSource2"/> </map> </property> </bean> ``` 接下来，需要实现一个继承于 MyBatis 的 Interceptor 接口的拦截器类，该类用于在执行 SQL 语句前切换数据源： ```java @Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})}) public class DynamicDataSourceInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { StatementHandler statementHandler = (StatementHandler) invocation.getTarget(); MetaObject metaObject = SystemMetaObject.forObject(statementHandler); MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement"); String dataSourceKey = getDataSourceKey(mappedStatement); if (dataSourceKey != null) { DynamicDataSource.setDataSourceKey(dataSourceKey); } return invocation.proceed(); } private String getDataSourceKey(MappedStatement mappedStatement) { String dataSourceKey = null; // 从 Mapper 方法上获取数据源 key if (mappedStatement != null) { String id = mappedStatement.getId(); if (id.startsWith("com.example.mapper1")) { dataSourceKey = "db1"; } else if (id.startsWith("com.example.mapper2")) { dataSourceKey = "db2"; } } return dataSourceKey; } @Override public Object plugin(Object target) { return Plugin.wrap(target, this); } @Override public void setProperties(Properties properties) { // do nothing } } ``` 最后，需要在 Spring 配置文件中配置该拦截器： ```xml <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dynamicDataSource"/> <property name="plugins"> <array> <bean class="com.example.DynamicDataSourceInterceptor"/> </array> </property> </bean> ``` 这样，就可以在 Mapper 方法上使用 @DataSource("db1") 或 @DataSource("db2") 注解来指定使用哪个数据源了。例如： ```java @DataSource("db1") List<User> getUserList(); @DataSource("db2") int addUser(User user); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值