• Spring 源码阅读 74：事务管理的原理 - BeanFactoryTransactionAttributeSourceAdvisor 分析

    本文通过对 BeanFactoryTransactionAttributeSourceAdvisor 类的分析，了解了 Spring 是如何通过 AOP 来完成事务的管理的，本文的内容需要你对 Spring 的 AOP 的实现原理有一定的了解。

    基于 Spring Framework v5.2.6.RELEASE

    概述

    Spring 的事务管理基于 AOP 特性，因此，事务管理的增强逻辑需要一个 Advisor 来提供，这便是 BeanFactoryTransactionAttributeSourceAdvisor，本文我们来分析它的原理。

    类关系

    它是 PointcutAdvisor 的实现类，我们开发时配置的切面通过 Spring 解析后得到的也是一个 PointcutAdvisor，因此，它们的原理应该是相似的。所以，本文会通过以下几个方面来进行分析：

    1. Spring 创建它的具体过程
    2. 如何匹配被增强的类型
    3. 如何匹配被增强的方法
    4. 通过增强逻辑实现事务管理的具体原理

    创建

    它是在 Spring 解析配置的时候被创建的，以下是 ProxyTransactionManagementConfiguration 中创建 BeanFactoryTransactionAttributeSourceAdvisor 的方法。

    1. // org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor
    2. @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    3. @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    4. public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
    5.       TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
    6.  
    7.    BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
    8.    advisor.setTransactionAttributeSource(transactionAttributeSource);
    9.    advisor.setAdvice(transactionInterceptor);
    10.    if (this.enableTx != null) {
    11.       advisor.setOrder(this.enableTx.getNumber("order"));
    12.    }
    13.    return advisor;
    14. }
    15. 复制代码

    方法中，通过无参构造方法创建了 BeanFactoryTransactionAttributeSourceAdvisor 对象，并初始化了一些属性。它并没有显式地声明构造方法，因此我们分别来看几个属性的设置。

    transactionAttributeSource 属性

    transactionAttributeSource 属性的值，来自方法参数，需要 Spring 来注入，这个值的来源是同一个配置类中的另外一个方法。

    1. // org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration#transactionAttributeSource
    2. @Bean
    3. @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    4. public TransactionAttributeSource transactionAttributeSource() {
    5.    return new AnnotationTransactionAttributeSource();
    6. }
    7. 复制代码

    其中，AnnotationTransactionAttributeSource 的构造方法如下。

    1. public AnnotationTransactionAttributeSource() {
    2.    this(true);
    3. }
    4. 复制代码

    再进入另外一个构造方法。

    1. public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
    2.    this.publicMethodsOnly = publicMethodsOnly;
    3.    if (jta12Present || ejb3Present) {
    4.       this.annotationParsers = new LinkedHashSet<>(4);
    5.       this.annotationParsers.add(new SpringTransactionAnnotationParser());
    6.       if (jta12Present) {
    7.          this.annotationParsers.add(new JtaTransactionAnnotationParser());
    8.       }
    9.       if (ejb3Present) {
    10.          this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
    11.       }
    12.    }
    13.    else {
    14.       this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
    15.    }
    16. }
    17. 复制代码

    AnnotationTransactionAttributeSource 的构造方法中，主要初始化了两个属性。

    • publicMethodsOnly 的值，从上一段代码的方法调用this(true)传入，它的值是true。
    • annotationParsers 是一个列表，根据当前类加载器能够加载到的类型，添加不同的事物注解解析器，限于本文讨论的范围，我们只考虑 SpringTransactionAnnotationParser。

    advice 属性

    advice 属性的值，同样来自方法参数，它包含的是 Advisor 的增强逻辑，这里注入的值是 TransactionInterceptor 类型，来源也是用一配置类中的另一个方法。

    1. // org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration#transactionInterceptor
    2. @Bean
    3. @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    4. public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
    5.    TransactionInterceptor interceptor = new TransactionInterceptor();
    6.    interceptor.setTransactionAttributeSource(transactionAttributeSource);
    7.    if (this.txManager != null) {
    8.       interceptor.setTransactionManager(this.txManager);
    9.    }
    10.    return interceptor;
    11. }
    12. 复制代码

    它的构造方法也不包含任何逻辑，并且，注入了上一部分介绍了 transactionAttributeSource。除此之外，如果成员变量txManager不为空，则赋值给他的 transactionManager 属性。

    transactionManager 是事务管理器，可以在当前配置类的父类中，找到它的来源。

    TransactionManager

    以下就是初始化成员变量txManager的方法。

    1. @Autowired(required = false)
    2. void setConfigurers(Collection<TransactionManagementConfigurer> configurers) {
    3.    if (CollectionUtils.isEmpty(configurers)) {
    4.       return;
    5.    }
    6.    if (configurers.size() > 1) {
    7.       throw new IllegalStateException("Only one TransactionManagementConfigurer may exist");
    8.    }
    9.    TransactionManagementConfigurer configurer = configurers.iterator().next();
    10.    this.txManager = configurer.annotationDrivenTransactionManager();
    11. }
    12. 复制代码

    方法添加了 @Autowired 注解，参数是 TransactionManagementConfigurer 类型的集合，Spring 会找到容器中所有的该类型的 Bean，组成一个集合，作为参数执行这个方法的逻辑。

    当方法传入的集合中有且只有一个元素的时候，它的annotationDrivenTransactionManager会被执行，并将的到的结果赋值给txManager。

    以下是 TransactionManagementConfigurer 接口的定义。

    1. public interface TransactionManagementConfigurer {
    2. TransactionManager annotationDrivenTransactionManager();
    3. }
    4. 复制代码

    里面只有一个方法，返回 TransactionManager 类型的结果，一个配置类可以通过实现 TransactionManagementConfigurer 接口来自定义 TransactionManager 的创建逻辑。

    pointcut 属性

    除了配置方法中设置的值以外，BeanFactoryTransactionAttributeSourceAdvisor 还有一个定义了初始值的属性pointcut，它表示切入点，负责匹配目标类和目标方法。

    1. // org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor#pointcut
    2. private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
    3.    @Override
    4.    @Nullable
    5.    protected TransactionAttributeSource getTransactionAttributeSource() {
    6.       return transactionAttributeSource;
    7.    }
    8. };
    9. 复制代码

    pointcut属性的类型是 TransactionAttributeSourcePointcut，并在初始化时实现了getTransactionAttributeSource方法。

    进入 TransactionAttributeSourcePointcut 的构造方法。

    1. // org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut#TransactionAttributeSourcePointcut
    2. protected TransactionAttributeSourcePointcut() {
    3.    setClassFilter(new TransactionAttributeSourceClassFilter());
    4. }
    5. 复制代码

    构造方法中调用了setClassFilter方法给classFilter成员变量赋值，值是一个通过构造方法创建的 TransactionAttributeSourceClassFilter 类型的实例。

    TransactionAttributeSourceClassFilter 是 TransactionAttributeSourcePointcut 的内部类，以下是它的源码。

    1. private class TransactionAttributeSourceClassFilter implements ClassFilter {
    2.  
    3.    @Override
    4.    public boolean matches(Class<?> clazz) {
    5.       if (TransactionalProxy.class.isAssignableFrom(clazz) ||
    6.             PlatformTransactionManager.class.isAssignableFrom(clazz) ||
    7.             PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
    8.          return false;
    9.       }
    10.       TransactionAttributeSource tas = getTransactionAttributeSource();
    11.       return (tas == null || tas.isCandidateClass(clazz));
    12.    }
    13. }
    14. 复制代码

    我们都知道，在 Advisor 中，pointcut的主要作用是匹配目标类型和方法，以上的 ClassFilter 给 TransactionAttributeSourcePointcut 提供了一个类型匹配的具体逻辑。

    在通过 Pointcut 进行目标类型和方法的匹配时，会先从 Pointcut 中获取一个 ClassFilter 或 MethodMatcher，然后通过它们的matches方法来判断。

    TransactionAttributeSourcePointcut 中，获取 ClassFilter 和 MethodMatcher 的方法定义在其父类 StaticMethodMatcherPointcut 中。

    1. @Override
    2. public ClassFilter getClassFilter() {
    3.    return this.classFilter;
    4. }
    5.  
    6. @Override
    7. public final MethodMatcher getMethodMatcher() {
    8.    return this;
    9. }
    10. 复制代码

    其中，ClassFilter 就是在构造方法中初始化的 TransactionAttributeSourceClassFilter，而 MethodMatcher 就是其自身。

    下面分别来看一下，它是如何做目标类和方法的匹配的。

    目标类型匹配

    目标类型的匹配逻辑在 TransactionAttributeSourceClassFilter 类的matches方法中。

    1. // org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut.TransactionAttributeSourceClassFilter#matches
    2. @Override
    3. public boolean matches(Class<?> clazz) {
    4.    if (TransactionalProxy.class.isAssignableFrom(clazz) ||
    5.          PlatformTransactionManager.class.isAssignableFrom(clazz) ||
    6.          PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
    7.       return false;
    8.    }
    9.    TransactionAttributeSource tas = getTransactionAttributeSource();
    10.    return (tas == null || tas.isCandidateClass(clazz));
    11. }
    12. 复制代码

    首先，确保目标类型不是 TransactionalProxy、PlatformTransactionManager 或者 PersistenceExceptionTranslator，然后，通过getTransactionAttributeSource方法，获取到transactionAttributeSource属性，通过他的isCandidateClass方法来判断。

    1. // org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#isCandidateClass
    2. @Override
    3. public boolean isCandidateClass(Class targetClass) {
    4.    for (TransactionAnnotationParser parser : this.annotationParsers) {
    5.       if (parser.isCandidateClass(targetClass)) {
    6.          return true;
    7.       }
    8.    }
    9.    return false;
    10. }
    11. 复制代码

    isCandidateClass方法的逻辑，就是遍历annotationParsers集合中的每一个 TransactionAnnotationParser 元素，执行过它们的isCandidateClass方法，进行判断。

    根据之前的分析，我们这里只考虑集合中包含 SpringTransactionAnnotationParser 的情况，以下是它的isCandidateClass方法。

    1. // org.springframework.transaction.annotation.SpringTransactionAnnotationParser#isCandidateClass
    2. @Override
    3. public boolean isCandidateClass(Class<?> targetClass) {
    4.    return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
    5. }
    6. 复制代码

    再进入 AnnotationUtils 的isCandidateClass方法。

    1. // org.springframework.core.annotation.AnnotationUtils#isCandidateClass(java.lang.Class<?>, java.lang.Class<? extends java.lang.annotation.Annotation>)
    2. public static boolean isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType) {
    3.    return isCandidateClass(clazz, annotationType.getName());
    4. }
    5.  
    6. // org.springframework.core.annotation.AnnotationUtils#isCandidateClass(java.lang.Class<?>, java.lang.String)
    7. public static boolean isCandidateClass(Class<?> clazz, String annotationName) {
    8.    if (annotationName.startsWith("java.")) {
    9.       return true;
    10.    }
    11.    if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) {
    12.       return false;
    13.    }
    14.    return true;
    15. }
    16. 复制代码

    如果类的名称是java.开头的，则返回true。然后，再 AnnotationsScanner 的hasPlainJavaAnnotationsOnly方法判断，除了此方法返回true的类型，其余情况都返回true。

    1. // org.springframework.core.annotation.AnnotationsScanner#hasPlainJavaAnnotationsOnly(java.lang.Class<?>)
    2. static boolean hasPlainJavaAnnotationsOnly(Class<?> type) {
    3.    return (type.getName().startsWith("java.") || type == Ordered.class);
    4. }
    5. 复制代码

    名称以java.开头的情况前面已经判断过了，因此这里就是判断类型是否是 Ordered 类型。

    总结下来，匹配类的逻辑就是，确保类不是 TransactionalProxy、PlatformTransactionManager、PersistenceExceptionTranslator、Ordered 这几种类型之一。

    目标方法匹配

    方法的匹配逻辑在 TransactionAttributeSourcePointcut 的matches方法中。

    1. @Override
    2. public boolean matches(Method method, Class<?> targetClass) {
    3.    TransactionAttributeSource tas = getTransactionAttributeSource();
    4.    return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    5. }
    6. 复制代码

    匹配的逻辑依然是通过成员变量transactionAttributeSource的getTransactionAttribute方法，从方法获取事务相关的注解配置属性信息，如果获取到的结果不为空，则符合匹配条件。

    AnnotationTransactionAttributeSource 中的getTransactionAttribute方法，继承自父类 AbstractFallbackTransactionAttributeSource。

    1. // org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#getTransactionAttribute
    2. @Override
    3. @Nullable
    4. public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
    5.    if (method.getDeclaringClass() == Object.class) {
    6.       return null;
    7.    }
    8.  
    9.    // First, see if we have a cached value.
    10.    Object cacheKey = getCacheKey(method, targetClass);
    11.    TransactionAttribute cached = this.attributeCache.get(cacheKey);
    12.    if (cached != null) {
    13.       // Value will either be canonical value indicating there is no transaction attribute,
    14.       // or an actual transaction attribute.
    15.       if (cached == NULL_TRANSACTION_ATTRIBUTE) {
    16.          return null;
    17.       }
    18.       else {
    19.          return cached;
    20.       }
    21.    }
    22.    else {
    23.       // We need to work it out.
    24.       TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
    25.       // Put it in the cache.
    26.       if (txAttr == null) {
    27.          this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
    28.       }
    29.       else {
    30.          String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
    31.          if (txAttr instanceof DefaultTransactionAttribute) {
    32.             ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
    33.          }
    34.          if (logger.isTraceEnabled()) {
    35.             logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
    36.          }
    37.          this.attributeCache.put(cacheKey, txAttr);
    38.       }
    39.       return txAttr;
    40.    }
    41. }
    42. 复制代码

    首先判断方法不是在 Object 类中声明的，然后，从缓存中读取数据，如果缓存中没有数据，则执行获取注解配置信息的逻辑。因此，这个方法中重点要分析的逻辑是最外层的else语句块中的逻辑。

    方法最终返回的txAttr是通过computeTransactionAttribute方法得到的，无论获取到的txAttr是否为空，都会将其添加到缓存集合attributeCache中，并最终作为结果返回。

    computeTransactionAttribute的源码如下。

    1. // org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#computeTransactionAttribute
    2. @Nullable
    3. protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class targetClass) {
    4.    // Don't allow no-public methods as required.
    5.    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
    6.       return null;
    7.    }
    8.  
    9.    // The method may be on an interface, but we need attributes from the target class.
    10.    // If the target class is null, the method will be unchanged.
    11.    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    12.  
    13.    // First try is the method in the target class.
    14.    TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
    15.    if (txAttr != null) {
    16.       return txAttr;
    17.    }
    18.  
    19.    // Second try is the transaction attribute on the target class.
    20.    txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
    21.    if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
    22.       return txAttr;
    23.    }
    24.  
    25.    if (specificMethod != method) {
    26.       // Fallback is to look at the original method.
    27.       txAttr = findTransactionAttribute(method);
    28.       if (txAttr != null) {
    29.          return txAttr;
    30.       }
    31.       // Last fallback is the class of the original method.
    32.       txAttr = findTransactionAttribute(method.getDeclaringClass());
    33.       if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
    34.          return txAttr;
    35.       }
    36.    }
    37.  
    38.    return null;
    39. }
    40. 复制代码

    方法的逻辑并不复杂，大致如下：

    1. 如果事务注解只对public修饰的方法有效，但是当前的目标方法method不是public修饰的方法，直接返回空。
    2. 通过 AopUtils 的getMostSpecificMethod方法，获取目标方法method的具体实现方法，也就是说，如果当前的目标方法是一个接口中定义的方法，则根据当前目标类型获取到类型中的实现方法specificMethod。
    3. 通过findTransactionAttribute方法从specificMethod获取 TransactionAttribute，如果不为空，则作为结果返回。
    4. 通过findTransactionAttribute方法从specificMethod所在的类型获取 TransactionAttribute，如果不为空，则作为结果返回。
    5. 如果method和specificMethod不是同一个方法，则对method和它所在的类型执行3、4步的操作。
    6. 以上都得不到结果的情况下，返回空。

    上面的步骤中，获取 TransactionAttribute 的findTransactionAttribute方法被多次调用，它的定义如下。

    1. // org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#findTransactionAttribute(java.lang.Class<?>)
    2. @Override
    3. @Nullable
    4. protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
    5.    return determineTransactionAttribute(clazz);
    6. }
    7.  
    8. // org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#findTransactionAttribute(java.lang.reflect.Method)
    9. @Override
    10. @Nullable
    11. protected TransactionAttribute findTransactionAttribute(Method method) {
    12.    return determineTransactionAttribute(method);
    13. }
    14. 复制代码

    其中的具体逻辑交给了determineTransactionAttribute方法。

    1. // org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#determineTransactionAttribute
    2. @Nullable
    3. protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
    4.    for (TransactionAnnotationParser parser : this.annotationParsers) {
    5.       TransactionAttribute attr = parser.parseTransactionAnnotation(element);
    6.       if (attr != null) {
    7.          return attr;
    8.       }
    9.    }
    10.    return null;
    11. }
    12. 复制代码

    主要的逻辑就是遍历annotationParsers集合中的注解解析器，来解析参数中传入的 AnnotatedElement，来获取 TransactionAttribute。前面我们提到过，这里的注解解析器，我们只考虑 SpringTransactionAnnotationParser，因此，进入它的parseTransactionAnnotation方法。

    1. // org.springframework.transaction.annotation.SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)
    2. @Override
    3. @Nullable
    4. public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
    5.    AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
    6.          element, Transactional.class, false, false);
    7.    if (attributes != null) {
    8.       return parseTransactionAnnotation(attributes);
    9.    }
    10.    else {
    11.       return null;
    12.    }
    13. }
    14. 复制代码

    逻辑非常简单，就是获取到方法或者类上的 Transactional 注解，然后将注解的属性封装成一个 TransactionAttribute 并返回。

    总结下来就是，如果目标方法或者所在的类型，标记了 Transactional 注解，那么就会被负责事务管理的拦截器匹配到，并对其进行增强。

    增强逻辑

    了解了目标类型和方法的匹配，最后在看具体的增强逻辑。根据 Spring AOP 的机制，执行增强逻辑时，需要从 BeanFactoryTransactionAttributeSourceAdvisor 对象中，通过getAdvice方法，获取到增强逻辑的拦截器，再执行拦截器的invoke方法。

    前文中已经介绍过，BeanFactoryTransactionAttributeSourceAdvisor 的advice属性是在配置类中初始化的，它的类型是 TransactionInterceptor，它的主要继承关系如下。

    可以确认，它实现了 MethodInterceptor 接口，并且它的invoke方法，就是增强逻辑所在的方法。

    1. // org.springframework.transaction.interceptor.TransactionInterceptor#invoke
    2. @Override
    3. @Nullable
    4. public Object invoke(MethodInvocation invocation) throws Throwable {
    5.    // Work out the target class: may be {@code null}.
    6.    // The TransactionAttributeSource should be passed the target class
    7.    // as well as the method, which may be from an interface.
    8.    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    9.  
    10.    // Adapt to TransactionAspectSupport's invokeWithinTransaction...
    11.    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    12. }
    13. 复制代码

    其中的核心逻辑是调用了定义在父类 TransactionAspectSupport 中的invokeWithinTransaction方法。

    先分析方法的参数。其中，method和targetClass是目标方法和类型，相比起来，更值得注意的是第三个参数invocation，它的类型是 InvocationCallback。

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport.InvocationCallback
    2. @FunctionalInterface
    3. protected interface InvocationCallback {
    4.  
    5.    Object proceedWithInvocation() throws Throwable;
    6. }
    7. 复制代码

    InvocationCallback 是一个函数式接口，其中的proceedWithInvocation方法，返回了一个 Object 结果。在调用方法时，这里传入的值是invocation::proceed，也就是说，这里的invocation参数传入的是目标方法的调用。了解完参数后，再看方法体。

    这个方法的代码超过了 100 行，我们只分析其中的核心部分，完整的方法体代码可以到 TransactionAspectSupport 类的源码中查看。

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction
    2.  
    3. // If the transaction attribute is null, the method is non-transactional.
    4. TransactionAttributeSource tas = getTransactionAttributeSource();
    5. final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
    6. final TransactionManager tm = determineTransactionManager(txAttr);
    7.  
    8. // 省略部分代码
    9.  
    10. PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    11. final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
    12.  
    13. if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
    14.    // Standard transaction demarcation with getTransaction and commit/rollback calls.
    15.    TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
    16.  
    17.    Object retVal;
    18.    try {
    19.       // This is an around advice: Invoke the next interceptor in the chain.
    20.       // This will normally result in a target object being invoked.
    21.       retVal = invocation.proceedWithInvocation();
    22.    }
    23.    catch (Throwable ex) {
    24.       // target invocation exception
    25.       completeTransactionAfterThrowing(txInfo, ex);
    26.       throw ex;
    27.    }
    28.    finally {
    29.       cleanupTransactionInfo(txInfo);
    30.    }
    31.  
    32.    if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
    33.       // Set rollback-only in case of Vavr failure matching our rollback rules...
    34.       TransactionStatus status = txInfo.getTransactionStatus();
    35.       if (status != null && txAttr != null) {
    36.          retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
    37.       }
    38.    }
    39.  
    40.    commitTransactionAfterReturning(txInfo);
    41.    return retVal;
    42. }
    43.  
    44. // 省略部分代码
    45. 复制代码

    方法体中的内容，可以归纳为以下几个关键步骤：

    • 通过createTransactionIfNecessary方法，得到一个 TransactionInfo 类型的txInfo对象。从方法名称和返回的结果来看，这一步应该是根据需要创建了事务，并得到事务的信息。
    • 然后，在try语句中调用目标方法，并的到执行的返回值retVal。
    • 如果执行目标方法的过程中出现了异常，则执行completeTransactionAfterThrowing方法，处理异常的情况，再将异常抛出。
    • 在finally语句块中执行cleanupTransactionInfo方法，清除异常信息。
    • 如果上述过程中没有出现异常，则执行commitTransactionAfterReturning方法，提交事务。

    从上述归纳中可以看出，最主要的步骤都是通过调用相应的方法来完成的，接下来，我们就逐一分析这些方法。

    createTransactionIfNecessary 方法

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport#createTransactionIfNecessary
    2. @SuppressWarnings("serial")
    3. protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
    4.       @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
    5.  
    6.    // If no name specified, apply method identification as transaction name.
    7.    if (txAttr != null && txAttr.getName() == null) {
    8.       txAttr = new DelegatingTransactionAttribute(txAttr) {
    9.          @Override
    10.          public String getName() {
    11.             return joinpointIdentification;
    12.          }
    13.       };
    14.    }
    15.  
    16.    TransactionStatus status = null;
    17.    if (txAttr != null) {
    18.       if (tm != null) {
    19.          status = tm.getTransaction(txAttr);
    20.       }
    21.       else {
    22.          if (logger.isDebugEnabled()) {
    23.             logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
    24.                   "] because no transaction manager has been configured");
    25.          }
    26.       }
    27.    }
    28.    return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    29. }
    30. 复制代码

    其中，有一行关键的代码，如下：

    1. status = tm.getTransaction(txAttr);
    2. 复制代码

    这里对执行tm的getTransaction方法，获取食物状态，开启事务也是在这里完成的。tm的类型是 PlatformTransactionManager，它是一个事务管理器对象。事务管理器是在 Spring 的事务管理配置类中注册到 Spring 容器的，这一部分在前文已经介绍过。

    事务管理器中会通过 JDBC 的方式，获取到数据库连接对象 Connection，通过调用setAutoCommit(false)将自动提交设置为false，就开启了事务。

    目标方法的执行

    开启事务之后，就可以开始执行目标方法了，由于目标方法执行时抛出的异常可能会导致事务会滚，因此，目标方法的调用被放在了try语句块中，方便对抛出的一场进行处理。

    completeTransactionAfterThrowing 方法

    如果目标方法跑出了一场，则会交给catch语句块中的completeTransactionAfterThrowing方法来处理。

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowing
    2. protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
    3.    if (txInfo != null && txInfo.getTransactionStatus() != null) {
    4.       if (logger.isTraceEnabled()) {
    5.          logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
    6.                "] after exception: " + ex);
    7.       }
    8.       if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
    9.          try {
    10.             txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
    11.          }
    12.          catch (TransactionSystemException ex2) {
    13.             logger.error("Application exception overridden by rollback exception", ex);
    14.             ex2.initApplicationException(ex);
    15.             throw ex2;
    16.          }
    17.          catch (RuntimeException | Error ex2) {
    18.             logger.error("Application exception overridden by rollback exception", ex);
    19.             throw ex2;
    20.          }
    21.       }
    22.       else {
    23.          // We don't roll back on this exception.
    24.          // Will still roll back if TransactionStatus.isRollbackOnly() is true.
    25.          try {
    26.             txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
    27.          }
    28.          catch (TransactionSystemException ex2) {
    29.             logger.error("Application exception overridden by commit exception", ex);
    30.             ex2.initApplicationException(ex);
    31.             throw ex2;
    32.          }
    33.          catch (RuntimeException | Error ex2) {
    34.             logger.error("Application exception overridden by commit exception", ex);
    35.             throw ex2;
    36.          }
    37.       }
    38.    }
    39. }
    40. 复制代码

    这个方法的源码虽然不少，但是逻辑其实非常简单。首先，会判断当前抛出的异常是不是属于 Transaction 注解中rollbackFor属性配置的异常的范畴，如果是，则说明当前抛出的异常，是需要回滚的异常，此时，就会调用事务管理器的rollback方法进行回滚，否则，通过commit方法进行提交，不过这里的提交并不是直接提交事务，而是在提交前会判断事务信息，只在符合提交条件的情况下进行提交。

    cleanupTransactionInfo 方法

    在目标方法执行的finally语句块中会cleanupTransactionInfo方法，从方法名称可以看出它的作用是清理事务信息。

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport#cleanupTransactionInfo
    2. protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
    3.    if (txInfo != null) {
    4.       txInfo.restoreThreadLocalStatus();
    5.    }
    6. }
    7. 复制代码

    它的作用其实就是将 ThreadLocal 中保存的当前事务的信息恢复到当前事务开启之前的状态。

    commitTransactionAfterReturning 方法

    最后，commitTransactionAfterReturning方法负责事务的提交。

    1. // org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturning
    2. protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
    3.    if (txInfo != null && txInfo.getTransactionStatus() != null) {
    4.       if (logger.isTraceEnabled()) {
    5.          logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
    6.       }
    7.       txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
    8.    }
    9. }
    10. 复制代码

    走到这一步，说明前面的流程实行的都很顺利，因此，直接告诉事务管理器提交事务就可以了。

    总结

    本文通过对 BeanFactoryTransactionAttributeSourceAdvisor 类的分析，了解了 Spring 是如何通过 AOP 来完成事务的管理的，本文的内容需要你对 Spring 的 AOP 的实现原理有一定的了解。

    由于本文的重点是 BeanFactoryTransactionAttributeSourceAdvisor 对提供事务管理功能的分析，遇到涉及太多 Spring 的事务抽象相关的内容，没有做介绍，如果你对此感兴趣，可以搜索相关的文章了解其中的细节。

  • 相关阅读:
    .NET微信网页开发相关文章教程
    Jan 2023-Prioritizing Samples in Reinforcement Learning with Reducible Loss
    Stable Diffusion webui 常用启动参数
    ACL2024 | AI的时空穿越记：大型语言模型共时推理的奇幻之旅！
    vue - Vue脚手架（终结篇）/ vue动画
    C++---红黑树介绍及简单实现
    【C++详解】——类和对象（下）（初始化列表、static成员、友元、匿名对象）
    代码随想录刷题Day51 | 309. 最佳买卖股票时机含冷冻期 | 714. 买卖股票的最佳时机含手续费
    MySQL到TiDB：Hive Metastore横向扩展之路
    JVM内存模型篇【JVM内存模型】
  • 原文地址：https://blog.csdn.net/Trouvailless/article/details/127868107