Spring多数据源事务管理

最新推荐文章于 2024-05-08 09:01:02 发布

bug猫

最新推荐文章于 2024-05-08 09:01:02 发布

阅读量9.2k

点赞数 7

分类专栏： java

本文链接：https://blog.csdn.net/qq_41399429/article/details/87452548

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

大家好，我是入错行的bug猫。（http://blog.csdn.net/qq_41399429，谢绝转载）

在Springmvc、Springboot中配置多个数据源，相信各位老师，都司空见惯、手到擒来、炒鸡煎蛋了！ ᕙ( * •̀ ᗜ •́ * )ᕗ

但是，数据源one和数据源two，需要处于同一个事务，要肿么办？

就是A数据库对应数据源one，B数据库对应数据源two，改了A库一张表数据，同时改B库另外一张表，两个事件，要在同一个事务中执行，要如何处理？

(￣▽￣)ノ：先森，藕知道，用分布式事务！

( •̀_•́ ) 凸：秀儿，先坐下！

如果系统本身就是分布式应用，使用使用分布式事务，无可厚非，用就用呗。

但是，如果只是一个普通的单机应用，先别说能不能驾驭得住分布式事务，用起来感觉就像是坦克拖着板车，庭院的花盆里长了点杂草，却弄了一辆无人机来洒农药！ 0v0
问题的确能解决，但是，太重了。

咱们聊聊单机应用中，如何方便、快捷、轻量级的让多个数据源在同一个事务中

以SpringMVC为例，先看看数据源、事务的配置


    <bean id="onedataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
		<!-- one的数据库配置，获得one数据源 -->
	</bean>

	<!-- 通过数据源，得到数据库会话工厂 -->
	<bean id="onesqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="onedataSource" />
		<property name="mapperLocations" value="classpath:mysql/one/*.xml"></property>
		<property name="configLocation" value="classpath:mybatis-config.xml" />
	</bean>
	
	<!-- DAO接口所在包名，Spring会自动查找其下的类 -->
	<bean id="oneconfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.bugcat.nobug.one.dao" />
		<property name="sqlSessionFactoryBeanName" value="onesqlSessionFactory"></property>
	</bean>

	<!-- 事务管理 -->
	<bean id="onetx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="oneconfigurer" />
	</bean>

	
	
	<!-- 使用注解开启事务，事务管理器为 onetx -->
    <tx:annotation-driven transaction-manager="onetx" proxy-target-class="true" />
	
	
	
	<!--                         第二个数据源配置                      -->
	
	
    <bean id="twodataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <!-- two的数据库配置，获得two数据源 -->
    </bean>
	
    <bean id="twosqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="twodataSource" />
        <property name="mapperLocations" value="classpath:mysql/two/*.xml"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml" />
    </bean>

    <bean id="twoconfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.bugcat.nobug.two.dao" />
        <property name="sqlSessionFactoryBeanName" value="twosqlSessionFactory"></property>
    </bean>
	
    <bean id="twotx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="twoconfigurer" />
    </bean>

one数据源和two数据源，配置对仗得非常工整。就是one多了一个<tx:annotation-driven transaction-manager="onetx" proxy-target-class="true" />。画重点，在系统中使用@Transactional，默认对应的事务管理器是 onetx，数据源是 onedataSource！

two数据源也有事务管理器，只不过在使用@Transactional时，还必须指定value值。

不要把注解看得太神奇！千万别以为@xxxx是一种很高深的java语法，加了它之后可以做任何事！

~~bean拷贝，有2个属性名有点不一样，写个自定义注解上，咦？怎么不生效？！为母事不生效？？~~
~~当然不生效，因为注解是有了，但是，处理属性名的业务还没有呢，不告诉程序怎么处理，程序怎么知道要怎么处理？靠意识控制么…~~

所以，其实在Spring的jar包中，还有针对@Transactional注解，处理的业务逻辑代码。~~再次强调，不要以为@Transactional是一种语法、java关键词之类的东西~~ (ಥ_ಥ)
其实就是搞了一个切面，在方法执行前，开启事务；在方法执行后，提交事务；异常后，回滚事务

要保证数据源one与数据库two在同一个事务，可以理解成：事务管理器onetx开启事务，同时事务管理器twotx也开启事务；onetx提交，twotx也提交；onetx回滚了，twotx也跟着回滚！

(￣▽￣)ノ：先森，藕又知道了，这是要改transaction jar包源码的节奏？！

( •̀_•́ ) 凸：秀儿，你还是先坐下！

Spring为@Transactional做了一个切面，为毛我们不能为自定义的注解，也搞一个切面？

╭( ′• o •′ )╭☞ 这能叫抄袭么，程序猿的事，只能算借鉴…

这个切面需要做的事情：

接收需要组合在一起的数据源对应的事务管理器id
在执行业务方法之前，通过这些事务管理器，手动开启事务
执行业务方法
业务方法执行完毕之后，再使用这些事务管理器，手动提交事务
如果业务方法抛出异常：判断是否不需要回滚事务，如果不需要回滚，则提交事务；否则回滚

先来个自定义注解


import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 
 * 多数据源，组合事务
 * 
 * 
 * @author bugcat
 * */
@Target({ ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface TransactionalGroup {

    /**
     * 
     * 配置的事务id
     * 
     * 
     * <bean id="onetx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     *     <property name="dataSource" ref="onetxdataSource" />
     * </bean>
     * 
     * 
     * <p> 在方法上添加：@TransactionalGroup("onetx","twotx") </p>
     * 
     * */
    String[] value();




  	 /*******  以下参数，参见 @Transactional  ********/

    //事务传播行为
    Propagation propagation() default Propagation.REQUIRED;

	//事务隔离级别
    Isolation isolation() default Isolation.DEFAULT;

	// 哪些异常不会滚事务
    Class<? extends Throwable>[] noRollbackFor() default {};
    
}

自定义切面



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.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.NoTransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 切面
 * @author bugcat
 * */
@Aspect
@Component
public class Pointcuts {

    /**
     * 多数据源组合事务
     * 手动开启一个事物
     * */
    @Pointcut("@annotation(com.bugcat.nobug.annotation.TransactionalGroup)")
    public void transactionalGroupAspect() {};

    @Around(value = "transactionalGroupAspect()")
    public Object transactionalGroupAspectArround(ProceedingJoinPoint pjp) throws Throwable {
        
        Object obj = null;

        boolean doit = false;//是否执行了方法

        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method targetMethod = methodSignature.getMethod();

        List<TransactionParam> tsParams = null;

        TransactionalGroup groupAnn = targetMethod.getAnnotation(TransactionalGroup.class);
        if( groupAnn != null ){

            Isolation isolation = groupAnn.isolation();   //事务隔离级别
            Propagation propagation = groupAnn.propagation(); //传播行为

            String[] groups = groupAnn.value();
            if( groups.length > 0 ){
            
                doit = true;    //执行 pjp.proceed 的if分支
                
                Set<String> noRollbackForNameSet = new HashSet<>();
                Class<? extends Throwable>[] noRollbackFor = groupAnn.noRollbackFor();
                if( noRollbackFor != null && noRollbackFor.length > 0 ){
                    for ( Class<? extends Throwable> clazz : noRollbackFor ) {
                        noRollbackForNameSet.add(clazz.getSimpleName().toLowerCase());
                    }
                }



                tsParams = new ArrayList<>(groups.length);
                try {
                    for (String tx : groups ) {

                        TransactionParam tsParam = new TransactionParam();

                        //获取到事务服务类，SpringContextUtil 为Spring容器
                        tsParam.tm = SpringContextUtil.getBean(tx, DataSourceTransactionManager.class);

                        tsParam.def = new DefaultTransactionDefinition();
                        // 事物隔离级别
                        tsParam.def.setIsolationLevel(isolation.value());
                        // 事物传播行为
                        tsParam.def.setPropagationBehavior(propagation.value());

                        // 获得事务状态
                        tsParam.status = tsParam.tm.getTransaction(tsParam.def);

                        tsParams.add(tsParam);
                    }


                    obj = pjp.proceed();


                    //提交事务
                    for(TransactionParam tsParam : tsParams){
                        tsParam.tm.commit(tsParam.status);
                    }


                } catch ( Throwable e ) {

                    boolean rollback = true;//事务回滚

                    String errName = e.getClass().getName().toLowerCase();

                    if( "transactionexception".equals(errName) ){ // 这是sql异常，救不了了
                        rollback = true;
                    } else {
                        if( noRollbackForNameSet.contains(errName) ){ //发生异常，不回滚
                            rollback = false;
                        }
                    }

                    if( !rollback ){ //事务不回滚
                        try {

                            for(TransactionParam tsParam : tsParams){
                                tsParam.tm.commit(tsParam.status);
                            }
                            throw e;   //但是还是要抛出异常
                            // end


                        } catch ( org.springframework.transaction.TransactionException e1 ) {//如果这步还出现sql异常，只能回滚事务了
                            e1.printStackTrace();
                        }

                    }

                    //事务回滚
                    for(TransactionParam tsParam : tsParams){
                        tsParam.tm.rollback(tsParam.status);
                    }
                    throw e;
                }
            }
        }
        
        if( !doit ){
            obj = pjp.proceed();
        }

        return obj;
    }
    
    
    
}


class TransactionParam{
    //事务服务类
    DataSourceTransactionManager tm;
    //默认事务对象
    DefaultTransactionDefinition def;
    //事务状态
    TransactionStatus status;
}

最后的呆毛


    @TransactionalGroup({"onetx", "twotx"})
    public void save(Demo demo) {
        oneDemoDao.updateById(demo);
        twoDemoDao.updateById(demo);
    }

注意，如果@TransactionalGroup中包含了默认事务处理器的id，那么在业务方法上、业务方法类上，千万别再加@Transactional注解了！！！

(￣▽￣)ノ：先森，介个藕知道，@TransactionalGroup的切面中，通过事务管理器id=“onetx”，获取到数据源one的事务管理器，手动开启了它的事务。如果再在方法上添加@Transactional，会导致Spring又会开启一个事务！

(￣ε(#￣)☆o=(-`д´- ｡) ：就你话多！

~~于是一个mini版的组合事务搞定了，可喜可贺可喜可贺~~

bug猫

关注

7
点赞
踩
39

收藏

觉得还不错? 一键收藏
22
评论
Spring多数据源事务管理

大家好，我是入错行的bug猫。（http://blog.csdn.net/qq_41399429，谢绝转载）在Springmvc、Springboot中配置多个数据源，相信各位老师，都司空见惯、手到擒来、炒鸡煎蛋了！ ᕙ( * •̀ ᗜ •́ * )ᕗ但是，数据源one和数据源two，需要处于同一个事务，要肿么办？就是A数据库对应数据源one，B数据库对应数据源two，改了A库一张表数据...
复制链接

扫一扫