spring源码分析之事务transaction上篇

大家基本上都用过事务，今天一起分析下spring源码中也比较重要的一个模块-事务。spring中事务这一块要完全使用好还是有一定难度，主要是很多细节需要注意，如果你还没有完全明白spring的事务，那么这篇文章肯定会让你收获满满。

一、创建代理

spring事务创建代理的流程和spring aop创建代理几乎是一模一样，不清楚的可以自行阅读相关资料或者参考这篇文章（spring aop分析）。这里稍微介绍创建代理之前spring会先创建几个重要的对象

我们从@EnableTransactionManagement这个事务的开关的入口开始

1.@EnableTransactionManagement

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
   }

不多讲，直接看@Import里面的类，如果不明白的，可以阅读这篇文章（spring源码解析之ConfigurationClassPostProcessor分析）

2.TransactionManagementConfigurationSelector

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
   

   /** * Returns {@link ProxyTransactionManagementConfiguration} or * {@code AspectJ(Jta)TransactionManagementConfiguration} for {@code PROXY} * and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, * respectively. */
   @Override
   protected String[] selectImports(AdviceMode adviceMode) {
   
      switch (adviceMode) {
   
          //默认是PROXY，spring会讲该方法返回的string[]都实例化
         case PROXY:
            return new String[] {
   AutoProxyRegistrar.class.getName(),
                  ProxyTransactionManagementConfiguration.class.getName()};
         case ASPECTJ:
            return new String[] {
   determineTransactionAspectClass()};
         default:
            return null;
      }
   }
    //...省略
}

所以到这里，spring会实例化一个AutoProxyRegistrar对象和ProxyTransactionManagementConfiguration对象，其中AutoProxyRegistrar和AOP创建那个拦截是否需要代理的BeanpostProcessor一样，这里就不继续跟，感兴趣自行阅读。我们看ProxyTransactionManagementConfiguration。

3.ProxyTransactionManagementConfiguration

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
   

   @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
         TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
   

      BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
      advisor.setTransactionAttributeSource(transactionAttributeSource);
      advisor.setAdvice(transactionInterceptor);
      if (this.enableTx != null) {
   
         advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
      }
      return advisor;
   }

   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionAttributeSource transactionAttributeSource() {
   
      return new AnnotationTransactionAttributeSource();
   }

   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
   
      TransactionInterceptor interceptor = new TransactionInterceptor();
      interceptor.setTransactionAttributeSource(transactionAttributeSource);
      if (this.txManager != null) {
   
         interceptor.setTransactionManager(this.txManager);
      }
      return interceptor;
   }

}

这里会创建三个对应的三个实例

BeanFactoryTransactionAttributeSourceAdvisor：是一个advisor，一般封装advice和pointcut

TransactionAttributeSource：用于解析事务标签属性

TransactionInterceptor：这个最重要，直接就是动态代理的调用的方法，其实现了MethodInterceptor接口。所以当调用生成的动态代理的方法时，会调用到TransactionInterceptor.invoke()方法，这也是我们今天分析的入口。其他的流程和springAOP流程一致，可自行阅读

二、创建事务源码分析

直接从TransactionInterceptor#invoke()开始分析

1.TransactionInterceptor.invoke()

public Object invoke(MethodInvocation invocation) throws Throwable {
   
   // Work out the target class: may be {@code null}.
   // The TransactionAttributeSource should be passed the target class
   // as well as the method, which may be from an interface.
   Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

   // Adapt to TransactionAspectSupport's invokeWithinTransaction...
   return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

直接过，看invokeWithinTransaction

2.TransactionAspectSupport.invokeWithinTransaction()

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {

// If the transaction attribute is null, the method is non-transactional.
TransactionAttributeSource tas = getTransactionAttributeSource();
//通过TransactionAttributeSource获取@Transactional注解中的属性
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
//获取事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
//这个if一般不会走到
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
}
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {

// Standard transaction demarcation with getTransaction and commit/rollback calls.
//1.这是创建事务的核心逻辑，非常重要
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.
//2.调用真是的业务逻辑
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {

// target invocation exception
//3.核心逻辑之一，事务回滚
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {

cleanupTransactionInfo(txInfo);
}
if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {

// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {

retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
//4.核心逻辑之一，事务提交
commitTransactionAfterReturning(txInfo);
return retVal;
}
//...省略代码，暂时先不看
}

事务-主要处理的逻辑如下

创建事务、调用业务逻辑、事务回滚、事务提交我们一个个来看，spring事务中隔离级别和mysql的隔离级别是一致的，但是spring中的传播属性是spring实现的，这就是难点之一，我们今天重点看的是如何正确处理好传播属性。分析之前，先描述下spring支持哪7重传播属性

REQUIRED：如有事务，则使用当前事务，没有则创建

SUPPORTS：如果有事务，就用当前事务；没有则不适用事务

MANDATORY：使用当前事务，如果当前事务没有则抛异常

REQUIRES_NEW：新建事务，如果当前存在事务，则将当前事务挂起

NOT_SUPPORTED：非事务方式执行，如果当前存在事务，就将当前事务挂起

NEVER：非事务方式执行，如果当前存在事务，就抛异常

NESTED：嵌套事务

其实最常用的就是REQUIRED（默认）、REQUIRES_NEW、NESTED，今天源码分析也只分析上面三种，也是最复杂的三种

本文以我下面的测试的代码为例子，进行分析

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
public void testInsert() throws Exception {

String sql = "insert into user (name,age,sex) values(?,?,?)";
jdbcTemplate.update(sql,new Object[]{
"taott11",12,"man"});
//int a = 1/0;
//throw new Exception();
String sql2 = "insert into user (name,age,sex) values(?,?,?)";
jdbcTemplate.update(sql2,new Object[]{
"tao",18,"woman"});
//这里又调用了另外一个有事务标记的方法（动态代理方法）
productService.queryUesr();
}

@Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
public void queryUesr() throws Exception {

query();
throw new RuntimeException();
}

上述实例会调用两次动态代理的方法，一次是UserService.testInsert()，另外一次是ProductService.queryUesr()，请忽略类名和方法名，没任何含义，仅仅是测试使用而已

我们先从第一个代理方法开始进入分析，调用业务方法testInsert()之前先创建事务

3.createTransactionIfNecessary()

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

// If no name specified, apply method identification as transaction name.
if (txAttr != null && txAttr.getName() == null) {

txAttr = new DelegatingTransactionAttribute(txAttr) {

@Override
public String getName() {

//获取完成方法名
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
if (txAttr != null) {

if (tm != null) {

//1.核心逻辑
status = tm.getTransaction(txAttr);
}
else {

if (logger.isDebugEnabled()) {

logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
"] because no transaction manager has been configured");
}
}
}
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

没什么重要的逻辑，我们重点看tm.getTransaction()

4.AbstractPlatformTransactionManager.getTransaction()

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {

// Use defaults if no transaction definition given.
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
//1.创建一个事务对象
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
//2.判断是否已经存在事务，第一次调用testInsert没有，第二次就有了，非常重要的方法
if (isExistingTransaction(transaction)) {

// Existing transaction found -> check propagation behavior to find out how to behave.
return handleExistingTransaction(def, transaction, debugEnabled);
}
// Check definition settings for new transaction.
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {

throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// No existing transaction found -> check propagation behavior to find out how to proceed.
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {

throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {

SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {

logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
}
try {

//3.开启事务
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error ex) {

resume(null, suspendedResources);
throw ex;
}
}
else {

// Create "empty" transaction: no actual transaction, but potentially synchronization.
if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {

logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + def);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}

重要的逻辑方法，我已经做了标注了，下面我们一个个看

4-1.doGetTransaction()

创建事务对象

protected Object doGetTransaction() {

DataSourceTransactionObject txObject = new DataSourceTransactionObject();
txObject.setSavepointAllowed(isNestedTransactionAllowed());
//这个地方拿到数据库的连接，其实是从threadlocal中拿，第一次拿不到，因为没有设置进去，后面会详细将
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
//所以这个事务的连接其实是null
txObject.setConnectionHolder(conHolder, false);
return txObject;
}

第一次不会走到上面代码4中的注释2，因为不存在事务。所以我们直接看注释3，开启事务startTransaction

4-2.startTransaction()

private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {

boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
//创建了一个事务状态，请记住第三个参数为true，后面会用到
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//开怎么开启事务的
doBegin(transaction, definition);
prepareSynchronization(status, definition);
return status;
}

这里就是创建了一个DefaultTransactionStatus，这里第三个参数newTransaction=true希望大家先记住，这是spring事务的一个非常重要的细节，后面的提交和回滚都和参数有联系，只有该参数为true的条件下的事务才有资格提交和回滚，下面我们看doBegin

4-2-1.doBegin()

protected void doBegin(Object transaction, TransactionDefinition definition) {

DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {

//1.给当前事务设置连接
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {

Connection newCon = obtainDataSource().getConnection();
if (logger.isDebugEnabled()) {

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());
// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
//2.必须要关闭自动提交设置手动提交，否则你提交代码就提交了事务
if (con.getAutoCommit()) {

txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {

logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);
}
prepareTransactionalConnection(con, definition);
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {

txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// Bind the connection holder to the thread.
//3.绑定连接
if (txObject.isNewConnectionHolder()) {

TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
catch (Throwable ex) {

if (txObject.isNewConnectionHolder()) {

DataSourceUtils.releaseConnection(con, obtainDataSource());
txObject.setConnectionHolder(null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}

这里重点的方法都标注出来了，我们一个个看

注释1：给当前事务设置连接，我们之前已经分析了，我们第一次调用testInsert()时，从threadlocal中是没取到ConnectionHolder（其实就是connection的封装），这里就从连接中获取一个connection然后封装成ConnectionHolder设置到事务对象中

注释2：这里就是要跟原生jdbc一样，使用事务，也要先将自动提交设置成手动提交

注释3：这里就比较重要了，其实就是将当前ConnectinoHolder设置到threadlocal中，方便第二个事务调用时能获取到，我们具体看下bindResource()里面的逻辑，还是非常有意思的

4-2-1-1.TransactionSynchronizationManager.bindResource()

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() + "]");
}
}

这个方法就是往threadLocal中设置一个Map<Object,Object>,其中key是数据源，value是ConnectionHolder。这里为什么要用Map而不是直接存储ConnectionHolder呢？因为可能存在多数据源的情况，一个方法如果两个数据源不一样，而我们拿到的连接如果是一样的就有问题了。另外设置到threadlocal中，我们在同一个线程中就能获取到上一次存储的ConnectionHolder了。也就是当我们调用第二个事务方法productService.queryUer()方法时，就能获取到存储在ConnectionHolder了（单个数据源情况下）
//———————————————–强行分页—————————————————————//

到这里我们第一个方法userService.testInsert()的事务已经开启了，我们开始调用业务逻辑，而业务逻辑中又会调用ProductService.queryUser()，这又要进入上述的一样的逻辑了。相同的逻辑我就不继续讲了，我们直接将视野看到代码4中（AbstractPlatformTransactionManager.getTransaction），这里有几个地方需要注意

注释1：这里又创建了一个新的事务，但是事务的连接是从threadlocal中拿的，我们这里没有切换数据源，并且第一次调用UserService.testInsert开始事务时已经往threadlocal中设置了connectionHolder，所以我们这里创建的第二个事务是新的，但是连接和上一个连接是一样的

注释2：这里的if会判断为true，会调用一个非常重要的方法handleExistingTransaction()，下面会详细分析，代码不会走到注释3，因为if里面已经return了。开始看handleExistingTransaction

5.handleExistingTransaction()

private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {

//1.传播属性为PROPAGATION_NEVER
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {

throw new IllegalTransactionStateException(
"Existing transaction found for transaction marked with propagation 'never'");
}
//2.传播属性为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);
return prepareTransactionStatus(
definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
//3.传播属性为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 {

return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {

resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}
//4.传播属性为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() + "]");
}
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.
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.
return startTransaction(definition, transaction, debugEnabled, null);
}
}
//5.剩下的几种都走下面的逻辑
// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
if (debugEnabled) {

logger.debug("Participating in existing transaction");
}
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);
//6.要特别注意第三个参数了为newTransaction=false
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

代码虽然很长，但是比较容易，无非就是根据上面的几种不同的传播属性，做不同的逻辑。本文重点分析常用的几种传播属性REQUIRED、REQUIRES_NEW、NESTED，其他的几种也很简单，大家自行分析。

先看REQUIRED，比较见到，看最下面一行就行了

5-1.REQUIRED

//要特别注意第三个参数了为newTransaction=false
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);

创建了一个事务状态，但是它的newTransaction=false，也就是它没有资格真正的回滚和提交后面会详细讲

5-2.REQUIRES_NEW

直接看上面的注释3

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {

if (debugEnabled) {

logger.debug("Suspending current transaction, creating new transaction with name [" +
definition.getName() + "]");
}
//1.会把上一个事务给挂起
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {

//2.开始事务
return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {

resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}

注释1：将上一个事务挂起，下面会分析

注释2：开始新的事务，这个地方和之前开启事务的逻辑一样，重新设置连接、将连接设置到threadlocal中、将自动提交设置成手动提交

下面我们看下注释1是如何挂起事务的

5-2-1.suspend

protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {

if (TransactionSynchronizationManager.isSynchronizationActive()) {

List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
try {

Object suspendedResources = null;
if (transaction != null) {

//1.重点挂起的逻辑
suspendedResources = doSuspend(transaction);
}
String name = TransactionSynchronizationManager.getCurrentTransactionName();
TransactionSynchronizationManager.setCurrentTransactionName(null);
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
TransactionSynchronizationManager.setActualTransactionActive(false);
//2.返回一个对象，该对象封装了被挂起的事务信息，方便后面能重新拿得到
return new SuspendedResourcesHolder(
suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
}
//...省
}

接着看注释1的逻辑doSuspend

5-2-1-1.doSuspend

protected Object doSuspend(Object transaction) {

DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
//将当前事务对象connection设置成null
txObject.setConnectionHolder(null);
//解绑，其实就是从threadlocal中删除Map
return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}

因为创建第二个事务的时候，会将第一个事务的connectionHolder设置进来，这里挂起的操作，就是将第一次设置到threadlocal中的connectionHolder删除掉，并且将当前事务的connection设置成null。然后上面代码5-2.REQUIRES_NEW中的注释2中开启事务startTransaction方法，会将新的connectionHolder设置到threadlocal中，注意，此时startTransaction生成的事务状态的newTransaction=true

5-3.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() + "]");
}
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.
//1.创建事务状态
DefaultTransactionStatus status =
prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
//2.创建回滚点
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.
return startTransaction(definition, transaction, debugEnabled, null);
}
}

注释1：创建事务状态，注意此的newTransaction=false

注释2：创建一个回滚点，支持部分回滚，其实就是简单的封装了jdbc，不清楚回滚点的可以自行查阅相关内容

不知不觉已经已经写了很多了，但是这仅仅只是介绍了创建事务的原理，还有事务回滚、事务提交、注意事项都没讲，原本以为一篇文章能全部讲完，但是写太长了怕大家阅读起来比较类有恐惧感，所以我将事务回滚、事务提交、注意事项写在下一篇文章，请移步到（spring源码分析之事务transaction下篇）

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/111198.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...