@EnableTransactionManagement注解注入了两个bean：

  1. AutoProxyRegistrar
  2. ProxyTransactionManagementConfiguration

AutoProxyRegistrar

AutoProxyRegistrar主要的作用就是注册了一个InfrastructureAdvisorAutoProxyCreator的Bean。
而InfrastructureAdvisorAutoProxyCreator继承了AbstractAdvisorAutoProxyCreator，所以这个类的主要作用就是开启自动代理的作用。

ProxyTransactionManagementConfiguration

ProxyTransactionManagementConfiguration中定义了三个bean：

  1. BeanFactoryTransactionAttributeSourceAdvisor：一个PointcutAdvisor
  2. AnnotationTransactionAttributeSource：就是Pointcut
  3. TransactionInterceptor：就是代理逻辑Advice
  1. BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
  2. advisor.setTransactionAttributeSource(transactionAttributeSource); 
  3. advisor.setAdvice(transactionInterceptor);

BeanFactoryTransactionAttributeSourceAdvisor是一个Advisor，在构造BeanFactoryTransactionAttributeSourceAdvisor这个bean时，需要另外两Bean。

BeanFactoryTransactionAttributeSourceAdvisor中是这么定义PointCut的：

  1. private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
  2.     @Override
  3.     @Nullable
  4.     protected TransactionAttributeSource getTransactionAttributeSource() {
  5.         return transactionAttributeSource;
  6.     }
  7. };

构造了一个PointCut, TransactionAttributeSource的实现对象为AnnotationTransactionAttributeSource，在PointCut匹配类时，会利用AnnotationTransactionAttributeSource去检查类上是否有@Transactional注解，在PointCut匹配方法时，会利用AnnotationTransactionAttributeSource去检查方法上是否有@Transactional注解。

所以ProxyTransactionManagementConfiguration的作用就是向Spring容器中添加了一个Advisor，有了Advisor，那么Spring在构造bean时就会查看当前bean是不是匹配所设置的PointCut（也就是beanClass上是否有@Transactional注解或beanClass中某个方法上是否有@Transactional注解），如果匹配，则利用所设置的Advise（也就是TransactionInterceptor）进行AOP，生成代理对象。

TransactionInterceptor

  1. public Object invoke(MethodInvocation invocation) throws Throwable {
  2.         // Work out the target class: may be {@code null}.
  3.         // The TransactionAttributeSource should be passed the target class
  4.         // as well as the method, which may be from an interface.
  5.         Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
  7.         // Adapt to TransactionAspectSupport's invokeWithinTransaction...
  8.         return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
  9.     }
  1. @Nullable
  2.     protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
  3.             final InvocationCallback invocation) throws Throwable {
  5.         // If the transaction attribute is null, the method is non-transactional.
  6.         TransactionAttributeSource tas = getTransactionAttributeSource();
  7.         final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
  8.         final TransactionManager tm = determineTransactionManager(txAttr);
  10.         if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
  11.             ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
  12.                 if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
  13.                     throw new TransactionUsageException(
  14.                             "Unsupported annotated transaction on suspending function detected: " + method +
  15.                             ". Use TransactionalOperator.transactional extensions instead.");
  16.                 }
  17.                 ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
  18.                 if (adapter == null) {
  19.                     throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
  20.                             method.getReturnType());
  21.                 }
  22.                 return new ReactiveTransactionSupport(adapter);
  23.             });
  24.             return txSupport.invokeWithinTransaction(
  25.                     method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
  26.         }
  28.         PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
  29.         final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
  31.         if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
  32.             // Standard transaction demarcation with getTransaction and commit/rollback calls.
  33.             //开启事务
  34.             TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
  36.             Object retVal;
  37.             try {
  38.                 // This is an around advice: Invoke the next interceptor in the chain.
  39.                 // This will normally result in a target object being invoked.
  40.                 //执行业务逻辑
  41.                 retVal = invocation.proceedWithInvocation();
  42.             }
  43.             catch (Throwable ex) {
  44.                 // target invocation exception
  45.                 //异常回滚
  46.                 completeTransactionAfterThrowing(txInfo, ex);
  47.                 throw ex;
  48.             }
  49.             finally {
  50.                 cleanupTransactionInfo(txInfo);
  51.             }
  53.             if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
  54.                 // Set rollback-only in case of Vavr failure matching our rollback rules...
  55.                 TransactionStatus status = txInfo.getTransactionStatus();
  56.                 if (status != null && txAttr != null) {
  57.                     retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
  58.                 }
  59.             }
  61.             commitTransactionAfterReturning(txInfo);
  62.             return retVal;
  63.         }
  65.         else {
  66.             Object result;
  67.             final ThrowableHolder throwableHolder = new ThrowableHolder();
  69.             // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
  70.             try {
  71.                 result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
  72.                     TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
  73.                     try {
  74.                         Object retVal = invocation.proceedWithInvocation();
  75.                         if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
  76.                             // Set rollback-only in case of Vavr failure matching our rollback rules...
  77.                             retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
  78.                         }
  79.                         return retVal;
  80.                     }
  81.                     catch (Throwable ex) {
  82.                         if (txAttr.rollbackOn(ex)) {
  83.                             // A RuntimeException: will lead to a rollback.
  84.                             if (ex instanceof RuntimeException) {
  85.                                 throw (RuntimeException) ex;
  86.                             }
  87.                             else {
  88.                                 throw new ThrowableHolderException(ex);
  89.                             }
  90.                         }
  91.                         else {
  92.                             // A normal return value: will lead to a commit.
  93.                             throwableHolder.throwable = ex;
  94.                             return null;
  95.                         }
  96.                     }
  97.                     finally {
  98.                         cleanupTransactionInfo(txInfo);
  99.                     }
  100.                 });
  101.             }
  102.             catch (ThrowableHolderException ex) {
  103.                 throw ex.getCause();
  104.             }
  105.             catch (TransactionSystemException ex2) {
  106.                 if (throwableHolder.throwable != null) {
  107.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  108.                     ex2.initApplicationException(throwableHolder.throwable);
  109.                 }
  110.                 throw ex2;
  111.             }
  112.             catch (Throwable ex2) {
  113.                 if (throwableHolder.throwable != null) {
  114.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  115.                 }
  116.                 throw ex2;
  117.             }
  119.             // Check result state: It might indicate a Throwable to rethrow.
  120.             if (throwableHolder.throwable != null) {
  121.                 throw throwableHolder.throwable;
  122.             }
  123.             return result;
  124.         }
  125.     }

TransactionInterceptor执行流程

Spring事务的底层实现流程.png

简单版流程

  1. 生成test事务状态对象
  2. test事务doBegin，获取并将数据库连接2825设置到test事务状态对象中
  3. 把test事务信息设置到事务同步管理器中
  4. 执行test业务逻辑方法（可以获取到test事务的信息）
    1. 生成a事务状态对象，并且可以获取到当前线程中已经存在的数据库连接2825
    2. 判断出来当前线程中已经存在事务
    3. 如果需要新开始事务，就先挂起数据库连接2825，挂起就是把test事务信息从事务同步管理器中转移到挂起资源对象中，并把当前a事务状态对象中的数据库连接设置为null
    4. a事务doBegin，新生成一个数据库连接2826，并设置到a事务状态对象中
    5. 把a事务信息设置到事务同步管理器中
    6. 执行a业务逻辑方法（可以利用事务同步管理器获取到a事务信息）
    7. 利用a事务状态对象，执行提交
    8. 提交之后会恢复所挂起的test事务，这里的恢复，其实只是把挂起资源对象中所保存的信息再转移回事务同步管理器中
  5. 继续执行test业务逻辑方法（仍然可以获取到test事务的信息）
  6. 利用test事务状态对象，执行提交

传播机制

Spring事务 - 图2

举例子

情况1

  1. @Component
  2. public class UserService {
  3.     @Autowired
  4.     private UserService userService;
  6.     @Transactional
  7.     public void test() {
  8.         // test方法中的sql
  9.         userService.a();
  10.     }
  12.     @Transactional
  13.     public void a() {
  14.         // a方法中的sql
  15.     }
  16. }

默认情况下传播机制为REQUIRED

所以上面这种情况的执行流程如下：

  1. 新建一个数据库连接conn
  2. 设置conn的autocommit为false
  3. 执行test方法中的sql
  4. 执行a方法中的sql
  5. 执行conn的commit()方法进行提交

情况2

假如是这种情况

  1. @Component
  2. public class UserService {
  3.     @Autowired
  4.     private UserService userService;
  6.     @Transactional
  7.     public void test() {
  8.         // test方法中的sql
  9.         userService.a();
  10.         int result = 100/0;
  11.     }
  13.     @Transactional
  14.     public void a() {
  15.         // a方法中的sql
  16.     }
  17. }

所以上面这种情况的执行流程如下：

  1. 新建一个数据库连接conn
  2. 设置conn的autocommit为false
  3. 执行test方法中的sql
  4. 执行a方法中的sql
  5. 抛出异常
  6. 执行conn的rollback()方法进行回滚

情况3

假如是这种情况：

  1. @Component
  2. public class UserService {
  3.     @Autowired
  4.     private UserService userService;
  6.     @Transactional
  7.     public void test() {
  8.         // test方法中的sql
  9.         userService.a();
  10.     }
  12.     @Transactional
  13.     public void a() {
  14.         // a方法中的sql
  15.         int result = 100/0;
  16.     }
  17. }

所以上面这种情况的执行流程如下：

  1. 新建一个数据库连接conn
  2. 设置conn的autocommit为false
  3. 执行test方法中的sql
  4. 执行a方法中的sql
  5. 抛出异常
  6. 执行conn的rollback()方法进行回滚

情况4

如果是这种情况：

  1. @Component
  2. public class UserService {
  3.     @Autowired
  4.     private UserService userService;
  6.     @Transactional
  7.     public void test() {
  8.         // test方法中的sql
  9.         userService.a();
  10.     }
  12.     @Transactional(propagation = Propagation.REQUIRES_NEW)
  13.     public void a() {
  14.         // a方法中的sql
  15.         int result = 100/0;
  16.     }
  17. }

所以上面这种情况的执行流程如下：

  1. 新建一个数据库连接conn
  2. 设置conn的autocommit为false
  3. 执行test方法中的sql
  4. 又新建一个数据库连接conn2
  5. 执行a方法中的sql
  6. 抛出异常
  7. 执行conn2的rollback()方法进行回滚
  8. 继续抛异常
  9. 执行conn的rollback()方法进行回滚