一文搞懂Spring事务

配置注解版事务

事务管理器

• 事务管理器的接口是PlatformTransactionManager，其中定义了三个接口方法如下：
  • TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException：获取事务，如果当前没有事务，那么就根据传播级别创建一个事务。
    • TransactionDefinition：其中定义了事务的传播属性，比如默认的传播属性（当前没有事务就开启事务）等。
  • void commit(TransactionStatus status) throws TransactionException;：提交事务
    • TransactionStatus：其中定义了一些事务的状态和查询、判断事务状态的方法
  • void rollback(TransactionStatus status) throws TransactionException;：回滚事务
• PlatformTransactionManager的实现类有很多，比如结合JDBC操作的DataSourceTransactionManager、配置JTA、Hibernate的事务管理器。

注入事务管理器【JDBC】

• 注入PlatformTransactionManager，步骤如下：
  • 注入数据源，这里我们使用的是结合JDBC，因此需要注入对应的事务管理器DataSourceTransactionManager

    
    //注入数据源，这里使用的是阿里的Druid，这里只是简单的配置
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("******");
        dataSource.setPassword("*****");
        dataSource.setUrl("******");
        dataSource.setInitialSize(10);
        dataSource.setMaxActive(20);
        dataSource.setMaxIdle(100000);
        return dataSource;
    }

    //注入事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        return dataSourceTransactionManager;
    }

• 开启事务，使用@EnableTransactionManagement

@Configuration
@ComponentScan(basePackages = {"cn.tedu.demo.*"})
@EnableTransactionManagement
public class MainConfig {}

源码解析事务

必知的知识和类

PlatformTransactionManager

• 事务管理器的接口，其中定义一些事务的方法，有提交，回滚，获取事务的方法。
• 实现类如下：
  • DataSourceTransactionManager：适用于JDBC事务的管理
  • JtaTransactionManager：适用于多数据源的事务管理，实现强一致性事务

TransactionDefinition

• 该接口主要定义了事务的一些属性，比如事务的传播行为，隔离级别等数据。

@EnableTransactionManagement

• 此注解的源码如下，其实真正起作用的就是@Import(TransactionManagementConfigurationSelector.class)，使用@Import这个注解向容器中注入了其他的Bean，详情请看我的Spring注解版开发，其中有@Import的使用

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {

TransactionManagementConfigurationSelector

• 这个实现了ImportSelector，结合@Import注解使用，是@Import注解的注入Bean的其中一种方式，有一个必须重载的方法，如下：
  • 此方法返回的BeanName的数组的全部Bean将会被注入到容器中

String[] selectImports(AnnotationMetadata importingClassMetadata);

• TransactionManagementConfigurationSelector对上面的这个方法重写了，如下：
  • 主要流程就是根据@EnableTransactionManagement中mode属性返回对应的BeanName，如果值是PROXY【默认】，那么就会注入AutoProxyRegistrar、ProxyTransactionManagementConfiguration这两个Bean，那么这个方法的作用就是如此，因此我们需要看看注入的两个Bean到底是什么作用？

    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
        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);
    }

AutoProxyRegistrar

• 该类实现了ImportBeanDefinitionRegistrar，主要的作用就是根据@EnableTransactionManagement属性中的mode和proxyTargetClass，注入对应的AutoProxyCreator【APC】，代码如下：

    //importingClassMetadata：其中封装了配置类的所有注解
    //registry：用于注入BeanDefintion
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //标记
        boolean candidateFound = false;
        //获取所有的注解类型
        Set annoTypes = importingClassMetadata.getAnnotationTypes();
        //遍历注解
        for (String annoType : annoTypes) {
            //获取指定注解的全部属性的值
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
            if (candidate == null) {
                continue;
            }
            //获取对应的mode和proxyTargetClass属性的值
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            //如果这些值都存在，那么可以判定配置类上标注了`@EnableTransactionManagement`这个注解
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&  
                    Boolean.class == proxyTargetClass.getClass()) {
                //标记设置为true
                candidateFound = true;
                //根据mode的值，注入不同的APC
                if (mode == AdviceMode.PROXY) {
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    if ((Boolean) proxyTargetClass) {
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
        if (!candidateFound && logger.isInfoEnabled()) {
            String name = getClass().getSimpleName();
            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));
        }
    }

• 其中核心的代码就是注入不同的APC的代码，如下：

  • AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);

    • 实际作用的源码如下：

    //cls是InfrastructureAdvisorAutoProxyCreator.class，APC的一种实现类
    //注入的BeanName是org.springframework.aop.config.internalAutoProxyCreator
    private static BeanDefinition registerOrEscalateApcAsRequired(
                Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    
            Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
            //判断对应的APC是否已经注入了
            if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
                BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
                if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                    int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                    int requiredPriority = findPriorityForClass(cls);
                    if (currentPriority < requiredPriority) {
                        apcDefinition.setBeanClassName(cls.getName());
                    }
                }
                return null;
            }
            
            //没有注入，直接使用RootBeanDefinition注入，BeanName是org.springframework.aop.config.internalAutoProxyCreator
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
            beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
            return beanDefinition;
        }
    

• AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);：强制使用子类代理【cglib代理】，实际作用的源码如下：

  • 实际的作用就是设置了proxyTargetClass为true

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
      if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
          BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
          definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
      }
  }

总结

• 该类是TransactionManagementSlector选择器注入的类，主要作用就是根据@EnableTranactionMangement注解中的mode和proxyTarget的值注入（AutoProxyCreator）【简称APC】，实际的APC的类型是InfrastructureAdvisorAutoProxyCreator

ProxyTransactionManagementConfiguration

• 该类是一个配置类，如下：

//ProxyTransactionManagementConfiguration配置类
@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {}

//AbstractTransactionManagementConfiguration
@Configuration
public abstract class AbstractTransactionManagementConfiguration implements ImportAware {}

• 从上面的源码可以知道抽象的AbstractTransactionManagementConfiguration类实现了ImportAware，那么其中的重载的方法一定是很重要的，代码如下：

    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        //获取@EnableTransactionMangement的属性值赋值给enableTx
        this.enableTx = AnnotationAttributes.fromMap(
                importMetadata.getAnnotationAttributes(EnableTransactionManagement.class.getName(), false));
        //如果为null，抛出异常
        if (this.enableTx == null) {
            throw new IllegalArgumentException(
                    "@EnableTransactionManagement is not present on importing class " + importMetadata.getClassName());
        }
    }

• 上述讲解了AbstractTransactionManagementConfiguration中的一个重要实现，其实就是将@EnableTransactionMangement的属性值赋值给enableTx
• 从ProxyTransactionManagementConfiguration的源码可以知道，其实就是向容器中注入了三个Bean，分别是org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor、org.springframework.transaction.interceptor.TransactionAttributeSource、org.springframework.transaction.interceptor.TransactionInterceptor

ImportAware

• 该类的作用是获取标注在实现了该接口的配置类上的所有注解的元数据，包括注解的属性，值，类型等信息。

• ImportAware同样实现了Aware接口，但是这个和BeanFactoryAware、ResourceLoaderAware等不同的是，这个接口必须是由配置类【即是标注了@Configuration注解】实现，并且需要结合@Import注解使用才能生效，否则不能生效，如下的使用方式将会生效。

  • 一定要结合@Import使用，可以直接导入配置类，也可以使用selector方式的注入，总之是要结合@Import注解使用，否则不能生效

@Configuration
@ComponentScan(basePackages = {"cn.tedu.demo.*"})
@EnableTransactionManagement
@Import(value = {DruidConfig.class})
public class MainConfig  {}


@Configuration
public class DruidConfig implements ImportAware {
    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        System.out.println(importMetadata);
    }
}

InfrastructureAdvisorAutoProxyCreator【@EnableTransactionManagement导入】

• 该APC是在@EnableTransactionMangement注解作用下注入到ioc容器中的

• 代理创建器，继承了AbstractAutoProxyCreator，这个和注解版AOP的代理创建器（AnnotationAwareAspectJAutoProxyCreator）继承的是一个类，主要的作用就是创建代理对象，我们之前也是知道事务的底层其实就是使用AOP进行操作的，继承的关系图如下：

[图片上传失败...(image-d23350-1562499352984)]

• 从上面的继承关系图可以很清晰的看到，这个类实现了不少的关于Bean生命周期的接口，因此我们只需要把实现的这些接口打上断点，即可清楚的分析出执行的流程了。这个和AOP讲解的类似，有些东西就不再一一讲述了
• 主要的功能就是为标注了@Transactional创建代理对象，其中最重要的逻辑就是找到候选的增强器【事务的实现注入的增强器就是BeanFactoryTransactionAttributeSourceAdvisor】，主要的逻辑如下：

1）在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary方法中是创建代理对象的主要方法，不过在这之前需要获取所有适用当前Bean的所有增强器（Advisor），调用的是Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);这个方法
    1.1) 进入org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean方法，调用的是List advisors = findEligibleAdvisors(beanClass, beanName)这段代码，获取可用的增强器
    1.2） 进入，实际调用的是List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName)这段代码，获取能够作用在beanClass的增强器
    1.3）进入，实际调用的是AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass)这段代码
    1.4）一路跟进，最终到了org.springframework.aop.support.AopUtils#canApply(org.springframework.aop.Pointcut, ava.lang.Class, boolean)，主要的逻辑开始了
        1.4.1） 最重要的代码便是循环获取的接口，获取其中的方法，调用methodMatcher.matches(method, targetClass)匹配，源码如下：
        for (Class clazz : classes) {
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            for (Method method : methods) {
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }
        1.4.2）跟进，进入了org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#computeTransactionAttribute方法，主要的逻辑就是先判断当前Bean的所有方法是否有@Transactional注解，之后判断该类头上是否有@Transactional注解
        1.4.3）最重要的解析是否存在@Transactional注解的方法就是org.springframework.transaction.annotation.SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)，其中的逻辑如下：

        public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        //获取注解@Transactional中的属性值
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        //如果属性值不为空，表示该类获取方法上标注了@Transactional注解
        if (attributes != null) {
            //解析注解的属性值，封装在TransactionAttribute中返回
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }
    //解析注解的属性值，将其封装在TransactionAttribute中
protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));

        List 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));
        }
        for (Class rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

SpringTransactionAnnotationParser

• @Transactional注解解析器，主要的作用就是解析指定类或者方法【标注有@Transactional注解的】上的@Transactional注解中的属性值，将其封装在 TransactionAttribute中，主要的逻辑如下：

public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        //获取注解中的所有属性值
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            //如果属性不为空，调用parseTransactionAnnotation方法封装
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

        //封装传播行为和隔离级别
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));
        
        //封装回滚规则
        List 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));
        }
        for (Class rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

AnnotationTransactionAttributeSource【@EnableTransactionManagement导入】

• 实现了TransactionAttributeSource，简单的说这个类中封装了所有类、方法上标注的@Transactional注解的属性值【以TransactionAttribute的属性保存在private final Map attributeCache = new ConcurrentHashMap<>(1024)，key是通过类，方法生成的MethodClassKey对象，value是TransactionAttribute】

• 重要的属性：

  • attributeCache中存储了所有类的方法的对应的@Transactional注解属性的值，后续在执行事务的时候，就是直接从这个缓存中直接获取的。

• 其中有几个重要的方法，如下：

  • public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class targetClass)：根据类、方法获取指定的TransactionAttribute ，具体的实现在AbstractFallbackTransactionAttributeSource类中，源码如下：
    • 其中findTransactionAttribute()方法没有继续跟进，因为其中的执行逻辑就是使用注解解析器（SpringTransactionalAnnotationParser）进行对@Transactional注解的解析，封装在TransactionAttribute返回。
    • attributeCache中存储了所有类的方法的对应的@Transactional注解属性的值，后续在执行事务的时候，就是直接从这个缓存中直接获取的。

  //method：指定的方法，targetClass指定的类
  public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class targetClass) {
        //如果是Object，直接返回null
        if (method.getDeclaringClass() == Object.class) {
            return null;
        }
  
        // 第一步先直接从缓存中取值，如果存在，直接返回即可
        Object cacheKey = getCacheKey(method, targetClass);
        TransactionAttribute cached = this.attributeCache.get(cacheKey);
        if (cached != null) {
            // Value will either be canonical value indicating there is no transaction attribute,
            // or an actual transaction attribute.
            if (cached == NULL_TRANSACTION_ATTRIBUTE) {
                return null;
            }
            else {
                return cached;
            }
        }
        else {
            //如果缓存中没有，那么需要调用computeTransactionAttribute方法去ioc中解析
            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
            //将取出的值存入缓存中，下次再取就不需要解析了，直接取值即可
            if (txAttr == null) {
                this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
            }
            else {
                  //获取方法的名称，全类名+方法名的形式
                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);
                }
                this.attributeCache.put(cacheKey, txAttr);
            }
            return txAttr;
        }
    }
  
  
  /**********************************computeTransactionAttribute****************/
  protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class targetClass) {
        //如果方法不是public类型的，直接返回null
        if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
            return null;
        }
  
        //如果method方法是在接口中定义的方法，那么获取接口实现类的方法。
        Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
  
        // 尝试获取目标方法上标注的@Transactional注解的属性【因为这个注解可以标注在方法和类上】
        TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
        if (txAttr != null) {
            return txAttr;
        }
  
        // 获取标注在类上的注解的属性
        txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }
      
        if (specificMethod != method) {
            // Fallback is to look at the original method.
            txAttr = findTransactionAttribute(method);
            if (txAttr != null) {
                return txAttr;
            }
            // Last fallback is the class of the original method.
            txAttr = findTransactionAttribute(method.getDeclaringClass());
            if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
                return txAttr;
            }
        }
  
        return null;
    }
  

• protected TransactionAttribute findTransactionAttribute(Class clazz)：获取指定类上的@Transactional的属性值

• protected TransactionAttribute findTransactionAttribute(Method method)：获取指定方法的上的@Transactional属性的值

• protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element)：获取@Transactional属性值的真正调用的方法，执行的逻辑就是使用前面讲过的SpringTransactionAnnotationParser进行注解的解析，代码如下：

protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        //遍历可用的事务注解解析器->this.annotationParsers
        for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
            //调用解析的方法，进行解析
            TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }

/***org.springframework.transaction.annotation.SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)****/
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        //直接获取元素上@Transactional注解的属性，如果获取都了，将其解析成TransactionAttribute对象返回即可
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            return parseTransactionAnnotation(attributes);
        }
        //不存在该注解，那么直接返回null
        else {
            return null;
        }
    

BeanFactoryTransactionAttributeSourceAdvisor【@EnableTransactionManagement导入】

• 事务的增强器，其中封装了拦截器和Advice。

TransactionInterceptor【重要】

• 事务拦截器，顾名思义，就是在方法执行之前进行一些操作，开启事务就是使用拦截器在调用方法之前开启的。

• 其中几个重要的方法，如下：

  • public Object invoke(MethodInvocation invocation)：jdk动态代理执行拦截器链的时候会执行的方法，内部真正调用的是父类TransactionAspectSupport的invokeWithinTransaction方法
  • protected Object invokeWithinTransaction(Method method, @Nullable Class targetClass, final InvocationCallback invocation)：以事务的方式调用，关于事务的周期，比如开启，提交，回滚等等都是从此方法进入的，源码如下：
    • TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);：从此段代码进去是开启事务的逻辑
    • completeTransactionAfterThrowing(txInfo, ex);：从此段代码进入是出现异常回滚事务的逻辑
    • commitTransactionAfterReturning(txInfo);：从此段代码进入是提交事务的逻辑

  protected Object invokeWithinTransaction(Method method, @Nullable Class targetClass,
            final InvocationCallback invocation) throws Throwable {
  
        // If the transaction attribute is null, the method is non-transactional.
        TransactionAttributeSource tas = getTransactionAttributeSource();
        final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
  
        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // This is an around advice: Invoke the next interceptor in the chain.
                // This will normally result in a target object being invoked.
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // target invocation exception
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }
  

调用标注@Transactional方法

前提

• 事务默认使用的是JDK的动态代理，并不是cglib代理
• 方法或者类上标注了@Transactional注解
• 配置类标注了@EnableTransactionManagement，开启事务

解析

• 调用标注有@Transactional注解的方法，进入了org.springframework.aop.framework.JdkDynamicAopProxy#invoke方法，进行了JDK的动态代理，源码如下：
  • this.advised：其实就是ProxyFactory（代理工厂），其中在创建代理对象的时候，封装了targetSource和事务增强器（BeanFactoryTransactionAttributeSourceAdvisor）
  • 其中最重要的一段代码就是List