【Spring】Transation：源码执行流程（下）提交与回滚

╰+攻爆jí腚メ 2022-10-31 10:58 138阅读 0赞

# 剩余流程（提交与回滚）解析 #

前面已经把最重要对象 `TransactionStatus` 准备流程说清了，剩下的事务控制实际上已经很简单了，获取到 `TransactionInfo` （主要是内部那个 `TransactionStatus` 以及对 `TransactionSychronizationManager` 的操作）：

后续的操作我们看到，就是三部分：报错做什么、最终做什么、怎么提交。

if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) { 
    			// Standard transaction demarcation with getTransaction and commit/rollback calls.
    			TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification); // 创建或者拿到当前事务信息
    
    			Object retVal;
    			try { 
    				// This is an around advice: Invoke the next interceptor in the chain.
    				// This will normally result in a target object being invoked.
    				retVal = invocation.proceedWithInvocation();// 执行切面
    			}
    			catch (Throwable ex) { 
    				// target invocation exception
    				completeTransactionAfterThrowing(txInfo, ex);// 回滚逻辑
    				throw ex;
    			}
    			finally { 
    				cleanupTransactionInfo(txInfo);// 拿回上一个事务
    			}
    			
    			commitTransactionAfterReturning(txInfo);// 提交当前事务
    			return retVal;
    		}

`cleanupTransactionInfo()` 已经讲过，就是 `TransactionInfo` 里有一个上一个事务 `TransactionInfo` 的引用，只是把它找回来，没什么太多的东西。

## 事务怎么做回滚 ##

回滚的核心方法在这里：

if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) { 
    				try { 
    					txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
    				}
    				catch (TransactionSystemException ex2) { 
    					logger.error("Application exception overridden by rollback exception", ex);
    					ex2.initApplicationException(ex);
    					throw ex2;
    				}
    				catch (RuntimeException | Error ex2) { 
    					logger.error("Application exception overridden by rollback exception", ex);
    					throw ex2;
    				}
    			}

我们可以看到，回滚的时候，会先保证处于我们标识的异常里，默认是所有的 `Error` 和 `RuntimeException` ，**注意这点哦，如果你对非 `RuntimeException` 进行了抛出，是不会回滚的！或者你重写了 `Throwable`，也不会！**

回滚的方法比较简单，但是又几个要注意的点：

triggerBeforeCompletion(status);
    
    				if (status.hasSavepoint()) { 
    					if (status.isDebug()) { 
    						logger.debug("Rolling back transaction to savepoint");
    					}
    					status.rollbackToHeldSavepoint();
    				}
    				else if (status.isNewTransaction()) { 
    					if (status.isDebug()) { 
    						logger.debug("Initiating transaction rollback");
    					}
    					doRollback(status);
    				}
    				else { 
    					// Participating in larger transaction
    					if (status.hasTransaction()) { 
    						if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) { 
    							if (status.isDebug()) { 
    								logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
    							}
    							// 如果有事务，则通过 `TransactionStatus` 将 `ConnectionHolder` 的变量 `rollbackOnly` 设置为真
    							doSetRollbackOnly(status);
    						}
    						else { 
    							if (status.isDebug()) { 
    								logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
    							}
    						}
    					}
    					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;
    			}
    
    			triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

我们可以看到有很多的触发（trigger），这些触发实际上都是我们刚才讲的那个 `Set<TransactionSynchronization>` 这里就不多说了。

这里的回滚分为几种情况：

1.  有保存点的，刚才讲过了，看漏的回去翻翻 `PROPAGATION_NESTED 与 SAVEPOINT保存点`
2.  崭新的事务！这是最简单的，就是调用 connection.rollback()

protected void doRollback(DefaultTransactionStatus status) { 
    		DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
    		Connection con = txObject.getConnectionHolder().getConnection();
    		if (status.isDebug()) { 
    			logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
    		}
    		try { 
    			con.rollback();
    		}
    	}

是的，到这里你发现除了保存点的回滚，这里没有做任何实质的回滚操作！它只是设置了一下 `rollbackOnly`，然后抛出异常，不过这个异常比如 `mybatis` 会捕获，并调用 `sqlSession.rollback()` 真正做回滚，不过这是 mybatis 的操作了。

## 事务怎么做提交 ##

提交也和回滚一样的道理，入口如下：

protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) { 
    		if (txInfo != null && txInfo.getTransactionStatus() != null) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
    			}
    			txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
    		}
    	}

它的实现如下：

public final void commit(TransactionStatus status) throws TransactionException { 
    		if (status.isCompleted()) { 
    			throw new IllegalTransactionStateException(
    					"Transaction is already completed - do not call commit or rollback more than once per transaction");
    		}
    
    		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
    		if (defStatus.isLocalRollbackOnly()) { 
    			if (defStatus.isDebug()) { 
    				logger.debug("Transactional code has requested rollback");
    			}
    			processRollback(defStatus, false);
    			return;
    		}
    
    		if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) { 
    			if (defStatus.isDebug()) { 
    				logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
    			}
    			processRollback(defStatus, true);
    			return;
    		}
    
    		processCommit(defStatus);
    	}

在这里，它会判断有没有其他地方给 `ConnectionHolder` 设置了 `rollbackOnly`，如果设置了，也会进行回滚操作，和回滚一样，最终抛出异常：

如果没有则正常调用 `processCommit()`，这里不细讲，因为和 `processRollback()` 没什么太大区别，就是几个触发（trigger），然后如果有保存点，就释放一下保存点，最终来到 `PlatformTransactionManager#docommit()`。

**值得注意的是，只有崭新的事务( `newTransaction = true` )才会调用 `docommit()`**，内嵌事务就不是崭新的事务，怎么判断崭新事务，就是那个创建了 `ConnectionHolder`，开启了连接的那一个事务，凡是拿了已有的 `ConnectionHolder` 进行操作的事务都不是崭新的事务：

protected void doCommit(DefaultTransactionStatus status) { 
    		DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
    		Connection con = txObject.getConnectionHolder().getConnection();
    		if (status.isDebug()) { 
    			logger.debug("Committing JDBC transaction on Connection [" + con + "]");
    		}
    		try { 
    			con.commit();
    		}
    	}

代码一样很简单，这里就不啰嗦了。