整体流程

在了解Seata整体运行流程时，需要梳理一下AT模式下分布式事务直接整个数据是怎么流转的。可以参照官网上的两段提交，大致流程如下：

Seata事务使用的是全局事务注解作为开始，在service上面添加@GlobalTransactional注解即可达到开启分布式事务的目的。

代码分析

启动类

很显然是通过AOP切面代理，识别注解。进行织入，填充对应的业务逻辑。我们可以从starter入手，启动Jar包是io.seata:seata-spring-boot-starter:1.6.0。再找到spring.factories文件。

很容易找到SeataAutoConfiguration就是我们要找的配置类。配置类主要功能就是构造了一个scanner。

找到wrapIfNecessary方法，可以看到具体的拦截和切面织入的操作。

if (!existsAnnotation(new Class[]{serviceInterface})
    && !existsAnnotation(interfacesIfJdk)) {
    return bean;
}

判断类和方法上是否有GlobalTransaction和GlobalLock注解。增强类为GlobalTransactionalInterceptor。

设置全局事务拦截器，如果没有的话就初始话一个拦截器。

切面织入操作

AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));
int pos;
for (Advisor avr : advisor) {
    // Find the position based on the advisor's order, and add to advisors by pos
    pos = findAddSeataAdvisorPosition(advised, avr);
    advised.addAdvisor(pos, avr);
}

其中getAdvicesAndAdvisorsForBean我们就可以知道实际织入的切面类就是上一步定义的全局事务拦截器。

至此，整个织入，加载过程完成。

能力依赖

整个构造都是通过集成AbstractAutoProxyCreator类进行的织入。seata中的很多类都是采用这种方式来进行拦截，写入业务逻辑。

XID生成和传输

xid是贯穿整个分布式事务中的一个重要链条，用来判断是否该线程处于全局事务，是否对提交进行一阶段提交，异常回滚等操作的唯一依据。

我们还是GlobalTransactionalInterceptor为切入点。核心处理逻辑在invoke方法上。

public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
        Class<?> targetClass =
            methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;
        Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
        if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
            final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);
            final GlobalTransactional globalTransactionalAnnotation =
                getAnnotation(method, targetClass, GlobalTransactional.class);
            final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);
            boolean localDisable = disable || (ATOMIC_DEGRADE_CHECK.get() && degradeNum >= degradeCheckAllowTimes);
            if (!localDisable) {
                if (globalTransactionalAnnotation != null || this.aspectTransactional != null) {
                    AspectTransactional transactional;
                    if (globalTransactionalAnnotation != null) {
                        transactional = new AspectTransactional(globalTransactionalAnnotation.timeoutMills(),
                            globalTransactionalAnnotation.name(), globalTransactionalAnnotation.rollbackFor(),
                            globalTransactionalAnnotation.rollbackForClassName(),
                            globalTransactionalAnnotation.noRollbackFor(),
                            globalTransactionalAnnotation.noRollbackForClassName(),
                            globalTransactionalAnnotation.propagation(),
                            globalTransactionalAnnotation.lockRetryInterval(),
                            globalTransactionalAnnotation.lockRetryTimes(),
                            globalTransactionalAnnotation.lockStrategyMode());
                    } else {
                        transactional = this.aspectTransactional;
                    }
                    return handleGlobalTransaction(methodInvocation, transactional);
                } else if (globalLockAnnotation != null) {
                    return handleGlobalLock(methodInvocation, globalLockAnnotation);
                }
            }
        }
        return methodInvocation.proceed();
    }