spring-transaction源码分析(5)TransactionInterceptor事务拦截逻辑 ...

spring-tx的事务拦截逻辑在TransactionInterceptor类，本文将详细分析其实现方式。
事务拦截器TransactionInterceptor

spring-tx的事务拦截逻辑在TransactionInterceptor类，它实现了MethodInterceptor接口。
MethodInterceptor接口

MethodInterceptor接口的实现类封装aop切面拦截逻辑：

1. public interface MethodInterceptor extends Interceptor {
3.         /**
4.          * Implement this method to perform extra treatments before and after the invocation.
5.          */
6.         Object invoke(MethodInvocation invocation) throws Throwable;
7. }

复制代码

TransactionInterceptor类

TransactionInterceptor类封装了事务拦截逻辑：

1. public class TransactionInterceptor
2.     extends TransactionAspectSupport implements MethodInterceptor, Serializable {
4.         // ...
6.         @Override
7.         public Object invoke(MethodInvocation invocation) throws Throwable {
8.                 // Work out the target class: may be {@code null}.
9.                 // The TransactionAttributeSource should be passed the target class
10.                 // as well as the method, which may be from an interface.
11.                 Class<?> targetClass =
12.             (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
14.                 // Adapt to TransactionAspectSupport's invokeWithinTransaction...
15.                 return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
16.         }
18.         // ...
19. }

复制代码

事务逻辑在父类TransactionAspectSupport的invokeWithinTransaction方法中。
invokeWithinTransaction方法

1. protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
2.                 final InvocationCallback invocation) throws Throwable {
4.         // 如果方法没有被Transactional注解标注，则返回null
5.         // 返回的是AnnotationTransactionAttributeSource对象
6.         // 用于获取Transactional注解相关属性，
7.         // 比如rollbackOn, propagationBehavior, isolationLevel等
8.         TransactionAttributeSource tas = getTransactionAttributeSource();
9.         TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
11.         // 获取事务管理器
12.         // 后面会转型成PlatformTransactionManager对象，可以开启事务、提交、回滚
13.     TransactionManager tm = determineTransactionManager(txAttr);
15.         // Reactive事务，略
17.         // 转型成PlatformTransactionManager对象，可以开启事务、提交、回滚
18.         PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
19.         // 获取事务方法的唯一标识
20.         // 格式为"类名.方法名"
21.         final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
23.         if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
24.                 // 创建事务
25.                 TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
27.                 Object retVal;
28.                 try {
29.                         // This is an around advice: Invoke the next interceptor in the chain.
30.                         // This will normally result in a target object being invoked.
31.                         retVal = invocation.proceedWithInvocation();
32.                 } catch (Throwable ex) {
33.                         // Handle a throwable, completing the transaction.
34.                         // We may commit or roll back, depending on the configuration.
35.                         completeTransactionAfterThrowing(txInfo, ex);
36.                         throw ex;
37.                 } finally {
38.                         // Reset the TransactionInfo ThreadLocal.
39.                         // Call this in all cases: exception or normal return!
40.                         cleanupTransactionInfo(txInfo);
41.                 }
43.                 if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
44.                         // Set rollback-only in case of Vavr failure matching our rollback rules...
45.                         TransactionStatus status = txInfo.getTransactionStatus();
46.                         if (status != null && txAttr != null) {
47.                                 retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
48.                         }
49.                 }
51.                 // 提交事务
52.                 commitTransactionAfterReturning(txInfo);
54.                 return retVal;
55.         } else {
56.                 // CallbackPreferringPlatformTransactionManager事务管理器逻辑，略
57.         }
58. }

复制代码

创建事务

Create a transaction if necessary based on the given TransactionAttribute. Allows callers to perform custom TransactionAttribute lookups through the TransactionAttributeSource.

1. protected TransactionInfo createTransactionIfNecessary(PlatformTransactionManager tm,
2.                 TransactionAttribute txAttr, final String joinpointIdentification) {
4.         // If no name specified, apply method identification as transaction name.
5.         if (txAttr != null && txAttr.getName() == null) {
6.                 txAttr = new DelegatingTransactionAttribute(txAttr) {
7.                         @Override
8.                         public String getName() {
9.                                 return joinpointIdentification;
10.                         }
11.                 };
12.         }
14.         TransactionStatus status = null;
15.         if (txAttr != null) {
16.                 if (tm != null) {
17.                         // 创建新事务或者返回已存在事务, 这取决于传播级别。
18.                         // 隔离级别或超时等参数只在新事务时生效，已存在事务会忽略这些参数。
19.                         status = tm.getTransaction(txAttr);
20.                 }
21.         }
23.         // 使用指定的事务属性和TransactionStatus创建TransactionInfo
24.         return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
25. }

复制代码

getTransaction(txAttr)

这个方法创建新事务或者返回已存在事务，这取决于传播级别。隔离级别或超时等参数只在新事务时生效，已存在事务会忽略这些参数。

1. public final TransactionStatus getTransaction(TransactionDefinition definition)
2.                 throws TransactionException {
4.         // Use defaults if no transaction definition given.
5.         TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
7.         // DataSourceTransactionManager实现类返回DataSourceTransactionObject对象
8.         // DataSourceTransactionObject对象封装着数据库连接、previousIsolationLevel、readOnly、savepointAllowed等
9.         Object transaction = doGetTransaction();
10.         boolean debugEnabled = logger.isDebugEnabled();
12.         if (isExistingTransaction(transaction)) {
13.                 // Existing transaction found -> check propagation behavior to find out how to behave.
14.                 return handleExistingTransaction(def, transaction, debugEnabled);
15.         }
17.         // No existing transaction found -> check propagation behavior to find out how to proceed.
18.         if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
19.                 // 传播级别设置为PROPAGATION_MANDATORY时，如果当前没有事务，则抛出异常
20.                 throw new IllegalTransactionStateException(
21.                                 "No existing transaction found for transaction marked with propagation 'mandatory'");
22.         } else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
23.                         def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
24.                         def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
25.                 SuspendedResourcesHolder suspendedResources = suspend(null);
26.                 // Creating new transaction
27.                 try {
28.                         return startTransaction(def, transaction, debugEnabled, suspendedResources);
29.                 } catch (RuntimeException | Error ex) {
30.                         resume(null, suspendedResources);
31.                         throw ex;
32.                 }
33.         } else {
34.                 // Create "empty" transaction: no actual transaction, but potentially synchronization.
35.                 if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
36.                         logger.warn("Custom isolation level specified but no actual transaction initiated; " +
37.                                         "isolation level will effectively be ignored: " + def);
38.                 }
39.                 boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
40.                 return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
41.         }
42. }

复制代码

doGetTransaction()

1. protected Object doGetTransaction() {
2.         // DataSourceTransactionObject封装着数据库连接、previousIsolationLevel、readOnly、savepointAllowed等
3.         DataSourceTransactionObject txObject = new DataSourceTransactionObject();
4.         // 是否允许设置保存点，NESTED传播级别时使用，DataSourceTransactionManager类型该属性为true
5.         txObject.setSavepointAllowed(isNestedTransactionAllowed());
6.         // 从ThreadLocal获取当前线程上绑定的ConnectionHolder
7.         // ConnectionHolder对象保存着数据库连接
8.         // 业务方法第一次执行时为null
9.         ConnectionHolder conHolder =
10.                         (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
11.         txObject.setConnectionHolder(conHolder, false);
12.         return txObject;
13. }

复制代码

当前有事务

handleExistingTransaction方法

1. if (isExistingTransaction(transaction)) {
2.         // Existing transaction found -> check propagation behavior to find out how to behave.
3.         return handleExistingTransaction(def, transaction, debugEnabled);
4. }

复制代码

isExistingTransaction方法判断当前是否存在事务：

1. protected boolean isExistingTransaction(Object transaction) {
2.         DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
3.         // 判断存在数据库连接且开启了事务
4.         return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
5. }

复制代码

handleExistingTransaction方法：

1. private TransactionStatus handleExistingTransaction(
2.                 TransactionDefinition definition, Object transaction, boolean debugEnabled)
3.                 throws TransactionException {
5.         // 传播级别为NEVER
6.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
7.                 // 传播级别设置为NEVER时，如果当前有事务，则抛出异常
8.                 throw new IllegalTransactionStateException(
9.                                 "Existing transaction found for transaction marked with propagation 'never'");
10.         }
12.         // 传播级别为NOT_SUPPORTED
13.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
14.                 // 挂起当前事务
15.                 Object suspendedResources = suspend(transaction);
16.                 boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
17.                 return prepareTransactionStatus(
18.                                 definition, null, false, newSynchronization, debugEnabled, suspendedResources);
19.         }
21.         // 传播级别为REQUIRES_NEW
22.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
23.                 // 挂起当前事务，然后创建新事务
24.                 SuspendedResourcesHolder suspendedResources = suspend(transaction);
25.                 try {
26.                         return startTransaction(definition, transaction, debugEnabled, suspendedResources);
27.                 } catch (RuntimeException | Error beginEx) {
28.                         resumeAfterBeginException(transaction, suspendedResources, beginEx);
29.                         throw beginEx;
30.                 }
31.         }
33.         // 传播级别为NESTED
34.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
35.                 if (!isNestedTransactionAllowed()) {
36.                         throw new NestedTransactionNotSupportedException(
37.                                         "Transaction manager does not allow nested transactions by default - " +
38.                                         "specify 'nestedTransactionAllowed' property with value 'true'");
39.                 }
40.                 // Creating nested transaction
41.                 if (useSavepointForNestedTransaction()) {
42.                         // Create savepoint within existing Spring-managed transaction,
43.                         // through the SavepointManager API implemented by TransactionStatus.
44.                         // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
45.                         DefaultTransactionStatus status =
46.                                         prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
47.                         status.createAndHoldSavepoint();
48.                         return status;
49.                 }
50.                 else {
51.                         // Nested transaction through nested begin and commit/rollback calls.
52.                         // Usually only for JTA: Spring synchronization might get activated here
53.                         // in case of a pre-existing JTA transaction.
54.                         return startTransaction(definition, transaction, debugEnabled, null);
55.                 }
56.         }
58.         // 传播级别为SUPPORTS/REQUIRED
59.         if (isValidateExistingTransaction()) {
60.                 if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
61.                         Integer currentIsolationLevel =
62.                 TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
63.                         if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
64.                                 Constants isoConstants = DefaultTransactionDefinition.constants;
65.                                 throw new IllegalTransactionStateException(
66.                     "Participating transaction with definition [" + definition +
67.                     "] specifies isolation level which is incompatible with existing transaction: " +
68.                                                 (currentIsolationLevel != null ?
69.                                                                 isoConstants.toCode(currentIsolationLevel,
70.                                                     DefaultTransactionDefinition.PREFIX_ISOLATION) :
71.                                                                 "(unknown)"));
72.                         }
73.                 }
74.                 if (!definition.isReadOnly()) {
75.                         if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
76.                                 throw new IllegalTransactionStateException("Participating transaction with definition [" +
77.                                                 definition + "] is not marked as read-only but existing transaction is");
78.                         }
79.                 }
80.         }
82.         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
83.         return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
84. }

复制代码

传播级别为NEVER

传播级别设置为NEVER时，如果当前有事务，抛出异常：

1. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
2.         throw new IllegalTransactionStateException(
3.                         "Existing transaction found for transaction marked with propagation 'never'");
4. }

复制代码

传播级别为NOT_SUPPORTED

挂起当前事务，业务方法以无事务方式执行：

1. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
2.         // 挂起当前事务
3.         Object suspendedResources = suspend(transaction);
4.         boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
5.         return prepareTransactionStatus(
6.                         definition, null, false, newSynchronization, debugEnabled, suspendedResources);
7. }

复制代码

prepareTransactionStatus方法：

• 创建DefaultTransactionStatus对象，把SuspendedResources封装进去，以便后续恢复旧事务
  
• 使用TransactionSynchronizationManager将事务属性绑定到当前线程
  
• 初始化当前线程TransactionSynchronization集
  

由于传播级别为NOT_SUPPORTED所以此处不会开启事务。
传播级别为REQUIRES_NEW

挂起当前事务，创建新事务：

1. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
2.         // 挂起当前事务
3.         SuspendedResourcesHolder suspendedResources = suspend(transaction);
4.         try {
5.                 // 开启新事务
6.                 return startTransaction(definition, transaction, debugEnabled, suspendedResources);
7.         } catch (RuntimeException | Error beginEx) {
8.                 resumeAfterBeginException(transaction, suspendedResources, beginEx);
9.                 throw beginEx;
10.         }
11. }

复制代码

开启新事务：

1. private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
2.                 boolean debugEnabled, SuspendedResourcesHolder suspendedResources) {
4.         // 值为true
5.         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
6.         DefaultTransactionStatus status = newTransactionStatus(
7.                         definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
8.         // 开启新事务
9.         doBegin(transaction, definition);
10.         // 初始化当前线程TransactionSynchronization集
11.         prepareSynchronization(status, definition);
12.         return status;
13. }
15. protected void doBegin(Object transaction, TransactionDefinition definition) {
16.         DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
17.         Connection con = null;
19.         try {
20.                 if (!txObject.hasConnectionHolder() ||
21.                                 txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
22.                         // 打开一个新连接
23.                         Connection newCon = obtainDataSource().getConnection();
24.                         txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
25.                 }
27.                 txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
28.                 con = txObject.getConnectionHolder().getConnection();
30.                 Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
31.                 txObject.setPreviousIsolationLevel(previousIsolationLevel);
32.                 txObject.setReadOnly(definition.isReadOnly());
34.                 // Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
35.                 // so we don't want to do it unnecessarily (for example if we've explicitly
36.                 // configured the connection pool to set it already).
37.                 if (con.getAutoCommit()) {
38.                         txObject.setMustRestoreAutoCommit(true);
39.                         // 设置手动提交
40.                         con.setAutoCommit(false);
41.                 }
43.                 // The default implementation executes a "SET TRANSACTION READ ONLY" statement
44.                 // if the "enforceReadOnly" flag is set to true and the transaction definition
45.                 // indicates a read-only transaction.
46.                 prepareTransactionalConnection(con, definition);
47.                 txObject.getConnectionHolder().setTransactionActive(true);
49.                 int timeout = determineTimeout(definition);
50.                 if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
51.                         txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
52.                 }
54.                 // Bind the connection holder to the thread.
55.                 if (txObject.isNewConnectionHolder()) {
56.                         TransactionSynchronizationManager
57.                 .bindResource(obtainDataSource(), txObject.getConnectionHolder());
58.                 }
59.         } catch (Throwable ex) {
60.                 if (txObject.isNewConnectionHolder()) {
61.                         DataSourceUtils.releaseConnection(con, obtainDataSource());
62.                         txObject.setConnectionHolder(null, false);
63.                 }
64.                 throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
65.         }
66. }

复制代码

传播级别为NESTED

为当前连接设置保存点，如果业务方法出现异常，会回滚到该保存点位置：

1. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
2.         if (!isNestedTransactionAllowed()) {
3.                 throw new NestedTransactionNotSupportedException(
4.                                 "Transaction manager does not allow nested transactions by default - " +
5.                                 "specify 'nestedTransactionAllowed' property with value 'true'");
6.         }
7.         // Creating nested transaction
8.         // 默认就是true
9.         if (useSavepointForNestedTransaction()) {
10.                 // Create savepoint within existing Spring-managed transaction,
11.                 // through the SavepointManager API implemented by TransactionStatus.
12.                 // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
13.                 DefaultTransactionStatus status =
14.                                 prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
15.                 // 设置保存点
16.                 status.createAndHoldSavepoint();
17.                 return status;
18.         } else {
19.                 // Nested transaction through nested begin and commit/rollback calls.
20.                 // Usually only for JTA: Spring synchronization might get activated here
21.                 // in case of a pre-existing JTA transaction.
22.                 return startTransaction(definition, transaction, debugEnabled, null);
23.         }
24. }

复制代码

设置保存点：

1. public void createAndHoldSavepoint() throws TransactionException {
2.         setSavepoint(getSavepointManager().createSavepoint());
3. }
5. // JdbcTransactionObjectSupport#createSavepoint
6. public Object createSavepoint() throws TransactionException {
7.         ConnectionHolder conHolder = getConnectionHolderForSavepoint();
8.         try {
9.                 if (!conHolder.supportsSavepoints()) {
10.                         throw new NestedTransactionNotSupportedException("不支持");
11.                 }
12.                 if (conHolder.isRollbackOnly()) {
13.                         throw new CannotCreateTransactionException("只读");
14.                 }
15.                 // 使用jdbc设置保存点
16.                 return conHolder.createSavepoint();
17.         } catch (SQLException ex) {
18.                 throw new CannotCreateTransactionException("Could not create JDBC savepoint", ex);
19.         }
20. }

复制代码

传播级别为SUPPORTS/REQUIRED/MANDATORY

1. // 默认false
2. if (isValidateExistingTransaction()) {
3.         if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
4.                 Integer currentIsolationLevel =
5.             TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
6.                 if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
7.                         Constants isoConstants = DefaultTransactionDefinition.constants;
8.                         throw new IllegalTransactionStateException(
9.                 "Participating transaction with definition [" + definition +
10.                 "] specifies isolation level which is incompatible with existing transaction: " +
11.                                         (currentIsolationLevel != null ?
12.                                                         isoConstants.toCode(currentIsolationLevel,
13.                                                 DefaultTransactionDefinition.PREFIX_ISOLATION) :
14.                                                         "(unknown)"));
15.                 }
16.         }
17.         if (!definition.isReadOnly()) {
18.                 if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
19.                         throw new IllegalTransactionStateException("Participating transaction with definition [" +
20.                                         definition + "] is not marked as read-only but existing transaction is");
21.                 }
22.         }
23. }
24. boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
25. return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);

复制代码

事务挂起

把当前线程上绑定的资源、事务配置信息移除封装到SuspendedResourcesHolder对象，传递给新创建的TransactionStatus对象，以便在业务方法执行结束后恢复旧事务：

1. protected final SuspendedResourcesHolder suspend(Object transaction) throws TransactionException {
2.         // 判断当前线程的Set<TransactionSynchronization>已经存在
3.         // TransactionSynchronization: 事务回调同步器，定义了事务挂起、恢复等方法
4.         // 例如mybatis-spring中有SqlSessionSynchronization实现类
5.         if (TransactionSynchronizationManager.isSynchronizationActive()) {
6.                 List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
7.                 try {
8.                         Object suspendedResources = null;
9.                         if (transaction != null) {
10.                                 // 挂起事务
11.                                 suspendedResources = doSuspend(transaction);
12.                         }
14.                         // 清除当前线程事务配置参数：事务名、只读属性、隔离级别等
15.                         String name = TransactionSynchronizationManager.getCurrentTransactionName();
16.                         TransactionSynchronizationManager.setCurrentTransactionName(null);
17.                         boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
18.                         TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
19.                         Integer isolationLevel =
20.                 TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
21.                         TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
22.                         boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
23.                         TransactionSynchronizationManager.setActualTransactionActive(false);
25.                         // 把当前线程的事务相关信息封装起来以便后续恢复
26.                         return new SuspendedResourcesHolder(suspendedResources, suspendedSynchronizations,
27.                                                 name, readOnly, isolationLevel, wasActive);
28.                 } catch (RuntimeException | Error ex) {
29.                         // doSuspend failed - original transaction is still active...
30.                         doResumeSynchronization(suspendedSynchronizations);
31.                         throw ex;
32.                 }
33.         } else if (transaction != null) {
34.                 // Transaction active but no synchronization active.
35.                 Object suspendedResources = doSuspend(transaction);
36.                 return new SuspendedResourcesHolder(suspendedResources);
37.         } else {
38.                 // Neither transaction nor synchronization active.
39.                 return null;
40.         }
41. }
43. private List<TransactionSynchronization> doSuspendSynchronization() {
44.         List<TransactionSynchronization> suspendedSynchronizations =
45.                         TransactionSynchronizationManager.getSynchronizations();
46.         // 挂起所有的TransactionSynchronization
47.         // 比如SqlSessionSynchronization实现类会清除当前线程的SessionFactory
48.         for (TransactionSynchronization synchronization : suspendedSynchronizations) {
49.                 synchronization.suspend();
50.         }
51.         // 清除线程上的TransactionSynchronization集
52.         TransactionSynchronizationManager.clearSynchronization();
53.         return suspendedSynchronizations;
54. }
56. protected Object doSuspend(Object transaction) {
57.         DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
58.         txObject.setConnectionHolder(null);
59.         // ConnectionHolder对象
60.         return TransactionSynchronizationManager.unbindResource(obtainDataSource());
61. }

复制代码

事务恢复

1. protected final void resume(Object transaction, SuspendedResourcesHolder resourcesHolder)
2.                 throws TransactionException {
4.         if (resourcesHolder != null) {
5.                 Object suspendedResources = resourcesHolder.suspendedResources;
6.                 if (suspendedResources != null) {
7.                         // 恢复之前挂起的是ConnectionHolder对象
8.                         doResume(transaction, suspendedResources);
9.                 }
10.                 List<TransactionSynchronization> suspendedSynchronizations =
11.             resourcesHolder.suspendedSynchronizations;
12.                 if (suspendedSynchronizations != null) {
13.                         TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
14.                         TransactionSynchronizationManager
15.                 .setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
16.                         TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
17.                         TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
18.                         doResumeSynchronization(suspendedSynchronizations);
19.                 }
20.         }
21. }
23. protected void doResume(Object transaction, Object suspendedResources) {
24.         // 恢复之前挂起的是ConnectionHolder对象
25.         TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
26. }

复制代码

当前无事务

1. // No existing transaction found -> check propagation behavior to find out how to proceed.
2. if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
3.         // 传播级别设置为PROPAGATION_MANDATORY时，如果当前没有事务，则抛出异常
4.         throw new IllegalTransactionStateException(
5.                         "No existing transaction found for transaction marked with propagation 'mandatory'");
6. } else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
7.                 def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
8.                 def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
9.         SuspendedResourcesHolder suspendedResources = suspend(null);
10.         // Creating new transaction
11.         try {
12.                 return startTransaction(def, transaction, debugEnabled, suspendedResources);
13.         } catch (RuntimeException | Error ex) {
14.                 resume(null, suspendedResources);
15.                 throw ex;
16.         }
17. } else {
18.         // Create "empty" transaction: no actual transaction, but potentially synchronization.
19.         if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
20.                 logger.warn("Custom isolation level specified but no actual transaction initiated; " +
21.                                 "isolation level will effectively be ignored: " + def);
22.         }
23.         boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
24.         return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
25. }

复制代码

创建TransactionInfo

1. protected TransactionInfo prepareTransactionInfo(PlatformTransactionManager tm,
2.                 TransactionAttribute txAttr, String joinpointIdentification,
3.                 TransactionStatus status) {
5.         TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
6.         if (txAttr != null) {
7.                 // The transaction manager will flag an error if an incompatible tx already exists.
8.                 txInfo.newTransactionStatus(status);
9.         } else {
10.                 // The TransactionInfo.hasTransaction() method will return false. We created it only
11.                 // to preserve the integrity of the ThreadLocal stack maintained in this class.
12.         }
14.         // We always bind the TransactionInfo to the thread, even if we didn't create
15.         // a new transaction here. This guarantees that the TransactionInfo stack
16.         // will be managed correctly even if no transaction was created by this aspect.
17.         txInfo.bindToThread();
18.         return txInfo;
19. }

复制代码

异常处理

1. protected void completeTransactionAfterThrowing(TransactionInfo txInfo, Throwable ex) {
2.         if (txInfo != null && txInfo.getTransactionStatus() != null) {
3.                 if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
4.                         try {
5.                                 txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
6.                         } catch (TransactionSystemException ex2) {
7.                                 logger.error("Application exception overridden by rollback exception", ex);
8.                                 ex2.initApplicationException(ex);
9.                                 throw ex2;
10.                         } catch (RuntimeException | Error ex2) {
11.                                 logger.error("Application exception overridden by rollback exception", ex);
12.                                 throw ex2;
13.                         }
14.                 } else {
15.                         // We don't roll back on this exception.
16.                         // Will still roll back if TransactionStatus.isRollbackOnly() is true.
17.                         try {
18.                                 txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
19.                         } catch (TransactionSystemException ex2) {
20.                                 logger.error("Application exception overridden by commit exception", ex);
21.                                 ex2.initApplicationException(ex);
22.                                 throw ex2;
23.                         } catch (RuntimeException | Error ex2) {
24.                                 logger.error("Application exception overridden by commit exception", ex);
25.                                 throw ex2;
26.                         }
27.                 }
28.         }
29. }

复制代码

回滚：

1. public final void rollback(TransactionStatus status) throws TransactionException {
2.         if (status.isCompleted()) {
3.                 throw new IllegalTransactionStateException("Transaction is already completed");
4.         }
6.         DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
7.         processRollback(defStatus, false);
8. }
10. private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
11.         try {
12.                 boolean unexpectedRollback = unexpected;
14.                 try {
15.                         triggerBeforeCompletion(status);
17.                         if (status.hasSavepoint()) {
18.                                 // 回滚到指定保存点
19.                                 status.rollbackToHeldSavepoint();
20.                         } else if (status.isNewTransaction()) {
21.                                 // 事务回滚
22.                                 doRollback(status);
23.                         } else {
24.                                 // Participating in larger transaction
25.                                 if (status.hasTransaction()) {
26.                                         if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
27.                                                 // 设置rollback-only
28.                                                 doSetRollbackOnly(status);
29.                                         }
30.                                 }
31.                                 // Unexpected rollback only matters here if we're asked to fail early
32.                                 if (!isFailEarlyOnGlobalRollbackOnly()) {
33.                                         unexpectedRollback = false;
34.                                 }
35.                         }
36.                 } catch (RuntimeException | Error ex) {
37.                         triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
38.                         throw ex;
39.                 }
41.                 triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
43.                 // Raise UnexpectedRollbackException if we had a global rollback-only marker
44.                 if (unexpectedRollback) {
45.                         throw new UnexpectedRollbackException(
46.                                         "Transaction rolled back because it has been marked as rollback-only");
47.                 }
48.         } finally {
49.                 // 这里面有恢复挂起事务的逻辑
50.                 cleanupAfterCompletion(status);
51.         }
52. }
54. // 回滚到指定保存点
55. public void rollbackToSavepoint(Object savepoint) throws TransactionException {
56.         ConnectionHolder conHolder = getConnectionHolderForSavepoint();
57.         try {
58.                 conHolder.getConnection().rollback((Savepoint) savepoint);
59.                 conHolder.resetRollbackOnly();
60.         } catch (Throwable ex) {
61.                 throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
62.         }
63. }
64. // 释放保存点
65. public void releaseSavepoint(Object savepoint) throws TransactionException {
66.         ConnectionHolder conHolder = getConnectionHolderForSavepoint();
67.         try {
68.                 conHolder.getConnection().releaseSavepoint((Savepoint) savepoint);
69.         } catch (Throwable ex) {
70.                 logger.debug("Could not explicitly release JDBC savepoint", ex);
71.         }
72. }
74. // 事务回滚
75. protected void doRollback(DefaultTransactionStatus status) {
76.         DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
77.         Connection con = txObject.getConnectionHolder().getConnection();
78.         try {
79.                 con.rollback();
80.         } catch (SQLException ex) {
81.                 throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
82.         }
83. }
85. private void cleanupAfterCompletion(DefaultTransactionStatus status) {
86.         status.setCompleted();
87.         if (status.isNewSynchronization()) {
88.                 TransactionSynchronizationManager.clear();
89.         }
90.         if (status.isNewTransaction()) {
91.                 // 恢复连接的事务属性，比如自动提交方式、隔离级别、只读属性等
92.                 // 将连接归还给数据源，清除ConnectionHolder的conn
93.                 doCleanupAfterCompletion(status.getTransaction());
94.         }
95.         if (status.getSuspendedResources() != null) {
96.                 // 恢复之前挂起的事务
97.                 Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
98.                 resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
99.         }
100. }

复制代码

事务清理

1. private void restoreThreadLocalStatus() {
2.         // Use stack to restore old transaction TransactionInfo.
3.         // Will be null if none was set.
4.         transactionInfoHolder.set(this.oldTransactionInfo);
5. }

复制代码

事务提交

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

复制代码

提交：

1. public final void commit(TransactionStatus status) throws TransactionException {
2.         if (status.isCompleted()) {
3.                 throw new IllegalTransactionStateException("Transaction is already completed");
4.         }
6.         DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
7.         if (defStatus.isLocalRollbackOnly()) {
8.                 // Transactional code has requested rollback
9.                 // 回滚
10.                 processRollback(defStatus, false);
11.                 return;
12.         }
14.         if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
15.                 // Global transaction is marked as rollback-only but transactional code requested commit
16.                 // 回滚
17.                 processRollback(defStatus, true);
18.                 return;
19.         }
21.         // 提交事务
22.         processCommit(defStatus);
23. }
25. // 提交事务
26. private void processCommit(DefaultTransactionStatus status) throws TransactionException {
27.         try {
28.                 boolean beforeCompletionInvoked = false;
30.                 try {
31.                         boolean unexpectedRollback = false;
32.                         prepareForCommit(status);
33.                         triggerBeforeCommit(status);
34.                         triggerBeforeCompletion(status);
35.                         beforeCompletionInvoked = true;
37.                         if (status.hasSavepoint()) {
38.                                 unexpectedRollback = status.isGlobalRollbackOnly();
39.                                 // 释放保存点
40.                                 status.releaseHeldSavepoint();
41.                         } else if (status.isNewTransaction()) {
42.                                 unexpectedRollback = status.isGlobalRollbackOnly();
43.                                 // 提交事务
44.                                 doCommit(status);
45.                         } else if (isFailEarlyOnGlobalRollbackOnly()) {
46.                                 unexpectedRollback = status.isGlobalRollbackOnly();
47.                         }
49.                         // Throw UnexpectedRollbackException if we have a global rollback-only
50.                         // marker but still didn't get a corresponding exception from commit.
51.                         if (unexpectedRollback) {
52.                                 throw new UnexpectedRollbackException(
53.                                                 "Transaction silently rolled back because it has been marked as rollback-only");
54.                         }
55.                 } catch (UnexpectedRollbackException ex) {
56.                         // can only be caused by doCommit
57.                         triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
58.                         throw ex;
59.                 } catch (TransactionException ex) {
60.                         // can only be caused by doCommit
61.                         if (isRollbackOnCommitFailure()) {
62.                                 doRollbackOnCommitException(status, ex);
63.                         } else {
64.                                 triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
65.                         }
66.                         throw ex;
67.                 } catch (RuntimeException | Error ex) {
68.                         if (!beforeCompletionInvoked) {
69.                                 triggerBeforeCompletion(status);
70.                         }
71.                         doRollbackOnCommitException(status, ex);
72.                         throw ex;
73.                 }
75.                 // Trigger afterCommit callbacks, with an exception thrown there
76.                 // propagated to callers but the transaction still considered as committed.
77.                 try {
78.                         triggerAfterCommit(status);
79.                 } finally {
80.                         triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
81.                 }
83.         } finally {
84.                 cleanupAfterCompletion(status);
85.         }
86. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！