seata注解@GlobalTransactional原理探究

最新推荐文章于 2025-04-30 21:31:51 发布

新world

最新推荐文章于 2025-04-30 21:31:51 发布

阅读量2.1k

点赞数 6

CC 4.0 BY-SA版权

分类专栏： seata 文章标签： java 分布式

本文链接：https://blog.csdn.net/qq_38685072/article/details/137788607

seata 专栏收录该内容

4 篇文章

订阅专栏

本文详细解析了Seata中`@GlobalTransactional`注解的工作原理，涉及AOP、Spring.factories中的配置、GlobalTransactionScanner类的wrapIfNecessary方法，以及TransactionalTemplate在事务执行中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

今天分析一下seata中怎么通过一个@GlobalTransactional注解实现全局事务的, 其实大家应该也能猜到是基于AOP, 在开发中当需要配合注解的时候我们往往想到的就是AOP

说明

我使用的seata版本是1.3.0版本(有点古老啊), 大家在查看对应源码的时候如果有出入, 不要慌, 有点细节的变化是正常的, 主流程基本不变

开始分析

摆在面前的还是那个恒久不变的问题, 从哪开始分析呢?

我们先看一下@GlobalTransactional注解所在的依赖包是哪个? 是在seata-spring-boot-starter依赖包中

对于starter结尾的包大家也应该不陌生吧, 这些starter都有一样的套路: 让我们直接聚焦到META-INF/spring.factories文件, 如下图所示:
在这里插入图片描述

从图中我们可以看出, 在spring.factories中指定了一个自动装配的默认配置SeataAutoConfiguration, 接下来我们看一下这个配置类

在下面的图里, 我把其他的忽略了, 只截取了相关的一个Bean, 从名称中也可以看出来他肯定和全局事务有点关系
在这里插入图片描述

点进去GlobalTransactionScanner这个类, 我们可以看到它继承了AbstractAutoProxyCreator这个类, 熟悉AOP的同学肯定对这个类不陌生吧(如果是对AOP不熟悉的, 可以查一下这个类的作用)
在这里插入图片描述

既然继承了AbstractAutoProxyCreator这个类, 那么最重要的方法要属wrapIfNecessary方法了, 这个方法的作用是对bean进行包装, 也就是代理这个bean, 下面是这个方法的代码分析

@Override
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 如果设置了禁用全局事务, 直接返回该bean, 不代理
    if (disableGlobalTransaction) {
        return bean;
    }
    try {
        // PROXYED_SET存储已经代理过的bean
        synchronized (PROXYED_SET) {
            // 如果已经代理过了, 直接返回该bean
            if (PROXYED_SET.contains(beanName)) {
                return bean;
            }
            interceptor = null;
            // 这个分支是TCC相关的, 暂时忽略
            if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, applicationContext)) {
                //TCC interceptor, proxy bean of sofa:reference/dubbo:reference, and LocalTCC
                interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));
            } 
            // 这个是本次的主要关注点
            else {
                // 获取bean的目标类
                Class<?> serviceInterface = SpringProxyUtils.findTargetClass(bean);
                // 获取bean目标类的接口信息, 如果不是JDK代理的形式返回空
                Class<?>[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);

                // 如果该类以及该类的接口中都不存在@GlobalTransactional注解, 直接返回bean
                if (!existsAnnotation(new Class[]{serviceInterface})
                    && !existsAnnotation(interfacesIfJdk)) {
                    return bean;
                }
                
                // 由于忽略了上面的TCC模式, 所以这里interceptor为null
                if (interceptor == null) {
                    if (globalTransactionalInterceptor == null) {
                        globalTransactionalInterceptor = new GlobalTransactionalInterceptor(failureHandlerHook);
                        ConfigurationCache.addConfigListener(
                            ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,
                            (ConfigurationChangeListener)globalTransactionalInterceptor);
                    }
                    // 将interceptor设置为globalTransactionalInterceptor
                    interceptor = globalTransactionalInterceptor;
                }
            }

            LOGGER.info("Bean[{}] with name [{}] would use interceptor [{}]", bean.getClass().getName(), beanName, interceptor.getClass().getName());
            // 如果不是代理bean, 则需要调用父类的wrapIfNecessary方法
            if (!AopUtils.isAopProxy(bean)) {
                bean = super.wrapIfNecessary(bean, beanName, cacheKey);
            } 
            // 如果已经是代理类, 将上面的Interceptor加入到Advisor[]中; 
            // 补充一句这里的Advisor类里面包含AOP的Advise(通知), 其实就是把Interceptor加入通知集合里面
            else {
                AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
                Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));
                for (Advisor avr : advisor) {
                    advised.addAdvisor(0, avr);
                }
            }
            // 已经代理过的加入到PROXYED_SET中
            PROXYED_SET.add(beanName);
            return bean;
        }
    } catch (Exception exx) {
        throw new RuntimeException(exx);
    }
}

通过上面的代码我们知道了:

Interceptor就是Advice, 也就是大家经常用到的通知, 只不过并不是完全一样, 功能上可以理解为是相同的东西
这里的Interceptor用到的是GlobalTransactionInterceptor

接下来, 我们看一下GlobalTransactionalInterceptor的实现, 这里主要看invoke方法就行了

@Override
public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
    // 获取代理对象目标类
    Class<?> targetClass =
        methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;
    // 获取方法, 不要诧异, 这里获取方法是为了应对java多态机制的重载, 通过方法参数类型找到最匹配的那一个
    Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
    // 判断不是Object类的方法
    if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
        // 查找提供桥接方法的原始方法 (关于什么是桥接方法,可以自己搜一下,这里就不展开了,只是为了阅读的完整性加下注释)
        final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);
        // 获取@GlobalTransactional注释
        final GlobalTransactional globalTransactionalAnnotation =
            getAnnotation(method, targetClass, GlobalTransactional.class);
        // 获取@GlobalLock注释
        final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);
        // 判断是否禁用全局事务或者启动了降级
        boolean localDisable = disable || (degradeCheck && degradeNum >= degradeCheckAllowTimes);
        if (!localDisable) {
            if (globalTransactionalAnnotation != null) {
                // 处理@GlobalTransactional注解相关的业务流程
                return handleGlobalTransaction(methodInvocation, globalTransactionalAnnotation);
            } else if (globalLockAnnotation != null) {
                return handleGlobalLock(methodInvocation);
            }
        }
    }
    return methodInvocation.proceed();
}

GlobalTransactionalInterceptor的invoke方法主要是提取除了类和方法中的@GlobalTransactional注解信息, 最终又调用了handleGlobalTransaction方法, 接着看下handleGlobalTransaction方法, 方法将全局事务的执行委托给了另一个类TransactionalTemplate, 这个类大家一看就知道用到了模版模式吧(对设计模式有困惑的可以看下我另一篇博客奥)

private Object handleGlobalTransaction(final MethodInvocation methodInvocation,
                                       final GlobalTransactional globalTrxAnno) throws Throwable {
    boolean succeed = true;
    try {
        // 调用TransactionalTemplate的execute方法
        return transactionalTemplate.execute(new TransactionalExecutor() {
           // 省略...
        });
    } catch (TransactionalExecutor.ExecutionException e) {
        // 省略...
    } finally {
        // 省略...
    }
}

继续看TransactionalTemplate的execute方法

public Object execute(TransactionalExecutor business) throws Throwable {
    // 获取TransactionInfo, 这个是在调用方法的时候通过匿名内部类构建的
    TransactionInfo txInfo = business.getTransactionInfo();
    if (txInfo == null) {
        throw new ShouldNeverHappenException("transactionInfo does not exist");
    }
    // 获取或者创建一个GlobalTransaction对象
    GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate();

    // 处理事务传播机制和分支类型
    Propagation propagation = txInfo.getPropagation();
    SuspendedResourcesHolder suspendedResourcesHolder = null;
    try {
        // 下面几个是对不同传播机制的处理
        switch (propagation) {
            // 如果当前存在事务, 挂起事务, 以非事务方式执行
            case NOT_SUPPORTED:
                suspendedResourcesHolder = tx.suspend(true);
                return business.execute();
            // 必须弄一个新的事务, 老的事务挂起
            case REQUIRES_NEW:
                suspendedResourcesHolder = tx.suspend(true);
                break;
            // 如果当前不存在事务, 以非事务方式执行
            case SUPPORTS:
                if (!existingTransaction()) {
                    return business.execute();
                }
                break;
            // 支持事务
            case REQUIRED:
                break;
            // 如果已经存在事务, 抛出异常, 否则以非事务方式执行
            case NEVER:
                if (existingTransaction()) {
                    throw new TransactionException(
                        String.format("Existing transaction found for transaction marked with propagation 'never',xid = %s"
                                      ,RootContext.getXID()));
                } else {
                    return business.execute();
                }
            // 如果当前不存在事务, 抛出异常    
            case MANDATORY:
                if (!existingTransaction()) {
                    throw new TransactionException("No existing transaction found for transaction marked with propagation 'mandatory'");
                }
                break;
            default:
                throw new TransactionException("Not Supported Propagation:" + propagation);
        }


        try {

            // 开始事务
            beginTransaction(txInfo, tx);

            Object rs = null;
            try {

                // 执行业务代码
                rs = business.execute();

            } catch (Throwable ex) {

                // 判断异常是否需要回滚, 不回滚就提交
                completeTransactionAfterThrowing(txInfo, tx, ex);
                throw ex;
            }

            // 提交事务
            commitTransaction(tx);

            return rs;
        } finally {
            // 触发完成后的钩子函数
            triggerAfterCompletion();
            // 触发完了之后将注册的钩子函数清空, 因为是在ThreadLocal中的, 不清理不太行啊
            cleanUp();
        }
    } finally {
        // 把那些挂起的事务恢复一下
        tx.resume(suspendedResourcesHolder);
    }

}