Spring系列第48篇：@Transaction事务源码解析

star2017 1年前 ⋅ 268 阅读

大家好，今天咱们通过源码来了解一下spring中@Transaction事务的原理。

在这里插播两句，整个系列前后知识是有依赖的，大家最好按顺序阅读，这样不会出现无法理解的情况，若跳着读，可能会比较懵。。。

1、环境

  1. jdk1.8
  2. Spring版本：5.2.3.RELEASE
  3. mysql5.7

2、@Transaction 事务的用法

咱们先来回顾一下，@Transaction 事务的用法，特别简单，2个步骤

1、在需要让spring管理事务的方法上添加 @Transaction 注解

2、在spring配置类上添加 @EnableTransactionManagement 注解，这步特别重要，别给忘了，有了这个注解之后，@Trasaction标注的方法才会生效。

3、@Transaction事务原理

原理比较简单，内部是通过spring aop的功能，通过拦截器拦截 @Transaction 方法的执行，在方法前后添加事务的功能。

4、@EnableTransactionManagement注解作用

@EnableTransactionManagement注解会开启spring自动管理事务的功能，有了这个注解之后，spring容器启动的过程中，会拦截所有bean的创建过程，判断bean 是否需要让spring来管理事务，即判断bean中是否有@Transaction注解，判断规则如下

1、一直沿着当前bean的类向上找，先从当前类中，然后父类、父类的父类，当前类的接口、接口父接口，父接口的父接口，一直向上找，一下这些类型上面是否有 @Transaction注解

2、类的任意public方法上面是否有@Transaction注解

如果bean满足上面任意一个规则，就会被spring容器通过aop的方式创建代理，代理中会添加一个拦截器

  1. org.springframework.transaction.interceptor.TransactionInterceptor

TransactionInterceptor 拦截器是关键，它会拦截@Trasaction方法的执行，在方法执行前后添加事务的功能，这个拦截器中大部分都是编程式事务的代码，若 大家看懂了，这个拦截器源码看起来就是小儿科了。

5、@EnableTransactionManagement源码解析

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import(TransactionManagementConfigurationSelector.class) //@1
  5. public @interface EnableTransactionManagement {
  7.     // 是基于类的代理（cglib），还是基于接口的代理（jdk动态代理），默认为false，表示是基于jdk动态代理
  8.     boolean proxyTargetClass() default false;
  10.     //通知的模式，默认是通过aop的方式
  11.     AdviceMode mode() default AdviceMode.PROXY;
  13.     // 我们知道这个注解的功能最终是通过aop的方式来实现的，对bean创建了一个代理，代理中添加了一个拦截器
  14.     // 当代理中还有其他拦截器的是时候，可以通过order这个属性来指定事务拦截器的顺序
  15.     // 默认值是 LOWEST_PRECEDENCE = Integer.MAX_VALUE,拦截器的执行顺序是order升序
  16.     int order() default Ordered.LOWEST_PRECEDENCE;
  18. }

注意@1这个代码

  1. @Import(TransactionManagementConfigurationSelector.class)

用到了@Import注解，对这个注解不熟悉的可以看一下，这个注解的value是TransactionManagementConfigurationSelector，看一下这个类的源码，重点是他的selectImports方法，这个方法会返回一个类名数组，spring容器启动过程中会自动调用这个方法，将这个方法指定的类注册到spring容器中；方法的参数是AdviceMode，这个就是@EnableTransactionManagement注解中mode属性的值，默认是PROXY，所以会走到@1代码处

  1. public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
  3.     @Override
  4.     protected String[] selectImports(AdviceMode adviceMode) {
  5.         switch (adviceMode) {
  6.             case PROXY: //@1
  7.                 return new String[] {AutoProxyRegistrar.class.getName(),
  8.                         ProxyTransactionManagementConfiguration.class.getName()};
  9.             case ASPECTJ:
  10.                 return new String[] {determineTransactionAspectClass()};
  11.             default:
  12.                 return null;
  13.         }
  14.     }
  16. }

最终会在spirng容器中注册下面这2个bean

  1. AutoProxyRegistrar
  2. ProxyTransactionManagementConfiguration

下面来看一下这2个类的代码。

AutoProxyRegistrar

这个类实现了ImportBeanDefinitionRegistrar接口，这个接口中有个方法registerBeanDefinitions，spring容器在启动过程中会调用这个方法，开发者可以在这个方法中做一些bean注册的事情，而AutoProxyRegistrar在这个方法中主要做的事情就是下面@1的代码，大家可以点进去看看，这里我就不点进去了，这个代码的作用就是在容器中做了一个非常关键的bean：InfrastructureAdvisorAutoProxyCreator，这个类之前在aop中介绍过，是bean后置处理器，会拦截所有bean的创建，对符合条件的bean创建代理。

  1. public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
  3.     @Override
  4.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  5.         boolean candidateFound = false;
  6.         Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
  7.         for (String annType : annTypes) {
  8.             AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
  9.             if (candidate == null) {
  10.                 continue;
  11.             }
  12.             Object mode = candidate.get("mode");
  13.             Object proxyTargetClass = candidate.get("proxyTargetClass");
  14.             if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
  15.                     Boolean.class == proxyTargetClass.getClass()) {
  16.                 candidateFound = true;
  17.                 if (mode == AdviceMode.PROXY) {
  18.                     AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);//@1
  19.                     if ((Boolean) proxyTargetClass) {
  20.                         AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
  21.                         return;
  22.                     }
  23.                 }
  24.             }
  25.         }
  26.     }
  27. }

说的简单点：AutoProxyRegistrar的作用就是启用spring aop的功能，对符合条件的bean创建代理。

ProxyTransactionManagementConfiguration

  1. @Configuration(proxyBeanMethods = false)
  2. public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
  3.     //注册bean：事务顾问（spring aop中拦截器链就是一个个的Advisor对象）
  4.     @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
  5.     @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  6.     public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
  7.             TransactionAttributeSource transactionAttributeSource,
  8.             TransactionInterceptor transactionInterceptor) {
  9.         BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
  10.         advisor.setTransactionAttributeSource(transactionAttributeSource);
  11.         //设置事务拦截器
  12.         advisor.setAdvice(transactionInterceptor);
  13.         if (this.enableTx != null) {
  14.             //设置aop中事务拦截器的顺序
  15.             advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
  16.         }
  17.         return advisor;
  18.     }
  20.     //注册bean:TransactionAttributeSource，TransactionAttributeSource用来获取获取事务属性配置信息：TransactionAttribute
  21.     @Bean
  22.     @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  23.     public TransactionAttributeSource transactionAttributeSource() { //@1
  24.         return new AnnotationTransactionAttributeSource();
  25.     }
  27.     //注册bean：事务拦截器
  28.     @Bean
  29.     @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  30.     public TransactionInterceptor transactionInterceptor(
  31.             TransactionAttributeSource transactionAttributeSource) {
  32.         TransactionInterceptor interceptor = new TransactionInterceptor();
  33.         interceptor.setTransactionAttributeSource(transactionAttributeSource);
  34.            //拦截器中设置事务管理器，txManager可以为空
  35.         if (this.txManager != null) {
  36.             interceptor.setTransactionManager(this.txManager);
  37.         }
  38.         return interceptor;
  39.     }
  41. }

是个配置类，代码比较简单，注册了3个bean，最重要的一点就是添加了事务事务拦截器：TransactionInterceptor。

AutoProxyRegistrar负责启用aop的功能，而ProxyTransactionManagementConfiguration负责在aop中添加事务拦截器，二者结合起来的效果就是：对@Transaction标注的bean创建代理对象，代理对象中通过TransactionInterceptor拦截器来实现事务管理的功能。

再看下代码@1，注册了一个TransactionAttributeSource类型的bean

TransactionAttributeSource接口源码：

  1. public interface TransactionAttributeSource {
  3.     /**
  4.      * 确定给定的类是否是这个TransactionAttributeSource元数据格式中的事务属性的候选类。
  5.      * 如果此方法返回false，则不会遍历给定类上的方法，以进行getTransactionAttribute内省。
  6.      * 因此，返回false是对不受影响的类的优化，而返回true仅仅意味着类需要对给定类上的每个方法进行完全自省。
  7.      **/
  8.     default boolean isCandidateClass(Class<?> targetClass) {
  9.         return true;
  10.     }
  12.     //返回给定方法的事务属性，如果该方法是非事务性的，则返回null。
  13.     TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass);
  15. }

getTransactionAttribute方法用来获取指定方法上的事务属性信息TransactionAttribute，大家对TransactionDefinition比较熟悉吧，用来配置事务属性信息的，而TransactionAttribute继承了TransactionDefinition接口，源码如下，而TransactionAttribute中新定义了2个方法，一个方法用来指定事务管理器bean名称的，一个用来判断给定的异常是否需要回滚事务

  1. public interface TransactionAttribute extends TransactionDefinition {
  3.     //事务管理器的bean名称
  4.     @Nullable
  5.     String getQualifier();
  7.     //判断指定的异常是否需要回滚事务
  8.     boolean rollbackOn(Throwable ex);
  10. }

TransactionAttributeSource接口有个实现类AnnotationTransactionAttributeSource，负责将@Transaction解析为TransactionAttribute对象，大家可以去这个类中设置一下断点看一下@Transaction注解查找的顺序，这样可以深入理解@Transaction放在什么地方才会让事务起效。

AnnotationTransactionAttributeSource内部最会委托给SpringTransactionAnnotationParser#parseTransactionAnnotation方法来解析@Transaction注解，进而得到事务属性配置信息：RuleBasedTransactionAttribute，代码如下：

  1. org.springframework.transaction.annotation.SpringTransactionAnnotationParser
  3. protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
  4.     RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
  6.     Propagation propagation = attributes.getEnum("propagation");
  7.     rbta.setPropagationBehavior(propagation.value());
  8.     Isolation isolation = attributes.getEnum("isolation");
  9.     rbta.setIsolationLevel(isolation.value());
  10.     rbta.setTimeout(attributes.getNumber("timeout").intValue());
  11.     rbta.setReadOnly(attributes.getBoolean("readOnly"));
  12.     rbta.setQualifier(attributes.getString("value"));
  14.     //回滚规则
  15.     List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
  16.     for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
  17.         rollbackRules.add(new RollbackRuleAttribute(rbRule));
  18.     }
  19.     for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
  20.         rollbackRules.add(new RollbackRuleAttribute(rbRule));
  21.     }
  22.     for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
  23.         rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
  24.     }
  25.     for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
  26.         rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
  27.     }
  28.     rbta.setRollbackRules(rollbackRules);
  30.     return rbta;
  31. }

下面来看重点了事务拦截器。

6、TransactionInterceptor

负责拦截@Transaction方法的执行，在方法执行之前开启spring事务，方法执行完毕之后提交或者回滚事务。

在讲这个类的源码之前，先提几个问题，大家带着问题去看代码，理解更深一些。

1、事务管理器是如何获取的？

2、什么情况下事务会提交？

3、什么异常会导致事务回滚？

6.1、invokeWithinTransaction方法

这个方法是事务拦截器的入口，需要spring管理事务的业务方法会被这个方法拦截，大家可以设置断点跟踪一下

  1. protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
  2.             final InvocationCallback invocation) throws Throwable {
  4.     TransactionAttributeSource tas = getTransactionAttributeSource();
  5.     //@6-1：获取事务属性配置信息：通过TransactionAttributeSource.getTransactionAttribute解析@Trasaction注解得到事务属性配置信息
  6.     final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
  7.     //@6-2：获取事务管理器
  8.     final TransactionManager tm = determineTransactionManager(txAttr);
  10.     //将事务管理器tx转换为 PlatformTransactionManager
  11.     PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
  13.     if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
  14.         // createTransactionIfNecessary内部，这里就不说了，内部主要就是使用spring事务硬编码的方式开启事务，最终会返回一个TransactionInfo对象
  15.         TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
  16.         // 业务方法返回值
  17.         Object retVal;
  18.         try {
  19.             //调用aop中的下一个拦截器，最终会调用到业务目标方法，获取到目标方法的返回值
  20.             retVal = invocation.proceedWithInvocation();
  21.         }
  22.         catch (Throwable ex) {
  23.             //6-3：异常情况下，如何走？可能只需提交，也可能只需回滚，这个取决于事务的配置
  24.             completeTransactionAfterThrowing(txInfo, ex);
  25.             throw ex;
  26.         }
  27.         finally {
  28.             //清理事务信息
  29.             cleanupTransactionInfo(txInfo);
  30.         }
  31.         //6-4：业务方法返回之后，只需事务提交操作
  32.         commitTransactionAfterReturning(txInfo);
  33.         //返回执行结果
  34.         return retVal;
  35.     }
  36. }

6.2、获取事务管理器

  1. //@6-2：获取事务管理器
  2. final TransactionManager tm = determineTransactionManager(txAttr);

determineTransactionManager源码如下：

  1. org.springframework.transaction.interceptor.TransactionAspectSupport#determineTransactionManager
  3. protected TransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
  4.     // txAttr == null || this.beanFactory == null ，返回拦截器中配置的事务管理器
  5.     if (txAttr == null || this.beanFactory == null) {
  6.         return getTransactionManager();
  7.     }
  9.     //qualifier就是@Transactional注解中通过value或者transactionManager来指定事务管理器的bean名称
  10.     String qualifier = txAttr.getQualifier();
  11.     if (StringUtils.hasText(qualifier)) {
  12.         //从spring容器中查找[beanName:qualifier,type:TransactionManager]的bean
  13.         return determineQualifiedTransactionManager(this.beanFactory, qualifier);
  14.     }
  15.     else if (StringUtils.hasText(this.transactionManagerBeanName)) {
  16.         //从spring容器中查找[beanName:this.transactionManagerBeanName,type:TransactionManager]的bean
  17.         return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
  18.     }
  19.     else {
  20.         //最后通过类型TransactionManager在spring容器中找事务管理器
  21.         TransactionManager defaultTransactionManager = getTransactionManager();
  22.         if (defaultTransactionManager == null) {
  23.             defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
  24.             if (defaultTransactionManager == null) {
  25.                 defaultTransactionManager = this.beanFactory.getBean(TransactionManager.class);
  26.                 this.transactionManagerCache.putIfAbsent(
  27.                     DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
  28.             }
  29.         }
  30.         return defaultTransactionManager;
  31.     }
  32. }

从上面可知，事务管理器的查找顺序：

1、先看@Transactional中是否通过value或者transactionManager指定了事务管理器

2、TransactionInterceptor.transactionManagerBeanName是否有值，如果有，将通过这个值查找事务管理器

3、如果上面2种都没有，将从spring容器中查找TransactionManager类型的事务管理器

6.3、异常情况下，如何走？

  1. try{
  2.     //....
  3. }catch (Throwable ex) {
  4.     //6-3：异常情况下，如何走？可能只需提交，也可能只需回滚，这个取决于事务的配置
  5.     completeTransactionAfterThrowing(txInfo, ex);
  6.     throw ex;
  7. }

源码中可以看出，发生异常了会进入completeTransactionAfterThrowing方法，completeTransactionAfterThrowing 源码如下

  1. protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
  2.     if (txInfo != null && txInfo.getTransactionStatus() != null) {
  3.         //@6-3-1：判断事务是否需要回滚
  4.         if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
  5.             //通过事务管理器回滚事务
  6.             txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
  7.         }
  8.         else {
  9.             //通过事务管理器提交事务
  10.             txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
  11.         }
  12.     }
  13. }

注意上面的@6-3-1代码，判断事务是否需要回滚，调用的是transactionAttribute.rollbackOn(ex)，最终会进入下面这个方法内部

  1. org.springframework.transaction.interceptor.RuleBasedTransactionAttribute#rollbackOn
  3. public boolean rollbackOn(Throwable ex) {
  4.     RollbackRuleAttribute winner = null;
  5.     int deepest = Integer.MAX_VALUE;
  7.     //@Trasaction中可以通过rollbackFor指定需要回滚的异常列表，通过noRollbackFor属性指定不需要回滚的异常
  8.     //根据@Transactional中指定的回滚规则判断ex类型的异常是否需要回滚
  9.     if (this.rollbackRules != null) {
  10.         for (RollbackRuleAttribute rule : this.rollbackRules) {
  11.             int depth = rule.getDepth(ex);
  12.             if (depth >= 0 && depth < deepest) {
  13.                 deepest = depth;
  14.                 winner = rule;
  15.             }
  16.         }
  17.     }
  18.     //若@Transactional注解中没有匹配到，这走默认的规则，将通过super.rollbackOn来判断
  19.     if (winner == null) {
  20.         return super.rollbackOn(ex);
  21.     }
  23.     return !(winner instanceof NoRollbackRuleAttribute);
  24. }

super.rollbackOn(ex)源码如下，可以看出默认情况下，异常类型是RuntimeException或者Error的情况下，事务才会回滚。

  1. @Override
  2. public boolean rollbackOn(Throwable ex) {
  3.     return (ex instanceof RuntimeException || ex instanceof Error);
  4. }

6.4、没有异常如何走？

  1. //6-4：业务方法返回之后，只需事务提交操作
  2. commitTransactionAfterReturning(txInfo);

没有异常的情况下会进入commitTransactionAfterReturning方法，commitTransactionAfterReturning源码如下，比较简单，就是调用事务管理器的commit方法提交事务

  1. protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
  2.     if (txInfo != null && txInfo.getTransactionStatus() != null) {
  3.         txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
  4.     }
  5. }

源码解析的差不多了，建议大家设置断点跟踪一下，加深对事务原理的理解。

7、重点回顾

1、使用@Transaction的时候，一定别忘记@EnableTransactionManagement注解，否则事务不起效

2、@Transaction的功能主要是通过aop来实现的，关键代码在TransactionInterceptor拦截器中

3、默认情况下，事务只会在 RuntimeException 或 Error 异常下回滚，可以通@Transaction来配置其他需要回滚或不需要回滚的异常类型

8、课堂讨论

下面代码的执行结果是什么？为什么？

  1. @Component
  2. public class ServiceA {
  4.     @Autowired
  5.     ServiceB serviceB;
  7.     @Transactional
  8.     public void m1() {
  9.         try {
  10.             serviceB.m2();
  11.         } catch (Exception e) {
  12.             e.printStackTrace();
  13.         }
  14.         "insert into t_user (name) values ('张三')";
  15.     }
  16. }
  18. @Component
  19. public class ServiceB {
  21.     @Transactional
  22.     public void m2() {
  23.         "insert into t_user (name) values ('李四')";
  24.         throw new RuntimeException("手动抛出异常!");
  25.     }
  26. }

欢迎留言和我分享你的想法。如果有收获，也欢迎你把这篇文章分享给你的朋友。

案例源码

  1. git地址：
  2. https://gitee.com/javacode2018/spring-series

本博客所有系列案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#Spring教程  |  Spring事务专题
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: