默认情况下，Spring中的事务只对RuntimeExceprion方法回滚。

10.2 事务自定义标签

搜索annotation-driven 最终锁定TxNamespaceHandler
在遇到诸如<tx:annotation-driven> 开头的配置后，Spring都会使用AnnotationDrivenBeanDefinitionParser类的parse方法进行解析

  1.     AnnotationDrivenBeanDefinitionParser
  2.     public BeanDefinition parse(Element element, ParserContext parserContext) {
  3.         registerTransactionalEventListenerFactory(parserContext);
  4.         String mode = element.getAttribute("mode");
  5.         if ("aspectj".equals(mode)) {
  6.             // mode="aspectj"
  7.             registerTransactionAspect(element, parserContext);
  8.             if (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader())) {
  9.                 registerJtaTransactionAspect(element, parserContext);
  10.             }
  11.         }
  12.         else {
  13.             // mode="proxy"
  14.             AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
  15.         }
  16.         return null;
  17.     }

10.2.1 注册InfrastructureAdvisorAutoProxyCreator

InfrastructureAdvisorAutoProxyCreator的类继承结构
image.png
spring中，所有bean的实例化时都会保证调用其postProcessAfterInitialization，其实现是父类AbstractAutoProxyCreator类中实现。

  1.     AbstractAutoProxyCreator
  2.     public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
  3.         if (bean != null) {
  4.             Object cacheKey = getCacheKey(bean.getClass(), beanName);
  5.             // 是否是由于避免循环依赖而创建的bean代理
  6.             if (this.earlyProxyReferences.remove(cacheKey) != bean) {
  7.                 return wrapIfNecessary(bean, beanName, cacheKey);
  8.             }
  9.         }
  10.         return bean;
  11.     }
  13.     protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  14.         if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
  15.             return bean;
  16.         }
  17.         if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  18.             return bean;
  19.         }
  20.         //给定的bean类是否代表一个基础设施类，不应代理，或者配置了指定bean需要自动代理
  21.         if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  22.             this.advisedBeans.put(cacheKey, Boolean.FALSE);
  23.             return bean;
  24.         }
  26.         // 创建代理
  27.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  28.         if (specificInterceptors != DO_NOT_PROXY) {
  29.             this.advisedBeans.put(cacheKey, Boolean.TRUE);
  30.             Object proxy = createProxy(
  31.                     bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  32.             this.proxyTypes.put(cacheKey, proxy.getClass());
  33.             return proxy;
  34.         }
  36.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  37.         return bean;
  38.     }

10.2.2 获取对应class/method的增强器

获取指定的bean对应的增强器，其中包含两个关键字：增强器与对应。也就是说getAdvicesAndAdvisorsForBean函数中，不但要找出增强器，而且还需要判断增强器是否满足要求。

  1. AbstractAutoProxyCreator
  2.     protected Object[] getAdvicesAndAdvisorsForBean(
  3.             Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
  5.         List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
  6.         if (advisors.isEmpty()) {
  7.             return DO_NOT_PROXY;
  8.         }
  9.         return advisors.toArray();
  10.     }
  12.     protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  13.         // 寻找候选增强器
  14.         List<Advisor> candidateAdvisors = findCandidateAdvisors();
  15.         //候选增强器中寻找匹配项
  16.         List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  17.         extendAdvisors(eligibleAdvisors);
  18.         if (!eligibleAdvisors.isEmpty()) {
  19.             eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  20.         }
  21.         return eligibleAdvisors;
  22.     }

1 寻找候选增强器

2 候选增强器中寻找匹配项

  1.     public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
  2.         if (candidateAdvisors.isEmpty()) {
  3.             return candidateAdvisors;
  4.         }
  5.         List<Advisor> eligibleAdvisors = new ArrayList<>();
  6.         // 首先处理引介增强
  7.         for (Advisor candidate : candidateAdvisors) {
  8.             if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
  9.                 eligibleAdvisors.add(candidate);
  10.             }
  11.         }
  12.         boolean hasIntroductions = !eligibleAdvisors.isEmpty();
  13.         for (Advisor candidate : candidateAdvisors) {
  14.             //引介增强 已经处理
  15.             if (candidate instanceof IntroductionAdvisor) {
  16.                 // already processed
  17.                 continue;
  18.             }
  19.             //对于普通 bean 的处理 
  20.             if (canApply(candidate, clazz, hasIntroductions)) {
  21.                 eligibleAdvisors.add(candidate);
  22.             }
  23.         }
  24.         return eligibleAdvisors;
  25.     }

10.3 事务增强器

TransactionInterceptor 支撑着整个事务功能的架构。TransactionInterceptor 类继承自MethodInterceptor。所以其调用是从invoke开始的。

  1.     protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
  2.             final InvocationCallback invocation) throws Throwable {
  4.         // If the transaction attribute is null, the method is non-transactional.
  5.         TransactionAttributeSource tas = getTransactionAttributeSource();
  6.         //提取对应事务属性
  7.         final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
  8.         //获取beanFactory 中的 TransactionManager
  9.         final TransactionManager tm = determineTransactionManager(txAttr);
  11.         if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
  12.             ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
  13.                 if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
  14.                     throw new TransactionUsageException(
  15.                             "Unsupported annotated transaction on suspending function detected: " + method +
  16.                             ". Use TransactionalOperator.transactional extensions instead.");
  17.                 }
  18.                 ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
  19.                 if (adapter == null) {
  20.                     throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
  21.                             method.getReturnType());
  22.                 }
  23.                 return new ReactiveTransactionSupport(adapter);
  24.             });
  25.             return txSupport.invokeWithinTransaction(
  26.                     method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
  27.         }
  29.         PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
  30.         final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
  31.         //声明式事务
  32.         if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
  33.             //创建 TransactionInfo
  34.             TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
  36.             Object retVal;
  37.             try {
  38.                 //执行被增强方法
  39.                 retVal = invocation.proceedWithInvocation();
  40.             }
  41.             catch (Throwable ex) {
  42.                 //异常回滚
  43.                 completeTransactionAfterThrowing(txInfo, ex);
  44.                 throw ex;
  45.             }
  46.             finally {
  47.                 //清除信息
  48.                 cleanupTransactionInfo(txInfo);
  49.             }
  51.             if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
  52.                 // Set rollback-only in case of Vavr failure matching our rollback rules...
  53.                 TransactionStatus status = txInfo.getTransactionStatus();
  54.                 if (status != null && txAttr != null) {
  55.                     retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
  56.                 }
  57.             }
  58.             //提交事务
  59.             commitTransactionAfterReturning(txInfo);
  60.             return retVal;
  61.         }
  63.         else {
  64.             Object result;
  65.             final ThrowableHolder throwableHolder = new ThrowableHolder();
  66.             //编程式事务处理
  67.             // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
  68.             try {
  69.                 result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
  70.                     TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
  71.                     try {
  72.                         Object retVal = invocation.proceedWithInvocation();
  73.                         if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
  74.                             // Set rollback-only in case of Vavr failure matching our rollback rules...
  75.                             retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
  76.                         }
  77.                         return retVal;
  78.                     }
  79.                     catch (Throwable ex) {
  80.                         if (txAttr.rollbackOn(ex)) {
  81.                             // A RuntimeException: will lead to a rollback.
  82.                             if (ex instanceof RuntimeException) {
  83.                                 throw (RuntimeException) ex;
  84.                             }
  85.                             else {
  86.                                 throw new ThrowableHolderException(ex);
  87.                             }
  88.                         }
  89.                         else {
  90.                             // A normal return value: will lead to a commit.
  91.                             throwableHolder.throwable = ex;
  92.                             return null;
  93.                         }
  94.                     }
  95.                     finally {
  96.                         cleanupTransactionInfo(txInfo);
  97.                     }
  98.                 });
  99.             }
  100.             catch (ThrowableHolderException ex) {
  101.                 throw ex.getCause();
  102.             }
  103.             catch (TransactionSystemException ex2) {
  104.                 if (throwableHolder.throwable != null) {
  105.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  106.                     ex2.initApplicationException(throwableHolder.throwable);
  107.                 }
  108.                 throw ex2;
  109.             }
  110.             catch (Throwable ex2) {
  111.                 if (throwableHolder.throwable != null) {
  112.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  113.                 }
  114.                 throw ex2;
  115.             }
  117.             // Check result state: It might indicate a Throwable to rethrow.
  118.             if (throwableHolder.throwable != null) {
  119.                 throw throwableHolder.throwable;
  120.             }
  121.             return result;
  122.         }
  123.     }

声明式事务主要有以下几个步骤。

  1. 获取事务的属性
  2. 加载配置中配置的TransactionManager
  3. 不同的事务处理方式使用不同的逻辑。对于声明事务的处理与编程式事务的处理，第一点区别在于事务属性上，因为编程式的事务处理不需要有事物属性的，第二点区别是TransactionManager上，CallBackPreferringPlatformTransactionManager实现PlatformTransactionManager接口。暴露出一个方法用于执行事务处理中心的回调。所以，这两种方式都可以用作事务处理的判断。
  4. 在目标方法执行前获取事物并收集事务信息。
  5. 执行目标方法
  6. 一旦出现异常，尝试异常处理
  7. 提交事务钱的事务信息清除。
  8. 提交事务。