这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战

前言

本文主要回答一个问题，spring 如何处理事务的隔离级别

事务传播级别

事务是逻辑处理原子性的保证手段，通过使用事务控制，可以极大的避免出现逻辑处理失败导致的脏数据等问题。

传播级别定义的是事务的控制范围

org.springframework.transaction.annotation.Propagation

其中嵌套事务单独写篇博客叙述

源码分析

在 spring 事务源码（二）一文中已经提到了一个关键的方法

org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction

是根据当前方法注解@Transactional去创建不同的事务

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
  // 获取事务管理信息
   Object transaction = doGetTransaction();

   if (definition == null) {
      // Use defaults if no transaction definition given.
      definition = new DefaultTransactionDefinition();
   }

   if (isExistingTransaction(transaction)) {
      // 如果当前线程上下文已经存在事务，则根据事务注解的隔离级别处理
      return handleExistingTransaction(definition, transaction, debugEnabled);
   }

   // 如果当前线程上下文中没有事务，也是根据事务注解的隔离级别处理
  
  // 如果当前事务隔离级别是 PROPAGATION_MANDATORY
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
      throw new IllegalTransactionStateException(
            "No existing transaction found for transaction marked with propagation 'mandatory'");
   }
   else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
         definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
         definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
      SuspendedResourcesHolder suspendedResources = suspend(null);
     
      try {
         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        // 创建事务 TransactionStatus
         DefaultTransactionStatus status = newTransactionStatus(
               definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        // 开启事务，提交sql
         doBegin(transaction, definition);
        // TransactionSynchronizationManager 相关属性处理
        // 当前线程上下文事务属性初始化
         prepareSynchronization(status, definition);
         return status;
      }
      .....
   }
   else {
     //SUPPORTS、NOT_SUPPORTED
     
      // 创建空事务，没有实际的事务处理但是也是创建 TransactionStatus
      if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
         logger.warn("Custom isolation level specified but no actual transaction initiated; " +
               "isolation level will effectively be ignored: " + definition);
      }
      boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
      return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
   }
}

其中在 handleExistingTransaction 方法中有对当前已经存在事务的不同传播级别不同的处理方式

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

  // PROPAGATION_NEVER
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
      throw new IllegalTransactionStateException(
            "Existing transaction found for transaction marked with propagation 'never'");
   }

  //PROPAGATION_NOT_SUPPORTED
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
      
      Object suspendedResources = suspend(transaction);
      boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
      return prepareTransactionStatus(
            definition, null, false, newSynchronization, debugEnabled, suspendedResources);
   }

  //PROPAGATION_REQUIRES_NEW
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
     
      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) {
         ...
      }
   }
	
  // PROPAGATION_NESTED
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
     
      if (useSavepointForNestedTransaction()) {
         // 创建一个保存点
         DefaultTransactionStatus status =
               prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
         status.createAndHoldSavepoint();
         return status;
      }
      else {
         // 
         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
         DefaultTransactionStatus status = newTransactionStatus(
               definition, transaction, true, newSynchronization, debugEnabled, null);
         doBegin(transaction, definition);
         prepareSynchronization(status, definition);
         return status;
      }
   }

   .....
   boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
   return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

当然上面这些源码看起来还是很懵逼的，需要在结合事务注解切面代码

最后

后面的博客我会着重挑几个常用的传播级别进行详细分析