1.引
上一节简单介绍了Spring中的嵌套事物，接下来针对每一种传播特性，单独分析，当然前提是已经存在一个事物
2.PROPAGATION_NEVER
该特性规定了以非事物方式执行，如果当前存在事物，则抛出异常。
// 1.PROPAGATION_NEVER --> 以非事物方式执行，如果当前存在事物，则抛出异常。 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) { throw new IllegalTransactionStateException("Existing transaction found for transaction marked with propagation 'never'"); }
3.PROPAGATION_NOT_SUPPORTED
该特性规定了以非事物方式执行，如果当前存在事物，则挂起当前事物。
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) { if (debugEnabled) { logger.debug("Suspending current transaction");} // 重点:挂起已有事物 Object suspendedResources = suspend(transaction); boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS); // 创建新事物,注意:transaction参数为null,所以这里创建的不是一个真正的事物 return prepareTransactionStatus( definition, null, false, newSynchronization, debugEnabled, suspendedResources); }
这里又涉及到一个概念，事物挂起（这个前面没有介绍，因为前面都是单个事物）。下面分析一下事物挂起的流程：
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException { // 1.如果存在事物同步回调接口 if (TransactionSynchronizationManager.isSynchronizationActive()) { // 1.1 挂起事务同步回调接口 List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization(); try { // 挂起事物 Object suspendedResources = null; if (transaction != null) { suspendedResources = doSuspend(transaction); } // 获取已有事物名称 String name = TransactionSynchronizationManager.getCurrentTransactionName(); // 清空已有事物名称 TransactionSynchronizationManager.setCurrentTransactionName(null); // 获取已有事物的readOnly属性值 boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly(); // 将已有事物的readOnly属性值设置为false TransactionSynchronizationManager.setCurrentTransactionReadOnly(false); // 获取已有事物数据库事物隔离级别 Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel(); // 清空已有事物数据库事物隔离级别 TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null); // 获取已有事物激活标识 boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive(); // 将当前事物激活标识设置为false TransactionSynchronizationManager.setActualTransactionActive(false); // 返回SuspendedResourcesHolder /** * 将上面获取到的一系列事物属性,重新封装至SuspendedResourcesHolder对象,并返回 */ return new SuspendedResourcesHolder(suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive); } catch (RuntimeException | Error ex) { // doSuspend failed - original transaction is still active... doResumeSynchronization(suspendedSynchronizations); throw ex; } } // 不存在事物同步回调接口,且当前事物不为空 else if (transaction != null) { // Transaction active but no synchronization active. // 事物已经被激活,但是没有事物同步回调,则直接挂起当前事物即可 Object suspendedResources = doSuspend(transaction); // 返回挂起的事物资源 return new SuspendedResourcesHolder(suspendedResources); } // 处理没有事物的情况... else { // Neither transaction nor synchronization active. return null; } }
首先来看事物同步回调接口，该接口会在prepareSynchronization方法中设置，即使我们没有自定义事物同步回调接口，Spring默认也会为当前事物创建一个空的事物同步回调接口。关于该接口的使用，可以参考上一节中的例子。（注意：事物同步回调接口是与当前线程绑定的）。下面看事物同步接口是如何挂起的：
private List<TransactionSynchronization> doSuspendSynchronization() { // 1.获取当前线程的所有事物同步回调 List<TransactionSynchronization> suspendedSynchronizations = TransactionSynchronizationManager.getSynchronizations(); // 2.循环并挂起所有同步回调接口 for (TransactionSynchronization synchronization : suspendedSynchronizations) { synchronization.suspend(); } // 3.清除资源 TransactionSynchronizationManager.clearSynchronization(); return suspendedSynchronizations; }
其次来看挂起事物的流程，注释里已经写了很清楚了，最后会将已有的事物属性封装到SuspendedResourcesHolder对象中，该类就持有了被挂起事物的属性。接下来调用prepareTransactionStatus方法并将suspendedResources入参，这样一来，新创建的事物就持有了被挂起事物的的属性，就会形成一个事物链。而且新创建的事物transaction参数为null，所以PROPAGATION_NOT_SUPPORTED特性是不会真正开启事物的。
return prepareTransactionStatus( definition, null, false, newSynchronization, debugEnabled, suspendedResources);
4.PROPAGATION_REQUIRES_NEW
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) { if (debugEnabled) { logger.debug("Suspending current transaction, creating new transaction with name [" + definition.getName() + "]"); } // 挂起已有事物 SuspendedResourcesHolder suspendedResources = suspend(transaction); try { boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); // 创建事物 DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources); // 开启事物 doBegin(transaction, definition); // 初始化事物同步属性 prepareSynchronization(status, definition); return status; } catch (RuntimeException | Error beginEx) { resumeAfterBeginException(transaction, suspendedResources, beginEx); throw beginEx; } }
该特性下会挂起已有事物并新建一个事物。
5.PROPAGATION_NESTED
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) { // 如果不允许嵌套事物,则抛出异常 if (!isNestedTransactionAllowed()) { throw new NestedTransactionNotSupportedException("Transaction manager does not allow nested transactions by default - " + "specify 'nestedTransactionAllowed' property with value 'true'"); } if (debugEnabled) { logger.debug("Creating nested transaction with name [" + definition.getName() + "]"); } /** * 下面对JtaTransactionManager和AbstractPlatformTransactionManager分别进行处理 */ // useSavepointForNestedTransaction(),是否为嵌套事务使用保存点 // 1.对于JtaTransactionManager-->返回false // 2.对于AbstractPlatformTransactionManager-->返回true if (useSavepointForNestedTransaction()) { // Create savepoint within existing Spring-managed transaction, // through the SavepointManager API implemented by TransactionStatus. // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization. // 创建保存点在现有spring管理事务,通过TransactionStatus SavepointManager API实现。 // 通常使用JDBC 3.0保存点。永远不要激活Spring同步。 DefaultTransactionStatus status = prepareTransactionStatus(definition,transaction, false, false, debugEnabled, null); // 创建保存点 status.createAndHoldSavepoint(); return status; } else { // Nested transaction through nested begin and commit/rollback calls. // Usually only for JTA: Spring synchronization might get activated here // in case of a pre-existing JTA transaction. // 通过嵌套的开始,提交调用,及回滚调用进行嵌套事务。 // 只对JTA有效,如果已经存在JTA事务，这里可能会激活Spring同步。 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, null); doBegin(transaction, definition); prepareSynchronization(status, definition); return status; } }
这里对AbstractPlatformTransactionManager和JtaTransactionManager分别做了不同的处理，重点看前者。AbstractPlatformTransactionManager是允许使用保存点的。接下来看保存点的创建过程：
// 创建保存点 public void createAndHoldSavepoint() throws TransactionException { setSavepoint(getSavepointManager().createSavepoint()); }
// 获取SavepointManager protected SavepointManager getSavepointManager() { Object transaction = this.transaction; if (!(transaction instanceof SavepointManager)) { throw new NestedTransactionNotSupportedException( "Transaction object [" + this.transaction + "] does not support savepoints"); } // SavepointManager就是当前事物 return (SavepointManager) transaction; }
// 创建保存点 public Object createSavepoint() throws TransactionException { // 获取ConnectionHolder ConnectionHolder conHolder = getConnectionHolderForSavepoint(); try { // 如果当前连接不支持保存点,抛出异常 if (!conHolder.supportsSavepoints()) { throw new NestedTransactionNotSupportedException( "Cannot create a nested transaction because savepoints are not supported by your JDBC driver"); } // 如果当前连接的RollbackOnly已经被标记为true,抛出异常 if (conHolder.isRollbackOnly()) { throw new CannotCreateTransactionException( "Cannot create savepoint for transaction which is already marked as rollback-only"); } // 创建保存点 return conHolder.createSavepoint(); } catch (SQLException ex) { throw new CannotCreateTransactionException("Could not create JDBC savepoint", ex); } }
总体来讲创建保存点的过程比较简单，最终会调用数据库驱动的底层方法去创建保存点，感兴趣的可以自己跟踪查看。创建完保存点之后将结果设置到TransactionStatus对象中。
该特性下会将新事物在原有事物内，以嵌套的方式运行，该特性也不会开启一个新的事物
6. PROPAGATION_SUPPORTS和PROPAGATION_REQUIRED
假如事物传播特性是PROPAGATION_SUPPORTS或PROPAGATION_REQUIRED的话，将会进行如下处理：
if (isValidateExistingTransaction()) { // 验证事物隔离级别 // 如果当前事物的隔离级别不为默认隔离级别,则比较当前事物隔离级别与已有事物隔离级别, // 如不同,则抛出事物隔离级别不兼容异常 if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) { Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel(); if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) { Constants isoConstants = DefaultTransactionDefinition.constants; throw new IllegalTransactionStateException("Participating transaction with definition [" + definition + "] specifies isolation level which is incompatible with existing transaction: " + (currentIsolationLevel != null ? isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) : "(unknown)")); } } // 验证事物只读属性 // 如果当前事物可写,但是已有的事物是只读,则抛出异常 if (!definition.isReadOnly()) { if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) { throw new IllegalTransactionStateException("Participating transaction with definition [" + definition + "] is not marked as read-only but existing transaction is"); } } } boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
isValidateExistingTransaction()该函数的作用是指定新事物参与已有事物时，新旧两个事物的验证级别。该属性值默认为false，宽松范围的验证，也就是不验证。如果将该属性值改为true的话，那么将会验证新旧两个事物的数据库事物隔离级别、事物只读属性是否相同。对于PROPAGATION_MANDATORY，从Spring的注释上没有看到对改属性的处理，但是该属性也会走这个分支，即使用已有事物，由于到这里肯定是已经存在事物的，该特性在这里不会抛出异常。
该特性也不会开启一个新的事物，而是继续在原有事物中运行或者以非事物方式运行
