1.引
上一节分析了嵌套事物的创建，本节分析每种传播特性的回滚处理过程。由于这一部分的组合情况会很多，我们只分析其中的一两种情况，更多的大家还是要多看源码、多测试！ 注意：这里最外层的事物一定要开启，如果将最外层的事物特性设置为PROPAGATION_NOT_SUPPORTED，则不会引发嵌套事物的问题。
2.processRollback回顾
private void processRollback(DefaultTransactionStatus status, boolean unexpected) { try { boolean unexpectedRollback = unexpected; try { // 1.事物完成之前的触发器调用 triggerBeforeCompletion(status); // 2.如果有保存点,则调用rollbackToHeldSavepoint回滚到保存点 if (status.hasSavepoint()) { if (status.isDebug()) { logger.debug("Rolling back transaction to savepoint"); } status.rollbackToHeldSavepoint(); } // 3.如果当前事物是一个新的事物,则调用doRollback执行给定事物的回滚 else if (status.isNewTransaction()) { if (status.isDebug()) { logger.debug("Initiating transaction rollback"); } doRollback(status); } else { // Participating in larger transaction // 4.如果当前事物并非独立事物,则将当前事物的rollbackOnly属性标记为true,等到事物链完成之后,一起执行回滚 // 如果当前存在事物,但是 // 事物的rollbackOnly属性已经被标记为true // 或者globalRollbackOnParticipationFailure(返回是否仅在参与事务失败后才将现有事务全局标记为回滚)为true if (status.hasTransaction()) { if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) { if (status.isDebug()) { logger.debug("Participating transaction failed - marking existing transaction as rollback-only"); } System.out.println("==当前事物并非独立事物,且RollbackOnly为true\n"); // 则将ConnectionHolder中的rollbackOnly标记为true doSetRollbackOnly(status); } else { if (status.isDebug()) { logger.debug("Participating transaction failed - letting transaction originator decide on rollback"); } } } // 5.如果当前不存在事物,则不会回滚 // 例如配置了 @Transactional(propagation = Propagation.NOT_SUPPORTED) else { logger.debug("Should roll back transaction but cannot - no transaction available"); } // Unexpected rollback only matters here if we're asked to fail early if (!isFailEarlyOnGlobalRollbackOnly()) { unexpectedRollback = false; } } } catch (RuntimeException | Error ex) { triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN); throw ex; } // 6.事物完成之后的触发器调用 triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK); // Raise UnexpectedRollbackException if we had a global rollback-only marker if (unexpectedRollback) { throw new UnexpectedRollbackException("Transaction rolled back because it has been marked as rollback-only"); } } finally { //7.事物完成后清理资源 cleanupAfterCompletion(status); } }
3.NOT_SUPPORTED
BankService、PersonService、AccountService的事物传播特性依次是：
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) public void save() throws RuntimeException { System.out.println("==调用BankService的save方法\n"); System.out.println("==准备调用PersonService的save方法\n"); personService.save(); System.out.println("==准备调用PersonService的save方法\n"); accountService.save(); throw new RuntimeException("==AccountService的save方法手动抛出异常"); } @Override @Transactional(propagation = Propagation.NOT_SUPPORTED, rollbackFor = Exception.class) public void save() throws RuntimeException { System.out.println("==调用PersonService的save方法\n"); jdbcTemplate.update(insert_sql); throw new RuntimeException("==PersonService手动抛出异常"); } @Transactional(propagation = Propagation.NOT_SUPPORTED, rollbackFor = Exception.class) public void save() throws RuntimeException { System.out.println("==调用AccountService的save方法\n"); jdbcTemplate.update(insert_sql); throw new RuntimeException("==AccountService的save方法手动抛出异常"); }
该特性下PersonService、AccountService并不会开启事物，在processRollback方法中会走到第6点，所以即便PersonService、AccountService抛出异常，也不会回滚。但是最外层的BankService是开启事物的，所以如果BankService里有针对数据库的写操作并抛出异常，依然会回滚。
但是这里是嵌套事物的回滚，当内层事物回滚之后不要忘记，外层事物还处在被挂起的状态，那么外层被挂起的事物如何恢复呢？就在processRollback方法中的第7点。
4.恢复挂起事物
private void cleanupAfterCompletion(DefaultTransactionStatus status) { // 1.将当前事物状态标记为已完成 status.setCompleted(); // 2.清除synchronization if (status.isNewSynchronization()) { TransactionSynchronizationManager.clear(); } // 3.事务完成后清理资源。 if (status.isNewTransaction()) { doCleanupAfterCompletion(status.getTransaction()); } // 4.从嵌套事物中恢复被挂起的资源 if (status.getSuspendedResources() != null) { if (status.isDebug()) { logger.debug("Resuming suspended transaction after completion of inner transaction"); } Object transaction = (status.hasTransaction() ? status.getTransaction() : null); resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources()); } }
关于其他的资源清理涉及的代码很多，留在后面介绍，这里我们只看如何恢复被挂起的事物。
protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder) throws TransactionException { if (resourcesHolder != null) { Object suspendedResources = resourcesHolder.suspendedResources; if (suspendedResources != null) { // 恢复挂起资源 doResume(transaction, suspendedResources); } List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations; // 恢复挂起的事物同步回调接口 if (suspendedSynchronizations != null) { TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive); TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel); TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly); TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name); doResumeSynchronization(suspendedSynchronizations); } } } protected void doResume(@Nullable Object transaction, Object suspendedResources) { TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources); } public static void bindResource(Object key, Object value) throws IllegalStateException { Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key); Assert.notNull(value, "Value must not be null"); Map<Object, Object> map = resources.get(); // set ThreadLocal Map if none found if (map == null) { map = new HashMap<>(); resources.set(map); } Object oldValue = map.put(actualKey, value); // Transparently suppress a ResourceHolder that was marked as void... if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) { oldValue = null; } if (oldValue != null) { throw new IllegalStateException("Already value [" + oldValue + "] for key [" +actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]"); } if (logger.isTraceEnabled()) { logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" +Thread.currentThread().getName() + "]"); } }
该方法比较简单，获取被挂起事物后重新绑定到resources对象即可。resources的定义如下：
private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");
5.PROPAGATION_REQUIRES_NEW
该情况下，因为PROPAGATION_REQUIRES_NEW每次都会新建事物，并挂起已有事物，所以在该传播特性下，如果PersonService或AccountService发生异常，就会执行回滚操作。当PersonService或AccountService完成回滚之后，恢复并回滚之前挂起的事物即可。至于外层被挂起的事物会不会回滚，则要根据外层事物的传播特性而定。假如外层事物的传播特性为NOT_SUPPORTED，那么即便外层事物操作了数据库并抛出异常也不会被回滚。而且不会有嵌套事物的问题。
6.PROPAGATION_NESTED
该特性下就有可能会走到processRollback方法的弟2步，即回滚到保存点。前提是外层开启事物，且内层事物必须有异常抛出。针对本例即BankService必须开启事物，PersonService或AccountService抛出异常。如果PersonService或AccountService没有抛出异常，虽然两者存在保存点，但是并不会回滚，这样一来即便BankService抛出异常并回滚也不会回滚到保存点，因为保存点是建立在PersonService和AccountService对应的事物上的。
下面来看回滚到保存点的实现：
/** * 回滚到事物的保存点并释放保存点资源 * Roll back to the savepoint that is held for the transaction * and release the savepoint right afterwards. */ public void rollbackToHeldSavepoint() throws TransactionException { Object savepoint = getSavepoint(); if (savepoint == null) { throw new TransactionUsageException("Cannot roll back to savepoint - no savepoint associated with current transaction"); } // 回滚到保存点 getSavepointManager().rollbackToSavepoint(savepoint); // 释放保存点资源 getSavepointManager().releaseSavepoint(savepoint); setSavepoint(null); } public void rollbackToSavepoint(Object savepoint) throws TransactionException { // 回滚到保存点并重置RollbackOnly属性 ConnectionHolder conHolder = getConnectionHolderForSavepoint(); try { conHolder.getConnection().rollback((Savepoint) savepoint); conHolder.resetRollbackOnly(); } catch (Throwable ex) { throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex); } } public void releaseSavepoint(Object savepoint) throws TransactionException { ConnectionHolder conHolder = getConnectionHolderForSavepoint(); try { // 释放保存点资源 conHolder.getConnection().releaseSavepoint((Savepoint) savepoint); } catch (Throwable ex) { logger.debug("Could not explicitly release JDBC savepoint", ex); } }
7.PROPAGATION_SUPPORTS和PROPAGATION_REQUIRED
对于这两种特性，既不会开启一个新的事物，也不会在原有事物中嵌套运行，而是把本身的事物交给已有事物。该情况下会执行到processRollback方法的第4点，将rollbackOnly标记为true，等到最外层事物事物回滚的时候一起回滚。即使最外层的事物没有抛出异常，内层事物的异常也会被外层事物截获并将整个事物进行回滚。
8.总结
关于嵌套事物的处理，就先分析到这里，大家还是要多结合事物创建过程、事物传播特性等多多分析。
