Spring事务传播实现原理
什么是事务传播？
假设这样一个场景：方法A上面添加了一个@Transactional注解，在该方法中去调用另一个Service的方法B，但方法B并不需要事务，但是由于A开启了事务，导致B方法的执行也处于事务范围，那么这种情况该如何处理呢？
简单来说事务传播其实就是当一个事务方法调用其它方法时，被调用的方法可以通过@Transactional注解来决定如何应对调用方的事务，是抛出异常(Propagation.NEVER)？还是挂起调用方的事务(Propagation.NOT_SUPPORTED)？还是被调用方法自己再开启一个事务(Propagation#REQUIRES_NEW)？这点也和Spring官方文档中关于事务传播行为的解释不谋而合。
另外需要说明的是数据库没有事务传播这个概念。
底层实现
我们在使用Spring的声明式事务时需要配置一个TransactionManager，字面翻译就是事务管理器。事务传播行为就是在该接口的抽象实现-AbstractPlatformTransactionManager的getTransaction方法中实现的。
@Bean public TransactionManager transactionManager(){ return new DataSourceTransactionManager(dataSource()); }
在getTransaction方法中，首先通过doGetTransaction方法来获取事务，接下来通过isExistingTransaction方法来判断是否存在事务，如果存在事务则执行handleExistingTransaction方法来处理已存在的事务。
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException { // Use defaults if no transaction definition given. TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults()); Object transaction = doGetTransaction(); boolean debugEnabled = logger.isDebugEnabled(); if (isExistingTransaction(transaction)) { // Existing transaction found -> check propagation behavior to find out how to behave. return handleExistingTransaction(def, transaction, debugEnabled); } // 删除与本次分析无关代码... } }
doGetTransaction方法由AbstractPlatformTransactionManager类定义，由DataSourceTransactionManager类实现，典型的模板方法设计模式。
在该方法中，首先创建一个事务对象-DataSourceTransactionObject ，重点是接下来的设置数据库链接持有器(封装了数据库链接-Connection)，通过TransactionSynchronizationManager的getResource方法来获取数据库链接持有器-ConnectionHolder，然后将获取到的数据库链接持有器设置到DataSourceTransactionObject中。因为数据库事务是和数据库链接-Connection有关(通过Connection的rollback或commit方法来回滚事务或提交事务)，因此我们只需要关注一个数据库链接如何在不同方法之间传递。
// DataSourceTransactionManager#doGetTransaction protected Object doGetTransaction() { DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject(); txObject.setSavepointAllowed(this.isNestedTransactionAllowed()); ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource()); txObject.setConnectionHolder(conHolder, false); return txObject; }
接下来就查看下TransactionSynchronizationManager的getResource方法，在该方法中调用TransactionSynchronizationUtils的unwrapResourceIfNecessary对传入的Key解除包装，然后调用doGetResource方法来根据解除包装后的Key获取对应的value，最后返回这个value。
public static Object getResource(Object key) { Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key); Object value = doGetResource(actualKey); if (value != null && logger.isTraceEnabled()) { logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]"); } return value; }
在doGetResource方法中，调用resources的get方法来获取一个Map，看上去熟悉不？通过get方法不需要传入key就能获取value，你脑海中首先想到的是什么？
private static Object doGetResource(Object actualKey) { Map<Object, Object> map = resources.get(); if (map == null) { return null; } Object value = map.get(actualKey); // 删除与本次分析无关的代码 return value; }
Bingo，答案就是ThreadLocal！看到这里估计已经有小伙伴能明白Spring声明式事务-@Transactional注解中事务传播行为是如何实现的。就是使用ThreadLocal来解决不同事务方法之间的数据库链接问题。
private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");
那么TransactionSynchronizationManager是什么东西呢？查看该类源码可以发现就是定义了六个ThreadLocal用于存放和事务相关的数据，例如前面我们看到的存放事务对象的-resources，存放当前事务名称的currentTransactionName 等等，其就是一个事物同步管理器。
public abstract class TransactionSynchronizationManager { private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class); // 用于存放当前事务 private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources"); // 用于存放同步回调接口实现类 private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal<>("Transaction synchronizations"); // 当前事务名称 private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal<>("Current transaction name"); // 当前事务是否只读 private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal<>("Current transaction read-only status"); // 当前事务的隔离级别 private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal<>("Current transaction isolation level"); // 当前事务是否活跃 private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal<>("Actual transaction active"); // ...... }
OK，明白Spring是如何将一个数据库链接在不同方法之间传递后，那再阅读isExistingTransaction(判断是否存在事务)和handleExistingTransaction(处理已存在事务)方法就会很简单。
在isExistingTransaction方法中就是通过判断传入的DataSourceTransactionObject对象(该对象由前面的doGetTransaction方法返回)持有的ConnectionHolder是否不等于空并且是否活跃。如果两个条件都满足则返回true，否则false。
// DataSourceTransactionManager#isExistingTransaction protected boolean isExistingTransaction(Object transaction) { DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction; return txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive(); }
handleExistingTransaction方法需要着重分析下，因为在该方法中完成了事务传播行为的实现，首先根据事务定义信息-TransactionDefinition (根据@Transactional注解创建)来获取事务传播行为。
// AbstractPlatformTransactionManager#handleExistingTransaction private TransactionStatus handleExistingTransaction( TransactionDefinition definition, Object transaction, boolean debugEnabled) throws TransactionException { // 当前方法上的@Transactional(propagation = Propagation.NEVER)配置是这样，则抛出异常 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) { throw new IllegalTransactionStateException( "Existing transaction found for transaction marked with propagation 'never'"); } // 当前方法上的@Transactional(propagation = Propagation.NOT_SUPPORTED)配置是这样 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) { if (debugEnabled) { logger.debug("Suspending current transaction"); } Object suspendedResources = suspend(transaction); // 调用suspend方法挂起事务 boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS); return prepareTransactionStatus( definition, null, false, newSynchronization, debugEnabled, suspendedResources); } // 当前方法上的@Transactional(propagation = 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 { // 调用startTransaction方法开启一个新的事务，其实就是重新从数据源中获取一个数据库链接，不使用原有的数据库链接 return startTransaction(definition, transaction, debugEnabled, suspendedResources); } catch (RuntimeException | Error beginEx) { resumeAfterBeginException(transaction, suspendedResources, beginEx); throw beginEx; } } if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) { // 嵌套事务处理这里就不再展开分析 } // 删除与本次分析无关源码... }
这里我们就以事务传播行为中Propagation.REQUIRES_NEW来分析下如果存在当前事务，是如何挂起当前事务的，其实就是分析suspend方法的执行逻辑。
// AbstractPlatformTransactionManager#suspend protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException { if (TransactionSynchronizationManager.isSynchronizationActive()) { List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization(); try { Object suspendedResources = null; if (transaction != null) { suspendedResources = doSuspend(transaction); // 暂停当前事务其实就是从ThreadLocal中移除当前事务 } String name = TransactionSynchronizationManager.getCurrentTransactionName(); TransactionSynchronizationManager.setCurrentTransactionName(null); // 将当前事务名称设置为null boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly(); TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);// 将当前事务是否只读设置为false Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel(); TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);// 将当前事务隔离级别设置为null boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive(); TransactionSynchronizationManager.setActualTransactionActive(false);// 将当前事务活跃状态设置为false return new SuspendedResourcesHolder( suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);// 根据要挂起的事务定义信息来构建一个SuspendedResourcesHolder对象 } catch (RuntimeException | Error ex) { // doSuspend failed - original transaction is still active... doResumeSynchronization(suspendedSynchronizations); throw ex; } } else if (transaction != null) { Object suspendedResources = doSuspend(transaction); return new SuspendedResourcesHolder(suspendedResources); } else { return null; } }
通过查看suspend方法，我们知道所谓挂起事务其实就是先从六个ThreadLocal中获取到当前事务的定义信息，并将这六个ThreadLocal重置为初始状态，根据当前事务的定义信息创建SuspendedResourcesHolder并返回。
那么接下来的startTransaction方法是如何处理上一步挂起的事务呢？
在startTransaction方法入参中，有一个值得注意的参数就是SuspendedResourcesHolder，它就是被挂起的当前事务定义信息。
// AbstractPlatformTransactionManager#startTransaction private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) { boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); // 创建一个DefaultTransactionStatus实例，该对象保存了SuspendedResourcesHolder DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources); doBegin(transaction, definition);// 开启事务 prepareSynchronization(status, definition);//预刷新事务同步 return status; }
如果让你来设计，你应该如何重新开启一个新的事务呢？
// DataSourceTransactionManager#doBegin protected void doBegin(Object transaction, TransactionDefinition definition) { DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction; Connection con = null; try { if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) { Connection newCon = this.obtainDataSource().getConnection(); // 根据数据源对象重新获取一个数据库链接 if (this.logger.isDebugEnabled()) { this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction"); } // 将新获取到的数据连接设置到事务对象中 txObject.setConnectionHolder(new ConnectionHolder(newCon), true); } txObject.getConnectionHolder().setSynchronizedWithTransaction(true); con = txObject.getConnectionHolder().getConnection(); Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition); // 设置事务隔离界别 txObject.setPreviousIsolationLevel(previousIsolationLevel); txObject.setReadOnly(definition.isReadOnly()); // 设置事务是否只读 if (con.getAutoCommit()) { txObject.setMustRestoreAutoCommit(true); if (this.logger.isDebugEnabled()) { this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit"); } con.setAutoCommit(false); // 关闭事务自动提交 } this.prepareTransactionalConnection(con, definition); txObject.getConnectionHolder().setTransactionActive(true); // 设置事务活跃状态 int timeout = this.determineTimeout(definition); if (timeout != -1) { txObject.getConnectionHolder().setTimeoutInSeconds(timeout); } if (txObject.isNewConnectionHolder()) { TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder()); // 将当前事务对象设置到事务同步管理器中 } } catch (Throwable var7) { if (txObject.isNewConnectionHolder()) { DataSourceUtils.releaseConnection(con, this.obtainDataSource()); txObject.setConnectionHolder((ConnectionHolder)null, false); } throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7); } }
答案很简单，就是重新获取一个数据库链接。
@Transactional注解propagation方法返回值和TransactionDefinition映射关系。详见下文：
@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Transactional { // ...... Propagation propagation() default Propagation.REQUIRED; // ...... } public enum Propagation { // 需要事务，如果当前存在事务就是用当前事务，否则新建事务 REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED), // 支持事务，如果当前存在事务就使用当前事务，否则以非事务方式运行 SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS), // 支持事务，如果当前没有事务则抛出异常 MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY), // 无论当前存不存在事务，都新建一个事务 REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW), // 不支持事务，如果当前存在事务，则挂起当前事务 NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED), // 绝不支持事务，如果当前存在事务则抛出异常 NEVER(TransactionDefinition.PROPAGATION_NEVER), // 支持嵌套事务 NESTED(TransactionDefinition.PROPAGATION_NESTED); private final int value; Propagation(int value) { this.value = value; } public int value() { return this.value; } }
总结
所谓Spring事务中的传播行为其实就是当事务方法调用其它方法时，被调用的方法可以通过@Transactional来决定如何应对调用方法的事务。
熟悉JDBC的小伙伴都明白，事务是和数据库链接-Connection相关，所以无论Spring声明式事务外表多么华丽，繁杂，其本质还是基于Connection来完成，这点是毋庸置疑的，Spring也无法超脱于JDBC来另起炉灶。为了解决数据库链接跨方法传递，Spring使用了ThreadLocal来解决。
