Spring TX 原理

调试环境：https://gitee.com/jhxxb/MySpringBoot/tree/master/spring-base/Spring-Transaction

源码

从 @EnableTransactionManagement 开始

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class) // 导入组件
public @interface EnableTransactionManagement {

    /**
     * 代理方式，CGLIB 动态代理和 JDK 动态代理
     */
    boolean proxyTargetClass() default false;

    /**
     * 代理方式：默认是 PROXY 采用 Spring 的动态代理（含 JDK 动态代理和 CGLIB 动态代理）
     * 若改为：AdviceMode.ASPECTJ 表示使用 AspectJ 静态代理方式。
     * 它能够解决同类内方法调用不走代理对象的问题，但是一般情况下都不建议这么去做，不要修改这个参数值
     */
    AdviceMode mode() default AdviceMode.PROXY;

    /**
     * 顺序，可能有多个 @EnableXXX
     */
    int order() default Ordered.LOWEST_PRECEDENCE;
}

TransactionManagementConfigurationSelector 的父类 AdviceModeImportSelector

可以看到还有 Cache 和 Async

public abstract class AdviceModeImportSelector<A extends Annotation> implements ImportSelector {
    /**
     * 默认都叫 mode
     */
    public static final String DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME = "mode";

    /**
     * 允许子类覆盖此方法
     */
    protected String getAdviceModeAttributeName() {
        return DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME;
    }

    /**
     * @param importingClassMetadata 注解的信息
     */
    @Override
    public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 这里泛型，拿到泛型类型
        Class<?> annType = GenericTypeResolver.resolveTypeArgument(getClass(), AdviceModeImportSelector.class);
        Assert.state(annType != null, "Unresolvable type argument for AdviceModeImportSelector");

        // 根据类型，拿到该类型的这个注解，然后转换为 AnnotationAttributes
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
        if (attributes == null) {
            throw new IllegalArgumentException(String.format("@%s is not present on importing class '%s' as expected", annType.getSimpleName(), importingClassMetadata.getClassName()));
        }

        // 拿到 AdviceMode，最终交给子类，让它自己去实现，决定导入哪个 Bean
        AdviceMode adviceMode = attributes.getEnum(getAdviceModeAttributeName());
        String[] imports = selectImports(adviceMode);
        if (imports == null) {
            throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
        }
        return imports;
    }

    /**
     * 子类去实现，具体导入哪个 Bean
     */
    @Nullable
    protected abstract String[] selectImports(AdviceMode adviceMode);
}

这里只看 TransactionManagementConfigurationSelector 实现

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
        // 绝大部分情况下都不会使用 AspectJ 的静态代理
        switch (adviceMode) {
            case PROXY:
                // 这里会导入两个类
                return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
            case ASPECTJ:
                return new String[]{determineTransactionAspectClass()};
            default:
                return null;
        }
    }

    private String determineTransactionAspectClass() {
        return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ?
                TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME : TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
    }
}

TransactionManagementConfigurationSelector 中导入的 AutoProxyRegistrar，主要是向 Spring 容器注入了一个自动代理创建器：org.springframework.aop.config.internalAutoProxyCreator，并且看看是采用 CGLIB 还是 JDK 代理。

跟踪 AopConfigUtils 的源码可以看到，事务这块向容器注入的是一个 InfrastructureAdvisorAutoProxyCreator，它主要是读取 Advisor 类。

/**
 * 实现了 ImportBeanDefinitionRegistrar 接口，可以向容器里注册 Bean 的定义信息
 */
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    private final Log logger = LogFactory.getLog(getClass());

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
        // 这里是拿到所有的注解类型，而不是只拿 @EnableAspectJAutoProxy 这个类型的
        // 原因：因为 mode、proxyTargetClass 等属性会直接影响到代理的方式，而拥有这些属性的注解至少有：
        // @EnableTransactionManagement、@EnableAsync、@EnableCaching 等
        // 甚至还有启用 AOP 的注解：@EnableAspectJAutoProxy，它也能设置`proxyTargetClass`这个属性的值，因此也会产生关联影响
        Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
        for (String annType : annTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
            if (candidate == null) {
                continue;
            }
            // 拿到注解里的这两个属性，说明：如果你是比如 @Configuration 或者别的注解的话，它们就是 null 了
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            // 如果存在 mode 和 proxyTargetClass 属性，且两个属性的 class 类型也是对的，才会进来此处（因此其余注解都挡外面了）
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true; // 标志：找到了候选的注解
                if (mode == AdviceMode.PROXY) {
                    // 这一步是非常重要的，AopConfigUtils 工具类的 registerAutoProxyCreatorIfNecessary 方法
                    // 它主要是注册了一个`internalAutoProxyCreator`，但是若出现多次的话，这里不是覆盖的形式，而是以第一次的为主
                    // 当然它内部有做等级的提升之类的
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) { // 看要不要强制使用 CGLIB 的方式(由此可以发现，这个属性若出现多次，是会以覆盖的形式)
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
        // 如果一个都没有找到，可能是自己注入这个类，而不是使用注解注入的（不建议这么做）
        if (!candidateFound && logger.isInfoEnabled()) {
            String name = getClass().getSimpleName();
            // 输出 info 日志，不是 error 日志
            logger.info(String.format("%s was imported but no annotations were found having both 'mode' and 'proxyTargetClass' attributes of type AdviceMode and boolean respectively. This means that auto proxy " +
                   "creator registration and configuration may not have occurred as intended, and components may not be proxied as expected. Check to ensure that %s has been @Import'ed on the same class where these"
                   + " annotations are declared; otherwise remove the import of %s altogether.", name, name, name));
        }
    }
}

TransactionManagementConfigurationSelector 中导入的 ProxyTransactionManagementConfiguration，是个配置类

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

    // 这个 Advisor 是事务的核心内容
    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(transactionAttributeSource);
        advisor.setAdvice(transactionInterceptor);
        if (this.enableTx != null) { // 顺序由 @EnableTransactionManagement 注解的 Order 属性来指定，默认值为：Ordered.LOWEST_PRECEDENCE
            advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
        }
        return advisor;
    }

    // 这里直接使用的是 AnnotationTransactionAttributeSource，基于注解的事务属性源
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    // 事务拦截器，是个`MethodInterceptor`，它也是 Spring 处理事务最为核心的部分
    // 请注意：你可以自己定义一个 TransactionInterceptor（同名的），来覆盖此 Bean（注意是覆盖）
    // 另外请注意：你自定义的 BeanName 必须同名，也就是必须名为：transactionInterceptor，否则两个都会注册进容器里面去
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        // 事务的属性
        interceptor.setTransactionAttributeSource(transactionAttributeSource);
        // 事务管理器（也就是注解最终需要使用的事务管理器，父类已经处理好了）
        // 此处注意：我们是可以不用特殊指定的，最终它自己会去容器匹配一个适合的
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }
        return interceptor;
    }
}

ProxyTransactionManagementConfiguration 的抽象父类 AbstractTransactionManagementConfiguration 

/**
 * 抽象父类，实现了 ImportAware 接口，可以拿到 @Import 所在类的所有注解信息
 */
@Configuration
public abstract class AbstractTransactionManagementConfiguration implements ImportAware {

    @Nullable
    protected AnnotationAttributes enableTx;

    /**
     * 此处：注解的默认事务处理器（可以通过实现接口 TransactionManagementConfigurer 来自定义配置）
     * 因为事务管理器这个东西，一般来说全局一个就行，但是 Spring 也提供了定制化的能力
     */
    @Nullable
    protected TransactionManager txManager;

    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        // 只拿 @EnableTransactionManagement 注解，作为 AnnotationAttributes 保存起来
        this.enableTx = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableTransactionManagement.class.getName(), false));
        if (this.enableTx == null) { // 这个注解是必须的
            throw new IllegalArgumentException("@EnableTransactionManagement is not present on importing class " + importMetadata.getClassName());
        }
    }

    /**
     * 配置类可以实现这个接口。改变默认的事务管理器
     */
    @Autowired(required = false)
    void setConfigurers(Collection<TransactionManagementConfigurer> configurers) {
        if (CollectionUtils.isEmpty(configurers)) {
            return;
        }
        if (configurers.size() > 1) { // 只允许配置一个
            throw new IllegalStateException("Only one TransactionManagementConfigurer may exist");
        }
        TransactionManagementConfigurer configurer = configurers.iterator().next();
        this.txManager = configurer.annotationDrivenTransactionManager();
    }

    /**
     * 注册一个监听器工厂，用以支持 @TransactionalEventListener 注解标注的方法，来监听事务相关的事件
     * 通过事件监听模式来实现事务的监控
     */
    @Bean(name = TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public static TransactionalEventListenerFactory transactionalEventListenerFactory() {
        return new TransactionalEventListenerFactory();
    }
}

ProxyTransactionManagementConfiguration 中注入的 AnnotationTransactionAttributeSource，指定拦截标注有 @Transaction 注解的方法

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource implements Serializable {
    // 这个是“向下兼容”，JavaEE 提供的其余两种注解
    private static final boolean jta12Present; // JTA 1.2事务注解
    private static final boolean ejb3Present; // EJB 3 事务注解

    static {
        ClassLoader classLoader = org.springframework.transaction.annotation.AnnotationTransactionAttributeSource.class.getClassLoader();
        jta12Present = ClassUtils.isPresent("javax.transaction.Transactional", classLoader);
        ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute", classLoader);
    }

    // true：只处理 public 方法（基于 JDK 的代理，只能处理 public 方法）
    // false：private/protected 等方法都会处理。基于 AspectJ 代理的方式可以设置为 false
    // 默认情况下：会被赋值为 true，表示只处理 public 的方法
    private final boolean publicMethodsOnly;

    // 保存用于分析事务注解的事务注解分析器，这个注解分析的解析器是重点
    private final Set<TransactionAnnotationParser> annotationParsers;


    /**
     * 构造函数, publicMethodsOnly 缺省使用 true
     */
    public AnnotationTransactionAttributeSource() {
        this(true);
    }

    public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
        this.publicMethodsOnly = publicMethodsOnly;
        if (jta12Present || ejb3Present) {
            this.annotationParsers = new LinkedHashSet<>(4);
            this.annotationParsers.add(new SpringTransactionAnnotationParser());
            if (jta12Present) {
                this.annotationParsers.add(new JtaTransactionAnnotationParser());
            }
            if (ejb3Present) {
                this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
            }
        } else { // 默认情况下，只添加 Spring 自己的注解解析器（绝大部分情况都是进入这里）
            this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
        }
    }

    // 自己也可以指定一个 TransactionAnnotationParser，或者多个
    public AnnotationTransactionAttributeSource(TransactionAnnotationParser annotationParser) {
        this.publicMethodsOnly = true;
        Assert.notNull(annotationParser, "TransactionAnnotationParser must not be null");
        this.annotationParsers = Collections.singleton(annotationParser);
    }
    public AnnotationTransactionAttributeSource(TransactionAnnotationParser... annotationParsers) {
        this.publicMethodsOnly = true;
        Assert.notEmpty(annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
        this.annotationParsers = new LinkedHashSet<>(Arrays.asList(annotationParsers));
    }
    public AnnotationTransactionAttributeSource(Set<TransactionAnnotationParser> annotationParsers) {
        this.publicMethodsOnly = true;
        Assert.notEmpty(annotationParsers, "At least one TransactionAnnotationParser needs to be specified");
        this.annotationParsers = annotationParsers;
    }

    @Override
    public boolean isCandidateClass(Class<?> targetClass) {
        for (TransactionAnnotationParser parser : this.annotationParsers) {
            if (parser.isCandidateClass(targetClass)) {
                return true;
            }
        }
        return false;
    }

    // 获取某个类/方法上的事务注解属性（属于父类的抽象方法）
    @Override
    @Nullable
    protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
        return determineTransactionAttribute(clazz);
    }
    @Override
    @Nullable
    protected TransactionAttribute findTransactionAttribute(Method method) {
        return determineTransactionAttribute(method);
    }

    /**
     * 分析获取某个被注解的元素（AnnotatedElement），具体来讲，指的是一个类或者一个方法上的事务注解属性。
     * 实现会遍历自己属性 annotationParsers 中所包含的事务注解属性，分析器试图获取事务注解属性，主要还是依赖于 TransactionAnnotationParser 去解析
     */
    @Nullable
    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        for (TransactionAnnotationParser parser : this.annotationParsers) {
            TransactionAttribute attr = parser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }

AnnotationTransactionAttributeSource 的父类 AbstractFallbackTransactionAttributeSource

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {

    /**
     * 针对没有事务注解属性的方法，进行事务注解属性缓存时使用的特殊值，用于标记该方法没有事务注解属性
     * 从而不用在首次缓存信息后，再次重复执行分析，来提高查找的效率
     * 标注了 @Transaction 注解的表示有事务属性的，才会最终加入事务。此处需要注意的是，只要被事务的 Advisor 切中的，都会缓存起来
     */
    @SuppressWarnings("serial")
    private static final TransactionAttribute NULL_TRANSACTION_ATTRIBUTE = new DefaultTransactionAttribute() {
        @Override
        public String toString() {
            return "null";
        }
    };

    /**
     * 方法上的事务注解属性缓存，key 使用目标类上的方法，使用类型 MethodClassKey 来表示
     * 这个 Map 会比较大，会被事务相关的 Advisor 拦截下来的方法，最终都会缓存下来
     * 因为会有很多，所以需要一个 NULL_TRANSACTION_ATTRIBUTE 常量来提高查找的效率
     */
    private final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>(1024);


    /**
     * 获取指定方法上的注解事务属性，如果方法上没有注解事务属性，则使用目标方法所属类上的注解事务属性
     */
    @Override
    @Nullable
    public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
        if (method.getDeclaringClass() == Object.class) { // 如果目标方法是内部类 Object 上的方法，总是返回 null，这些方法上不应用事务
            return null;
        }

        // 先看缓存里有没有，此处使用的 MethodClassKey 作为 Map 的 key
        Object cacheKey = getCacheKey(method, targetClass);
        TransactionAttribute cached = this.attributeCache.get(cacheKey);
        if (cached != null) {
            // 目标方法上并没有事务注解属性，但是已经被尝试分析过并且已经被缓存
            // 使用的值是 NULL_TRANSACTION_ATTRIBUTE，所以这里再次尝试获取其注解事务属性时，直接返回 null
            if (cached == NULL_TRANSACTION_ATTRIBUTE) {
                return null;
            } else {
                return cached;
            }
        } else { // 缓存没有命中
            // 通过方法、目标 Class 分析出此方法上的事务属性
            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
            if (txAttr == null) { // 如果目标方法上并没有使用注解事务属性，也缓存该信息，只不过使用的值是一个特殊值
                this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
            } else {
                // 获取 methodIdentification 基本是为了输出日志
                String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
                if (txAttr instanceof DefaultTransactionAttribute) {
                    ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
                }
                if (logger.isTraceEnabled()) {
                    logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
                }
                // 存在目标属性就 put 进去。
                this.attributeCache.put(cacheKey, txAttr);
            }
            return txAttr;
        }
    }

    /**
     * 查找目标方法上的事务注解属性，也是上面的核心方法
     */
    @Nullable
    protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
        // 如果事务注解属性分析仅仅针对 public 方法，而当前方法不是 public，则直接返回 null
        // 如果是 private，AOP 是能切入，代理对象也会生成的，但就是事务不会生效
        if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
            return null;
        }

        // 因为 Method 并不一样属于目标类。所以这个方法就是获取 targetClass 上的那个和 method 对应的方法，也就是最终要执行的方法
        Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

        // 第一步：去找直接标记在方法上的事务属性，如果方法上有就直接返回（不用再看类上的了）
        // findTransactionAttribute 这个方法由子类去实现的
        TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
        if (txAttr != null) {
            return txAttr;
        }

        // 然后尝试检查事务注解属性是否标记在目标方法 specificMethod（注意此处用不是 Method）所属类上
        txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }

        // 程序走到这里说明目标方法 specificMethod，也就是实现类上的目标方法上没有标记事务注解属性（否则直接返回了）
        // 如果 specificMethod 和 method 不同，则说明 specificMethod 是具体实现类的方法，method 是实现类所实现接口的方法
        // 因此再次尝试从 method 上获取事务注解属性，这也就是为何我们的 @Transaction 标注在接口上或者接口的方法上都生效的原因
        if (specificMethod != method) {
            txAttr = findTransactionAttribute(method);
            if (txAttr != null) {
                return txAttr;
            }
            txAttr = findTransactionAttribute(method.getDeclaringClass());
            if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
                return txAttr;
            }
        }

        return null;
    }

    /**
     * 默认值是 false，表示 private 的也是 ok 的
     * 但`AnnotationTransactionAttributeSource`复写了它，可以由开发者指定（默认是 true 了）
     */
    protected boolean allowPublicMethodsOnly() {
        return false;
    }

    protected Object getCacheKey(Method method, @Nullable Class<?> targetClass) {
        return new MethodClassKey(method, targetClass);
    }

    @Nullable
    protected abstract TransactionAttribute findTransactionAttribute(Class<?> clazz);

    @Nullable
    protected abstract TransactionAttribute findTransactionAttribute(Method method);
}

真正把 @Transaction 注解变成一个 TransactionAttribute 类的是 TransactionAnnotationParser，主要看 SpringTransactionAnnotationParser 实现，用于解析 Class 或者 Method 上的 org.springframework.transaction.annotation.Transactional 注解

 

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

    @Override
    public boolean isCandidateClass(Class<?> targetClass) {
        return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
    }

    /**
     * 此方法对外暴露，表示获取该方法/类上面的 TransactionAttribute
     */
    @Override
    @Nullable
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(element, Transactional.class, false, false);
        if (attributes != null) { // 把注解的属性交给 parseTransactionAnnotation 方法，最终转换为事务的属性类
            return parseTransactionAnnotation(attributes);
        } else { // 没有标注解就返回 null
            return null;
        }
    }

    /**
     * 重载方法，可以直接传入一个注解
     */
    public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
        return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    }

    /**
     * 把注解上的属性转换为事务属性
     */
    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        // 此处用的 RuleBasedTransactionAttribute，因为它可以指定不需要回滚的类
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

        // 事务的传播属性枚举：内部定义了 7 种事务传播行为
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        // 事务的隔离级别枚举。一共是 4 种，枚举里提供一个默认值：TransactionDefinition.ISOLATION_DEFAULT
        // 至于默认值是哪种隔离界别，和具体的数据库有关
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        // 设置事务的超时时间
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        // 是否是只读事务
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        // 这个属性，是指定事务管理器 PlatformTransactionManager 的 BeanName 的，若不指定，就按照类型找了
        // 若容器中存在多个事务管理器，但又没指定名字，那就报错
        rbta.setQualifier(attributes.getString("value"));

        // rollbackFor 可以指定需要回滚的异常，可以指定多个，若不指定默认为 RuntimeException
        // 此处使用的 RollbackRuleAttribute 包装，它就是个 POJO，没有实现 Spring 中的接口
        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
        for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        // 全类名的方式
        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }

        // 指定不需要回滚的异常类型
        // 此处使用的 NoRollbackRuleAttribute 包装，它是 RollbackRuleAttribute 的子类
        for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }

        // 添加到 RuleBasedTransactionAttribute
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

ProxyTransactionManagementConfiguration 中注入的 BeanFactoryTransactionAttributeSourceAdvisor，是一个 Advisor，也就是 Pointcut 和 Advice 的组合

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

    @Nullable
    private TransactionAttributeSource transactionAttributeSource;

    /**
     * 这个很重要，就是切面。它决定了哪些类会被切入，从而生成的代理对象
     * 关于：TransactionAttributeSourcePointcut 下面有说
     */
    private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
        @Override
        @Nullable
        protected TransactionAttributeSource getTransactionAttributeSource() {
            return transactionAttributeSource;
        }
    };

    /**
     * 可以手动设置一个事务属性源
     */
    public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
        this.transactionAttributeSource = transactionAttributeSource;
    }

    /**
     * 可以指定 ClassFilter，默认情况下：ClassFilter classFilter = ClassFilter.TRUE; 匹配所有的类
     */
    public void setClassFilter(ClassFilter classFilter) {
        this.pointcut.setClassFilter(classFilter);
    }

    /**
     * 此处 pointcut 就是使用自己的这个 pointcut 去切入
     */
    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }
}

BeanFactoryTransactionAttributeSourceAdvisor 中的 TransactionAttributeSourcePointcut，这个就是事务的 Pointcut 切面，决定了哪些类需要生成代理对象从而应用事务

/**
 * 访问权限是 default，是 Spring 内部使用的
 * 继承自 StaticMethodMatcherPointcut，构造器调用了 setClassFilter 方法
 * 并且 isRuntime=false，表示只需要对方法进行静态匹配即可
 */
abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {

    protected TransactionAttributeSourcePointcut() {
        setClassFilter(new TransactionAttributeSourceClassFilter());
    }

    /**
     * 方法的匹配，静态匹配即可（事务不需要动态匹配那么细粒）
     * 关于 matches 方法的调用时机：只要是容器内的每个 Bean，都会经过 AbstractAutoProxyCreator#postProcessAfterInitialization，
     * 从而会调用 wrapIfNecessary 方法，因此容器内所有的 Bean 的所有方法在容器启动时候都会执行此 matche 方法
     */
    @Override
    public boolean matches(Method method, Class<?> targetClass) {
        TransactionAttributeSource tas = getTransactionAttributeSource();
        return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    }

    /**
     * 由子类提供给，告诉事务属性源，好知道哪些方法需要切入
     */
    @Nullable
    protected abstract TransactionAttributeSource getTransactionAttributeSource();

    private class TransactionAttributeSourceClassFilter implements ClassFilter {
        @Override
        public boolean matches(Class<?> clazz) {
            // 实现了如下三个接口的子类，就不需要被代理了，直接放行
            // TransactionalProxy 是 SpringProxy 的子类。如果是被 TransactionProxyFactoryBean 生产出来的 Bean，就会自动实现此接口，那么就不会被这里再次代理了
            // PlatformTransactionManager：Spring 抽象的事务管理器
            // PersistenceExceptionTranslator：RuntimeException 转换成 DataAccessException 的转换接口
            if (TransactionalProxy.class.isAssignableFrom(clazz) ||
                    TransactionManager.class.isAssignableFrom(clazz) ||
                    PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
                return false;
            }
            // 拿到事务属性源，如果 tas == null 表示没有配置事务属性源，那就是全部匹配的，也就是说所有的方法都匹配
            // 或者标注了 @Transaction 这样的注解的方法才会给与匹配
            TransactionAttributeSource tas = getTransactionAttributeSource();
            return (tas == null || tas.isCandidateClass(clazz));
        }
    }

ProxyTransactionManagementConfiguration 中注入的 TransactionInterceptor，真正的执行事务方法

在看 TransactionInterceptor 之前，先看下 Spring 事务管理中的 3 个高层抽象接口：

• TransactionDefinition：用于描述隔离级别、超时时间、是否为只读事务和事务传播规则
• TransactionStatus：代表一个事务的具体运行状态、以及还原点
• PlatformTransactionManager：一个高层次的接口，包含3个方法。commit、rollback和getTramsaction

TransactionStatus，事务代码可以使用它来检索状态信息，以编程方式请求回滚（而不是抛出导致隐式回滚的异常）

public interface TransactionExecution {
    /**
     * 判断当前的事务是否是新事务
     */
    boolean isNewTransaction();

    /**
     * 事务的唯一结果是进行回滚。如果在外层给 try catche 住，不让事务回滚，就会抛出异常：
     * Transaction rolled back because it has been marked as rollback-only
     */
    void setRollbackOnly();
    boolean isRollbackOnly();

    /**
     * 不管是 commit 或者 rollback 了，都算结束了
     */
    boolean isCompleted();
}

/**
 * 表示事务的状态，继承自 SavepointManager，所以它也会处理还原点
 */
public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
    /**
     * 判断该事务里面是否含有还原点
     */
    boolean hasSavepoint();

    /**
     * 将基础会话刷新到数据存储
     */
    @Override
    void flush();
}

抽象实现 AbstractTransactionStatus

public abstract class AbstractTransactionStatus implements TransactionStatus {
    // 两个标志位
    private boolean rollbackOnly = false;
    private boolean completed = false;

    // 一个还原点
    @Nullable
    private Object savepoint;

    // 把该属性值保存为 true
    @Override
    public void setRollbackOnly() {
        this.rollbackOnly = true;
    }

    // 注意此处并不是直接读取
    @Override
    public boolean isRollbackOnly() {
        return (isLocalRollbackOnly() || isGlobalRollbackOnly());
    }
    public boolean isLocalRollbackOnly() {
        return this.rollbackOnly;
    }

    // Global 这里返回 false 但是子类 DefaultTransactionStatus 复写了此方法
    public boolean isGlobalRollbackOnly() {
        return false;
    }

    // 由子类去实现
    @Override
    public void flush() {
    }

两个具体实现：SimpleTransactionStatus 和 DefaultTransactionStatus(Spring 默认使用的事务状态)

// 就是标志一下事务是否是新的事务
public class SimpleTransactionStatus extends AbstractTransactionStatus {

    private final boolean newTransaction;

    public SimpleTransactionStatus() {
        this(true);
    }

    public SimpleTransactionStatus(boolean newTransaction) {
        this.newTransaction = newTransaction;
    }

    @Override
    public boolean isNewTransaction() {
        return this.newTransaction;
    }
}

public class DefaultTransactionStatus extends AbstractTransactionStatus {
    @Nullable
    private final Object transaction;
    // 是否是新事务
    private final boolean newTransaction;
    // 如果为给定事务打开了新的事务同步，该值为 true
    private final boolean newSynchronization;
    // 该事务是否标记为了只读
    private final boolean readOnly;
    private final boolean debug;

    @Nullable
    private final Object suspendedResources;

    /**
     * 唯一构造函数
     */
    public DefaultTransactionStatus(@Nullable Object transaction, boolean newTransaction, boolean newSynchronization, boolean readOnly, boolean debug, @Nullable Object suspendedResources) {
        this.transaction = transaction;
        this.newTransaction = newTransaction;
        this.newSynchronization = newSynchronization;
        this.readOnly = readOnly;
        this.debug = debug;
        this.suspendedResources = suspendedResources;
    }

    /**
     * 直接把底层事务返回
     */
    public Object getTransaction() {
        Assert.state(this.transaction != null, "No transaction active");
        return this.transaction;
    }

    public boolean hasTransaction() {
        return (this.transaction != null);
    }

    @Override
    public boolean isNewTransaction() {
        return (hasTransaction() && this.newTransaction);
    }

    /**
     * 都由 SmartTransactionObject 去处理，该接口的实现类有：
     * JdbcTransactionObjectSupport 和 JtaTransactionObject（多数据源事务）
     */
    @Override
    public boolean isGlobalRollbackOnly() {
        return ((this.transaction instanceof SmartTransactionObject) && ((SmartTransactionObject) this.transaction).isRollbackOnly());
    }

    @Override
    public void flush() {
        if (this.transaction instanceof SmartTransactionObject) {
            ((SmartTransactionObject) this.transaction).flush();
        }
    }

再看 TransactionInterceptor：事务拦截器，是个 MethodInterceptor，被事务拦截的方法最终都会执行到此增强器身上。MethodInterceptor 是个环绕通知，正好符合开启、提交、回滚事务等操作

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
    /**
     * 构造函数：
     * 可以不用特殊的指定 PlatformTransactionManager 事务管理器，后面会讲解自定义去获取
     * 可以自己指定 Properties 以及 TransactionAttributeSource
     */
    public TransactionInterceptor() {
    }
    public TransactionInterceptor(TransactionManager ptm, TransactionAttributeSource tas) {
        setTransactionManager(ptm);
        setTransactionAttributeSource(tas);
    }
    @Deprecated
    public TransactionInterceptor(PlatformTransactionManager ptm, TransactionAttributeSource tas) {
        setTransactionManager(ptm);
        setTransactionAttributeSource(tas);
    }
    @Deprecated
    public TransactionInterceptor(PlatformTransactionManager ptm, Properties attributes) {
        setTransactionManager(ptm);
        setTransactionAttributes(attributes);
    }

    // invoke 方法：拦截的入口
    @Override
    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取目标类
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

        // invokeWithinTransaction：父类 TransactionAspectSupport 的模板方法
        // invocation::proceed 本处执行完成执行目标方法（当然可能还有其余增强器）
        return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    }

可以看出，真正做事的是父类 TransactionAspectSupport，它有一个执行事务的模版

/**
 * 通过 BeanFactoryAware 获取到 BeanFactory
 * InitializingBean 的 afterPropertiesSet 是对 Bean 做一些验证（经常会借助它这么来校验 Bean）
 */
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
    // 这个类不允许实现 Serializable 接口，请注意
    // NOTE: This class must not implement Serializable because it serves as base
    // class for AspectJ aspects (which are not allowed to implement Serializable)!

    private static final Object DEFAULT_TRANSACTION_MANAGER_KEY = new Object();
    private static final boolean vavrPresent = ClassUtils.isPresent("io.vavr.control.Try", TransactionAspectSupport.class.getClassLoader());
    private static final boolean reactiveStreamsPresent = ClassUtils.isPresent("org.reactivestreams.Publisher", TransactionAspectSupport.class.getClassLoader());

    /**
     * currentTransactionStatus() 方法依托于它
     */
    private static final ThreadLocal<TransactionInfo> transactionInfoHolder = new NamedThreadLocal<>("Current aspect-driven transaction");

    /**
     * 此方法是个静态方法，并且是 protected 的，说明只有子类能够调用，外部并不可以
     */
    @Nullable
    protected static TransactionInfo currentTransactionInfo() throws NoTransactionException {
        return transactionInfoHolder.get();
    }

    /**
     * 外部调用此 Static 方法，可议获取到当前事务的状态，从而可以手动来提交、回滚事务
     */
    public static TransactionStatus currentTransactionStatus() throws NoTransactionException {
        TransactionInfo info = currentTransactionInfo();
        if (info == null || info.transactionStatus == null) {
            throw new NoTransactionException("No transaction aspect-managed TransactionStatus in scope");
        }
        return info.transactionStatus;
    }

    @Nullable
    private final ReactiveAdapterRegistry reactiveAdapterRegistry;
    @Nullable
    private String transactionManagerBeanName; // 事务管理器的名称（若设置，会根据此名称去找到事务管理器）
    @Nullable
    private TransactionManager transactionManager;
    @Nullable
    private TransactionAttributeSource transactionAttributeSource;
    @Nullable
    private BeanFactory beanFactory;
    // 事务管理器可能会有多个，此处做了一个简单的缓存
    private final ConcurrentMap<Object, TransactionManager> transactionManagerCache = new ConcurrentReferenceHashMap<>(4);
    private final ConcurrentMap<Method, ReactiveTransactionSupport> transactionSupportCache = new ConcurrentReferenceHashMap<>(1024);

    protected TransactionAspectSupport() {
        if (reactiveStreamsPresent) {
            this.reactiveAdapterRegistry = ReactiveAdapterRegistry.getSharedInstance();
        } else {
            this.reactiveAdapterRegistry = null;
        }
    }

    /**
     * 若传入的为 Properties，内部实际使用的是 NameMatchTransactionAttributeSource 去匹配的
     * 备注：若调用了此方法 transactionAttributeSource 就会被覆盖
     */
    public void setTransactionAttributes(Properties transactionAttributes) {
        NameMatchTransactionAttributeSource tas = new NameMatchTransactionAttributeSource();
        tas.setProperties(transactionAttributes);
        this.transactionAttributeSource = tas;
    }

    /**
     * 若有多种匹配策略，这也是支持的
     */
    public void setTransactionAttributeSources(TransactionAttributeSource... transactionAttributeSources) {
        this.transactionAttributeSource = new CompositeTransactionAttributeSource(transactionAttributeSources);
    }

    public void setTransactionAttributeSource(@Nullable TransactionAttributeSource transactionAttributeSource) {
        this.transactionAttributeSource = transactionAttributeSource;
    }


    /**
     * 处理事务的模版方法，protected 修饰，不允许其它包和无关类调用
     */
    @Nullable
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable {
        // 获取事务属性源
        TransactionAttributeSource tas = getTransactionAttributeSource();
        // 获取该方法对应的事务属性（这个特别重要）
        final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        // 找到一个合适的事务管理器
        final TransactionManager tm = determineTransactionManager(txAttr);

        if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
            ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
                if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
                    throw new TransactionUsageException("Unsupported annotated transaction on suspending function detected: " + method + ". Use TransactionalOperator.transactional extensions instead.");
                }
                ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
                if (adapter == null) {
                    throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType());
                }
                return new ReactiveTransactionSupport(adapter);
            });
            return txSupport.invokeWithinTransaction(method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
        }

        PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
        // 拿到目标方法唯一标识（类.方法，如 service.UserServiceImpl.save）
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        // 如果 txAttr 为空或者 tm 属于非 CallbackPreferringPlatformTransactionManager，执行目标增强
        // 在 TransactionManager 上，CallbackPreferringPlatformTransactionManager 实现 PlatformTransactionManager 接口，暴露出一个方法用于执行事务处理中的回调
        if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
            // 看是否有必要创建一个事务，根据`事务传播行为`，做出相应的判断
            TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

            Object retVal;
            try {
                // 回调方法执行，执行目标方法（原有的业务逻辑）
                retVal = invocation.proceedWithInvocation();
            } catch (Throwable ex) {
                // 出现异常了，进行回滚（注意：并不是所有异常都会 rollback 的）
                // 备注：此处若没有事务属性会 commit，兼容编程式事务
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            } finally {
                // 清除信息
                cleanupTransactionInfo(txInfo);
            }

            if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                // Set rollback-only in case of Vavr failure matching our rollback rules...
                TransactionStatus status = txInfo.getTransactionStatus();
                if (status != null && txAttr != null) {
                    retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                }
            }
            // 目标方法完全执行完成后，提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        // 编程式事务处理(CallbackPreferringPlatformTransactionManager) 会走这里
        // 对于声明式事务的处理与编程式事务的处理，重要区别在于事务属性上，因为编程式的事务处理是不需要有事务属性的
        else {
            Object result;
            final ThrowableHolder throwableHolder = new ThrowableHolder();

            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            try {
                result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
                    TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
                    try {
                        Object retVal = invocation.proceedWithInvocation();
                        if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                            // Set rollback-only in case of Vavr failure matching our rollback rules...
                            retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                        }
                        return retVal;
                    } catch (Throwable ex) {
                        if (txAttr.rollbackOn(ex)) {
                            // A RuntimeException: will lead to a rollback.
                            if (ex instanceof RuntimeException) {
                                throw (RuntimeException) ex;
                            } else {
                                throw new ThrowableHolderException(ex);
                            }
                        } else {
                            // A normal return value: will lead to a commit.
                            throwableHolder.throwable = ex;
                            return null;
                        }
                    } finally {
                        cleanupTransactionInfo(txInfo);
                    }
                });
            } catch (ThrowableHolderException ex) {
                throw ex.getCause();
            } catch (TransactionSystemException ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    ex2.initApplicationException(throwableHolder.throwable);
                }
                throw ex2;
            } catch (Throwable ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }
                throw ex2;
            }

            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        }
    }

    /**
     * 从容器中找到一个事务管理器
     */
    @Nullable
    protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
        // 如果这两个都没配置，那肯定是手动设置了 PlatformTransactionManager，直接返回即可
        if (txAttr == null || this.beanFactory == null) {
            return getTransactionManager();
        }
        // qualifier 相当于 BeanName
        String qualifier = txAttr.getQualifier();
        if (StringUtils.hasText(qualifier)) { // 根据此名称以及 PlatformTransactionManager.class 去容器内找
            return determineQualifiedTransactionManager(this.beanFactory, qualifier);
        } else if (StringUtils.hasText(this.transactionManagerBeanName)) { // 若没有指定 qualifier，那再看看是否指定了 transactionManagerBeanName
            return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
        } else { // 若都没指定，那就不管了。直接根据类型去容器里找 getBean(Class)，此处若容器内有两个 PlatformTransactionManager，那就会报错
            TransactionManager defaultTransactionManager = getTransactionManager();
            if (defaultTransactionManager == null) {
                defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
                if (defaultTransactionManager == null) {
                    defaultTransactionManager = this.beanFactory.getBean(TransactionManager.class);
                    this.transactionManagerCache.putIfAbsent(DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
                }
            }
            return defaultTransactionManager;
        }
    }

    /**
     * 它是创建事务的一个重要方法
     * 它会判断是否存在事务，根据事务的传播属性。做出不同的处理，也是做了一层包装，核心是通过 TransactionStatus 来判断事务的属性
     * 若有需要，创建一个 TransactionInfo (具体的事务从事务管理器里面 getTransaction() 出来)
     */
    @SuppressWarnings("serial")
    protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
        // 给 Name 赋值
        if (txAttr != null && txAttr.getName() == null) {
            txAttr = new DelegatingTransactionAttribute(txAttr) {
                @Override
                public String getName() {
                    return joinpointIdentification;
                }
            };
        }

        // 从事务管理器里，通过 txAttr 拿出来一个 TransactionStatus
        TransactionStatus status = null;
        if (txAttr != null) {
            if (tm != null) {
                status = tm.getTransaction(txAttr);
            } else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping transactional joinpoint [" + joinpointIdentification + "] because no transaction manager has been configured");
                }
            }
        }
        // 通过 TransactionStatus 等，转换成一个通用的 TransactionInfo
        return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    }

    /**
     * 准备事务
     */
    protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, String joinpointIdentification, @Nullable TransactionStatus status) {
        // 构造一个 TransactionInfo
        TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
        if (txAttr != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }
            // 如果已存在不兼容的 Tx，事务管理器将标记错误
            txInfo.newTransactionStatus(status);
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("No need to create transaction for [" + joinpointIdentification + "]: This method is not transactional.");
            }
        }
        // 这句话是最重要的：把生成的 TransactionInfo 绑定到当前线程的 ThreadLocal
        txInfo.bindToThread();
        return txInfo;
    }

    /**
     * 提交事务
     */
    protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
        // 用事务管理器提交事务即可，具体的实现逻辑在事务管理器的 commit 实现里
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }
            txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
        }
    }

    /**
     * 回滚事务
     */
    protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
        if (txInfo != null && txInfo.getTransactionStatus() != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex);
            }
            // 如果有事务属性，那就调用 rollbackOn 看看这个异常需不需要回滚
            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                } catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                } catch (RuntimeException | Error ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    throw ex2;
                }
            } else { // 编程式事务没有事务属性，那就 commit
                try {
                    txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
                } catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by commit exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                } catch (RuntimeException | Error ex2) {
                    logger.error("Application exception overridden by commit exception", ex);
                    throw ex2;
                }
            }
        }
    }

    /**
     * 清除（解绑）事务
     */
    protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
        if (txInfo != null) {
            txInfo.restoreThreadLocalStatus();
        }
    }

    /**
     * 内部类，事务 Info
     */
    protected static final class TransactionInfo {
        @Nullable
        private final PlatformTransactionManager transactionManager; // 当前事务的事务管理器
        @Nullable
        private final TransactionAttribute transactionAttribute; // 当前事务的事务属性
        private final String joinpointIdentification; // joinpoint 标识
        @Nullable
        private TransactionStatus transactionStatus; // 当前事务的 TransactionStatus
        // 重点就是这个 oldTransactionInfo 字段
        // 这个字段保存了当前事务所在的`父事务`上下文的引用，构成了一个链，准确的说是一个有向无环图
        @Nullable
        private TransactionInfo oldTransactionInfo;

        public TransactionInfo(@Nullable PlatformTransactionManager transactionManager,
                               @Nullable TransactionAttribute transactionAttribute, String joinpointIdentification) {
            this.transactionManager = transactionManager;
            this.transactionAttribute = transactionAttribute;
            this.joinpointIdentification = joinpointIdentification;
        }

        public PlatformTransactionManager getTransactionManager() {
            Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
            return this.transactionManager;
        }

        // 注意这个方法名，新的一个事务 status
        public void newTransactionStatus(@Nullable TransactionStatus status) {
            this.transactionStatus = status;
        }

        public boolean hasTransaction() {
            return (this.transactionStatus != null);
        }

        // 绑定当前正在处理的事务的所有信息到 ThreadLocal
        private void bindToThread() {
            // 老的事务先从线程中拿出来，再把新的（也就是当前）绑定进去
            this.oldTransactionInfo = transactionInfoHolder.get();
            transactionInfoHolder.set(this);
        }

        private void restoreThreadLocalStatus() {
            // 当前事务处理完之后，恢复父事务上下文
            transactionInfoHolder.set(this.oldTransactionInfo);
        }

最后看 PlatformTransactionManager：事务管理器，谈到事务，肯定是离不开它的。

关于事务管理器，不管是 JPA（JpaTransactionManager ）还是 JDBC（DataSourceTransactionManager）甚至是 JTA（JtaTransactionManager）等都实现自接口 PlatformTransactionManager

先看抽象实现 AbstractPlatformTransactionManager，是一个非常典型的模版实现，各个方法实现都是这样。自己先提供实现模版，很多具体的实现方案都开放给子类，比如 begin,suspend, resume, commit, rollback 等，相当于留好了众多的连接点

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
    public static final int SYNCHRONIZATION_ALWAYS = 0; // 始终激活事务同步（请参阅事务的传播属性）
    public static final int SYNCHRONIZATION_ON_ACTUAL_TRANSACTION = 1; // 仅对实际事务（即，不针对由传播导致的空事务）激活事务同步不支持现有后端事务
    public static final int SYNCHRONIZATION_NEVER = 2; // 永远不激活事务同步
    // 相当于把本类的所有 public static final 的变量都收集到此处
    private static final Constants constants = new Constants(AbstractPlatformTransactionManager.class);
    protected transient Log logger = LogFactory.getLog(getClass());
    private int transactionSynchronization = SYNCHRONIZATION_ALWAYS;
    private int defaultTimeout = TransactionDefinition.TIMEOUT_DEFAULT;
    private boolean nestedTransactionAllowed = false;
    private boolean validateExistingTransaction = false;
    // 设置是否仅在参与事务`失败后`将现有事务`全局`标记为回滚，默认值是 true
    // 表示只要你的事务失败了，就标记此事务为 rollback-only，表示它只能回滚，不能再 commit 或者正常结束了
    // 这个调用者经常会犯的一个错误就是：上层事务 service 抛出异常了，自己把它给 try 住，并且还不 throw，那就肯定会报错的：
    // 报错信息：Transaction rolled back because it has been marked as rollback-only
    // 这个属性强制不建议设置为 false
    private boolean globalRollbackOnParticipationFailure = true;
    private boolean failEarlyOnGlobalRollbackOnly = false; // 如果事务被全局标记为仅回滚，则设置是否及早失败
    private boolean rollbackOnCommitFailure = false; // 设置在 docommit 调用失败时是否应执行 dorollback，通常不需要，因此应避免

    /**
     * 使用起来有点枚举的意思了，这也是 Constants 的重要意义
     */
    public final void setTransactionSynchronizationName(String constantName) {
        setTransactionSynchronization(constants.asNumber(constantName).intValue());
    }

    /**
     * 最为重要的一个方法，根据定义，获取到一个事务 TransactionStatus
     */
    @Override
    public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
        // 如果没有配置事务属性，则使用默认的事务属性
        TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());

        // doGetTransaction() 方法是抽象方法，具体的实现由具体的事务处理器提供
        Object transaction = doGetTransaction();
        boolean debugEnabled = logger.isDebugEnabled();

        if (isExistingTransaction(transaction)) { // 检查当前线程是否存在事务，isExistingTransaction 此方法默认返回 false，但子类都复写了此方法
            // handleExistingTransaction 方法为处理已经存在事务的情况，这个方法的实现也很复杂，总之还是对一些传播属性进行解析，各种情况的考虑，如果有新事务产生 doBegin() 就会被调用
            return handleExistingTransaction(def, transaction, debugEnabled);
        }

        if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) { // 超时校验
            throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
        }

        // 处理事务属性中配置的事务传播特性
        // PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常
        if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
        } else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) { // 如果事务传播特性为 required、required_new 或 nested
            // 挂起，但是 doSuspend() 由子类去实现
            // 挂起操作，触发相关的挂起注册的事件，把当前线程事物的所有属性都封装好，放到一个 SuspendedResourcesHolder
            // 然后清空一下`当前线程事务`
            SuspendedResourcesHolder suspendedResources = suspend(null);
            if (debugEnabled) {
                logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
            }
            try { // 此处，开始创建事务
                return startTransaction(def, transaction, debugEnabled, suspendedResources);
            } catch (RuntimeException | Error ex) { // 重新开始，里面的 doResume 由子类去实现
                resume(null, suspendedResources);
                throw ex;
            }
        } else { // 走到这里，传播属性就是不需要事务的，那就直接创建一个
            if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
                logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + def);
            }
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            // 这个方法相当于先 newTransactionStatus，再 prepareSynchronization 这两步
            // 显然和上面的区别是：中间不会插入调用 doBegin() 方法，因为没有事务
            return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
        }
    }

    /**
     * Start a new transaction.
     */
    private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        // 创建一个新的事务状态，就是 new DefaultTransactionStatus()，把个属性都赋值上
        DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        // 开始事务，抽象方法，由子类去实现
        doBegin(transaction, definition);
        // 初始化和同步事务状态，是 TransactionSynchronizationManager 这个类，它内部维护了很多的 ThreadLocal
        prepareSynchronization(status, definition);
        return status;
    }

    @Override
    public final void commit(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) { // 如果是一个已经完成的事物，不可重复提交
            throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        if (defStatus.isLocalRollbackOnly()) { // 如果已经标记为了需要回滚，那就执行回滚吧
            if (defStatus.isDebug()) {
                logger.debug("Transactional code has requested rollback");
            }
            processRollback(defStatus, false);
            return;
        }

        // shouldCommitOnGlobalRollbackOnly 这个默认值是 false，目前只有 JTA 事务复写成 true 了
        // isGlobalRollbackOnly：是否标记为了全局的 RollbackOnly
        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            if (defStatus.isDebug()) {
                logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
            }
            processRollback(defStatus, true);
            return;
        }
        // 提交事务，这里面还是挺复杂的，会考虑到还原点、新事务、事务是否是 rollback-only 之类的
        processCommit(defStatus);
    }

    @Override
    public final void rollback(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException("Transaction is already completed - do not call commit or rollback more than once per transaction");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        // 里面 doRollback 方法交给子类去实现
        processRollback(defStatus, false);
    }

DataSourceTransactionManager 实现

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager implements ResourceTransactionManager, InitializingBean {

    @Nullable
    private DataSource dataSource; // 管理的是 DataSource，JTA 多数据源事务管理可能就是各种各样的数据源了
    private boolean enforceReadOnly = false; // 不要强制标记为 ReadOnly

    public DataSourceTransactionManager() {
        setNestedTransactionAllowed(true); // JDBC 默认是允许内嵌的事务的
    }

    public DataSourceTransactionManager(DataSource dataSource) {
        this();
        setDataSource(dataSource);
        afterPropertiesSet(); // InitializingBean 做了一个简单的校验
    }

    /**
     * 手动设置数据源
     */
    public void setDataSource(@Nullable DataSource dataSource) {
        if (dataSource instanceof TransactionAwareDataSourceProxy) { // TransactionAwareDataSourceProxy 是对 dataSource 的包装
            this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();
        } else {
            this.dataSource = dataSource;
        }
    }

    /**
     * 这里返回的是一个`DataSourceTransactionObject`
     * 它是一个`JdbcTransactionObjectSupport`，所以它是 SavepointManager、实现了 SmartTransactionObject 接口
     */
    @Override
    protected Object doGetTransaction() {
        DataSourceTransactionObject txObject = new DataSourceTransactionObject();
        txObject.setSavepointAllowed(isNestedTransactionAllowed());
        // 按照线程来获取
        ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
        txObject.setConnectionHolder(conHolder, false);
        return txObject;
    }

    @Override
    protected boolean isExistingTransaction(Object transaction) { // 检查当前事务是否 active
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
    }

    @Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        Connection con = null;

        try {
            if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                // 从 DataSource 里获取一个连接（这个 DataSource 一般是有连接池的）
                Connection newCon = obtainDataSource().getConnection();
                if (logger.isDebugEnabled()) {
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }
                // 把这个连接用 ConnectionHolder 包装一下
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();
            // 设置 isReadOnly、设置隔离级别等
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);
            txObject.setReadOnly(definition.isReadOnly());

            // 这里非常的关键，先看看 Connection 是否是自动提交的
            // 如果是，就 con.setAutoCommit(false)，要不然数据库默认每执行一条 SQL 都是一个事务，就没法进行事务的管理了
            if (con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if (logger.isDebugEnabled()) {
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }
                con.setAutoCommit(false);
            }

            // 因此从这后面，通过此 Connection 执行的所有 SQL 语句只要没有 commit 就都不会提交给数据库

            // 这个方法特别特别有意思，它自己`Statement stmt = con.createStatement()`拿到一个 Statement
            // 然后执行了一句 SQL：`stmt.executeUpdate("SET TRANSACTION READ ONLY");`
            // 所以，所以：如果你仅仅只是查询。把事务的属性设置为 readonly=true，Spring 会帮你对 SQl 进行优化
            // 需要注意的是：readonly=true 后，只能读，不能进行 dml 操作）（只能看到设置事物前数据的变化，看不到设置事物后数据的改变）
            prepareTransactionalConnection(con, definition);
            txObject.getConnectionHolder().setTransactionActive(true);

            int timeout = determineTimeout(definition);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }

            // 这一步：就是把当前的链接 和当前的线程进行绑定
            if (txObject.isNewConnectionHolder()) {
                TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
            }
        } catch (Throwable ex) {
            if (txObject.isNewConnectionHolder()) { // 如果是新创建的链接，那就释放
                DataSourceUtils.releaseConnection(con, obtainDataSource());
                txObject.setConnectionHolder(null, false);
            }
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
        }
    }

    @Override
    protected void doCommit(DefaultTransactionStatus status) { // 真正提交事务
        // 拿到连接，然后直接 commit
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.commit();
        } catch (SQLException ex) {
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);
        }
    }

---

https://blog.csdn.net/f641385712/article/details/89607829

https://blog.csdn.net/f641385712/article/details/89673753

https://blog.csdn.net/f641385712/article/details/89637176