Spring主从数据源动态切换

最新推荐文章于 2022-09-17 21:27:25 发布
最新推荐文章于 2022-09-17 21:27:25 发布
阅读量162 收藏
点赞数
分类专栏： 系统实现 文章标签： spring aop 多数据源 主从 master/slave
参考文档：
 
我们的需求达到的目标和现有的条件:
 
  • 不同类型数据源都可能存在master和slave区分；
  • 数据源之间已经可以通过package区分，不同package对应的service也不同；
  • aop在service层面，对应不同数据源的service之间可能存在互相调用；
  • 最外层方法的名称决定了该数据源应该使用master（可写）还是slave数据源（不可写）；
  • 在嵌套使用其他service的过程中，根据情况分析该service方法是否使用slave数据源；
 
我们在spring中的配置文件中使用了切面式的配置来定义声明式事务：
  
<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="create*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="merge*" propagation="REQUIRED"/>
            <tx:method name="del*" propagation="REQUIRED"/>
            <tx:method name="remove*" propagation="REQUIRED"/>
            <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到 -->
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="count*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="list*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 只对业务逻辑层实施事务 -->
    <aop:config expose-proxy="true">
        <aop:pointcut id="txPointcut" expression="(execution(* com.api.example.*.*.service..*.*(..)))
            or (execution(* com.api.example.*.service..*.*(..)))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
 
 
在aop:config中，只对业务逻辑层实施事务管理，此时需要定义pointCut：用于确定实行动态织入用到的方法条件，和advisor：用于确定方法中使用到的事务管理器，事务管理器中定义了各种类型方法前缀所定义的事务范围和传播属性。
 
我们的数据源需要动态定义，需要在事务开启之前，切入数据源去选择该方法执行过程到底是该使用读库还是写库来开启该事务，因此这个切面需要在org.springframework.transaction.interceptor.TransactionInterceptor之前就要起作用。
 
 

实现方案

 
完成的整体类图如下：
 


 
 
从AbstractDataSource中继承，增加写库以及多个从库，以便于在spring配置文件中能够配置该数据源，由于需要支持多个数据源的master/slave主从库配置，所以MasterSlaveDataSourceDecision中不能简单地定义静态ThreadLocal变量来维持当前事务状态，而且每个TransactionManager都需要定义对应的数据源决策类。
  
public class MasterSlaveDataSource extends AbstractDataSource implements InitializingBean {

    private static final Logger log = LoggerFactory.getLogger(MasterSlaveDataSource.class);

    private DataSource masterDataSource;
    private Map<String, DataSource> slaveDataSourceMap;
 
 
重写其中的getConnection()方法：
 
  
@Override
    public Connection getConnection() throws SQLException {
        return determineDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return determineDataSource().getConnection(username, password);
    }
 
通过determineDataSource()方法来决定使用写库还是从库，对于多个从库来说，可以采用其他算法来支持，也可以根据线程ID，让同一个线程能够使用同一从库（当前实现并没有这么做）：
  
public DataSource determineDataSource() {
        if (masterSlaveDataSourceDecision.isChoiceWrite()) {
            log.debug("current determine write datasource");
            return masterDataSource;
        } else if (masterSlaveDataSourceDecision.isChoiceNone()) {
            log.debug("no choice read/write, default determine write datasource");
            return masterDataSource;
        } else {
            return selectReadDataSource();
        }
    }
 
 
定义切换数据源使用到的切面方法，当进行到需要启动事务的方法时，根据需要选择。我们一般会定义一个txAdvice，用于声明式事务的传播属性以及readonly属性，如果我们需要使用到该属性，需要利用spring的Bean加载完成通知，实现BeanPostProcessor接口中的postProcessAfterInitialization方法
  
public class MasterSlaveDataSourceProcessor implements BeanPostProcessor {

    private Map<String, Boolean> readWriteMethodMap = new HashMap<String, Boolean>();
private String txAdviceName;
    private MasterSlaveDataSourceDecision masterSlaveDataSourceDecision;

    public void setTxAdviceName(String txAdviceName) {
        this.txAdviceName = txAdviceName;
    }

    public void setMasterSlaveDataSourceDecision(MasterSlaveDataSourceDecision masterSlaveDataSourceDecision) {
        this.masterSlaveDataSourceDecision = masterSlaveDataSourceDecision;
    }

@Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (txAdviceName.equalsIgnoreCase(beanName)) {
            try {
                TransactionInterceptor transactionInterceptor = (TransactionInterceptor) bean;
                NameMatchTransactionAttributeSource transactionAttributeSource =
                        (NameMatchTransactionAttributeSource) transactionInterceptor.getTransactionAttributeSource();
                Field nameMapField = ReflectionUtils.findField(NameMatchTransactionAttributeSource.class, "nameMap");
                nameMapField.setAccessible(true);
                Map<String, TransactionAttribute> nameMap = (Map<String, TransactionAttribute>) nameMapField
                        .get(transactionAttributeSource);

                for (Entry<String, TransactionAttribute> entry : nameMap.entrySet()) {
                    RuleBasedTransactionAttribute attr = (RuleBasedTransactionAttribute) entry.getValue();
                    // 仅对read-only的处理
                    String methodName = entry.getKey();
                    if (attr.isReadOnly()) {
                        if (forceChoiceReadWhenWrite) {
                            // 不管之前操作是写，默认强制从读库读 （设置为NOT_SUPPORTED即可）
                            // NOT_SUPPORTED会挂起之前的事务
                            attr.setPropagationBehavior(Propagation.NOT_SUPPORTED.value());
                        } else {
                            // 否则 设置为SUPPORTS（这样可以参与到写事务）
                            attr.setPropagationBehavior(Propagation.SUPPORTS.value());
                        }
                    }

                    log.info("read/write transaction process  method:{} force read:{}", methodName,
                            forceChoiceReadWhenWrite);
                    readWriteMethodMap.put(methodName, attr.isReadOnly());
                }

            } catch (Exception e) {
                throw new ReadWriteDataSourceTransactionException("process read/write transaction error", e); 
            }

        }
        return bean;
    }
 
 
由于我们的环境中允许存在多个数据源的主从库设置，也存在多个事务管理器，当然也会有多个txAdvice，这里在其中设置一个属性txAdvice名称，每个不同数据源的MasterSlaveDataSourceProcessor监听不同的txAdvice。
 
我们将其中的tx method属性分成两种类型，一种为只读（从库），一种为写（写库），将其放置到对应的readWriteMethodMap中，
  
<tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="create*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="merge*" propagation="REQUIRED"/>
            <tx:method name="del*" propagation="REQUIRED"/>
            <tx:method name="remove*" propagation="REQUIRED"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="count*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="list*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
 
 
根据切面的方法名称，以及刚才获得的readWriteMethodMap，来确定该方法是否可以读从库来减轻压力：
 
     
public Object selectDataSource(ProceedingJoinPoint pjp) throws Throwable {
        if (isChoiceReadDB(pjp.getSignature().getName())) {
            masterSlaveDataSourceDecision.markRead();
        } else {
            masterSlaveDataSourceDecision.markWrite();
        }
        try {
            return pjp.proceed();
        } catch (Throwable t) {
            masterSlaveDataSourceDecision.reset();
            throw t;
        } finally {
            masterSlaveDataSourceDecision.pop();
        }

    }
 
spring可以通过内置的PatternMatchUtils工具类，来进行简单匹配工作，实现最长路径匹配，找到最合适的matchName（该代码是从NameMatchTransactionAttributeSource.getTransactionAttribute()中获得）。
  
private boolean isChoiceReadDB(String methodName) {

        String bestNameMatch = null;
        for (String mappedName : this.readWriteMethodMap.keySet()) {
            if (PatternMatchUtils.simpleMatch(mappedName, methodName)&&
                    (bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) {
                bestNameMatch = mappedName;
            }
        }
        // 默认走写库
        boolean currentRead = (bestNameMatch == null ? false : readWriteMethodMap.get(bestNameMatch)); 
        // 如果当前为读库,并且设置了强制读,则忽略当前主库写状态
        if (currentRead && forceChoiceReadWhenWrite) {
            return true;
        }
        // 如果之前选择了写库,则当前使用写库
        if (masterSlaveDataSourceDecision.isChoiceWrite()) {
            return false;
        }
        return currentRead;
    }
 
 
由于需要支持service方法之间的嵌套操作，MasterSlaveDataSourceDecision需要使用ThreadLocal<Stack>的方法保存当前上下文对应的数据源配置：
  
public class MasterSlaveDataSourceDecision {

    public enum DataSourceType {
        write, read;
    }

    private final ThreadLocal<Stack<DataSourceType>> holder = new ThreadLocal<Stack<DataSourceType>>() {
        @Override
        protected Stack<DataSourceType> initialValue() {
            return new Stack<>();
        }
    };

    public void markWrite() {
        holder.get().push(DataSourceType.write);
    }

    public void markRead() {
        holder.get().push(DataSourceType.read);
    }

    public void reset() {
        holder.get().clear();
    }

    public boolean isChoiceNone() {
        return holder.get().isEmpty();
    }

    public boolean isChoiceWrite() {
        return !isChoiceNone() && DataSourceType.write == holder.get().peek();
    }

    public boolean isChoiceRead() {
        return !isChoiceNone() && DataSourceType.read == holder.get().peek();
    }

    public DataSourceType pop() {
        return isChoiceNone() ? null : holder.get().pop();
    }
}
 
 

配置方法

 
数据源定义应该使用我们定义的主从DataSource，其中包含了写库以及从库的相关配置：
  
<bean id="masterSlaveDataSource" class="com.api.example.tx.MasterSlaveDataSource">
        <property name="masterSlaveDataSourceDecision" ref="masterSlaveDataSourceDecision"/>
        <property name="masterDataSource" ref="dataSource"/>
        <property name="slaveDataSourceMap">
            <map><entry key="slave1" value-ref="dataSourceSlave"/></map>
        </property>
    </bean>
 
 
定义transactionManager使用该数据源：
  
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="masterSlaveDataSource"/>
    </bean>
 
定义txAdvice，关联该transactionManager，并定义事务的传播属性，以及readOnly属性
  
<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="create*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="merge*" propagation="REQUIRED"/>
            <tx:method name="del*" propagation="REQUIRED"/>
            <tx:method name="remove*" propagation="REQUIRED"/>
            <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到 -->
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="count*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="list*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
 
 
定义对应的aop config，使用aop:aspect，注意要设置order，保证该interceptor在事务启动之前能够选择到对应的dataSource，
  
    <!-- 只对业务逻辑层实施事务 -->
    <aop:config expose-proxy="true">
        <aop:pointcut id="txPointcut" expression="execution(* com.api.example.service..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

        <aop:aspect order="-1" ref="masterSlaveDataSourceProcessor">
            <aop:around method="selectDataSource" pointcut-ref="txPointcut"/>
        </aop:aspect>
    </aop:config>
 
 
加入Processor，以及decision，注意DataSourceProcessor需要关联对应的decision类，以及txAdvice名称（其id名称），以保证Processor会在对应的txAdvice加载完成后使用其定义的txAttributes属性信息，用于判断该事务的方法是否读主库，或从库。
  
    <bean id="masterSlaveDataSourceProcessor" class="com.api.example.tx.MasterSlaveDataSourceProcessor">
        <property name="txAdviceName" value="txAdvice"/>
        <property name="masterSlaveDataSourceDecision" ref="masterSlaveDataSourceDecision"/>
    </bean>

    <bean id="masterSlaveDataSourceDecision" class="com.api.example.tx.MasterSlaveDataSourceDecision"/>
 
 
此外com.api.example.tx.MasterSlaveDataSourceProcessor中forceChoiceReadWhenWrite属性用于控制该执行该方法时，是否需要强制读操作（如果存在嵌套事务，将当前事务挂起）。
 
经过测试，可以满足我们的需求，达到根据service包中方法名称动态切换主从数据源的目的。
 
 
 
 
 
 
clamaa
关注
专栏目录
java mysql主从切换_动态切换主从数据源，实现读写分离最后一步！
weixin_33218578的博客
02-16 1133
前言:前篇已经搭好mysql主从实例及配置好主从复制功能。这篇实现应用层动态切换数据源，完成读写分离功能最后一步。首先大概介绍步骤：1.已经有了单数据库的ssh应用，并且正常启动使用着。到这里的配置就不写了。2.改造：配置主从数据库的properties参数3.xml配置多个数据源，并关联到sqlSessionFactory4.实现AbstractRoutingDataSource类的determ...
Spring主从数据库的配置和动态数据源切换原理
葵续浅笑的博客
03-06 1148
在大型应用程序中，配置主从数据库并使用读写分离是常见的设计模式。在Spring应用程序中，要实现读写分离，最好不要对现有代码进行改动，而是在底层透明地支持。 Spring内置了一个AbstractRoutingDataSource，它可以把多个数据源配置成一个Map，然后，根据不同的key返回不同的数据源。因为AbstractRoutingDataSource也是一个DataSource接口，因此，应用程序可以先设置好key， 访问数据库的代码就可以从AbstractRoutingDataSource拿到对
Sharding-JDBC读写分离DataSour生成解析
qq_53318060的博客
07-20 715
读写分离DataSource解析
SpringBoot集成ShardingJDBC系列【4】—— 集成多数据源动态切换
Klayt的博客
09-04 5822
文章只负责讲解sharding的相关配置，springboot其他的配置自己解决！！ 文章内容将分开发布，便于平时查阅。 集成多数据源动态切换 为什么有了sharding还要配置多数据源？ 根据之前SpringBoot集成ShardingJDBC系列【2】—— 基于yaml基本配置这篇文章中提到过这个问题，对于只有部分数据库分库分表，为什么需要将不分库分表的表也配置在分片规则中。 因为ShardingSphere是将多个数据源合并为一个统一的逻辑数据源。因此即使不分库分表的部分，不配置分片规则Sh.
springboot实现主从数据库动态切换（注解式）
S mile0804的博客
09-08 2913
Overridelogger.info("使用数据源：{}", dataSource);}}重写 determineCurrentLookupKey方法，返回要使用的数据源key值。以上两个类解决了动态数据源key值的问题，下面处理初始化targetDataSources对象。
Spring Boot + MyBatis-Plus 实现 MySQL 主从复制动态数据源切换
最新发布
08-20
Spring Boot + MyBatis-Plus 实现 MySQL 主从复制动态数据源切换
spring mybatis 多数据源动态切换
08-25
在 `thc-datasources` 压缩包中，可能包含了更详细的配置示例、数据源切换注解的实现以及相关的辅助工具类，如 `DynamicDataSourceContextHolder`。读者可以结合这些资源，进一步理解和实践多数据源动态切换的实现。
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务
01-05
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务。一个基于springboot的快速集成多数据源的启动器。支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持数据库...
Springcloud 多数库 多数据源整合,查询动态切换数据库
07-22
创建一个自定义的数据源切换注解，比如`@SwitchDataSource`，并在需要切换数据源的方法上使用。通过AspectJ的切面处理，我们可以在方法执行前后动态改变ThreadLocal中的数据源引用。 3. **Spring Cloud Config ...
后台多数据源切换，master、slave、devops
qq_37575728的博客
09-24 1407
切换注解、默认为主库 @Target({ ElementType.METHOD, ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface DataSource { /** * 切换数据源名称 */ public DataSourceType value() default DataSourceType.MASTER; } 动态数据源
【mysql-6】mysql分库分表+读写分离（shardingJDBC）
growing_duck的博客
12-04 769
一：Sharding-JDBC 分库分表 1、Sharding-JDBC 是一款轻量级java框架，以jar形式提供服务，增强版JDBC。主要功能： 数据分片： 分库分表； 读写分离； 分片策略； 分布式主键 分布式事务： 标准化事务接口； XA强一致性事务； 柔性事务 数据库治理： 配置动态化； 编排治理； 数据脱敏； 可视化链路追踪 2、Sharding-JDBC内部结构： 黄色部分：Sharding-JDBC的入口API，采用工厂方法的形式提供。目前两个工厂类： Shar.
shardingsphere做了读写分离做了主从配置脱敏无效分析
笨小孩浅谈技术
09-17 1304
shardingsphere配置了主从读写分离导致脱敏配置失效
聊聊sharding-jdbc的MasterSlaveRouter
chuoguo3754的博客
08-04 1047
序 本文主要研究一下sharding-jdbc的MasterSlaveRouter MasterSlaveRouter incubator-shardingsphere-4.0.0-RC1/sharding-core/sharding-core-route/src/main/java/org/...
springboot系类代码：spring-boot-mybatis-sharding-jdbc-masterslave
BLOG域名:programb.blog.csdn.net
05-21 303
读写分离，就是将DML交给主数据库去执行，将更新结果同步至各个从数据库保持主从数据一致，DQL分发给从数据库去查询，从数据库只提供读取查询操作。读写分离特别适用于读多写少的场景下，通过分散读写到不同的数据库实例上来提高性能，缓解单机数据库的压力: Name Remark DQL 数据查询语言，比如select查询语句 DML 数据操纵语言，比如insert、delete、update更新语句 DDL 数据定义语言，比如create/drop/alter等语句 DCL 数据控制语言，比如grant/
spring-master-slave-commondao
java 学习路
07-19 361
互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。 为此，往往搭建 db的 一主多从库的 数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数...
《Netkiller Spring Cloud 手札》之 Master / Slave 主从数据库数据源配置
weixin_33898233的博客
04-22 344
2019独角兽企业重金招聘Python工程师标准>>> ...
spring读写分离 - 事务配置篇（转）
热门推荐
linminqin的专栏
10-12 1万+
转自：http://jinnianshilongnian.iteye.com/blog/1720618 如何配置mysql数据库的主从？ 单机配置mysql主从：http://my.oschina.net/god/blog/496   常见的解决数据库读写分离有两种方案 1、应用层 http://neoremind.net/2011/06/spring实现数据库读写分离
Spring项目中使用两种方法动态切换数据源，多数据源切换
bobozai86的博客
04-07 3064
本文介绍两种动态切换数据库的方法。 方法一：数据源信息配置在xml中，适用于一般数据库切换。执行完某操作，切换数据库，执行另一个操作。 方法二：数据源信息配置在默认数据源中，适用于切换数据库操作同一方法，相当于批量执行方法。 两种方法核心都是AbstractRoutingDataSource，由spring提供，用来动态切换数据源。我们需要继承它，来进行操作。源码分析可以看下一篇文章源码分析 ...
Spring Boot+Mybatis 实现主从数据源分离详细教程
在Spring Boot应用中集成Mybatis实现主从数据源分离，主要是为了提高系统的读写性能，将读操作分配到从库，写操作处理在主库，从而减轻主库的压力。以下是一些关键步骤和配置： 1. 项目结构与依赖：首先创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值