Spring 事务源码解析

谁践踏了优雅 2022-05-12 05:42 322阅读 0赞

# 准备 #

*  `Spring版本：5.0.8`

# 解析过程 #

### 标签解析分析 ###

事务注解驱动标签 `<tx:annotation-driven/>` 解析，首先定位到 `TxNamespaceHandler`

// TxNamespaceHandler
    public void init() {
       registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
       registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
       registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
    }

// AnnotationDrivenBeanDefinitionParser
    public BeanDefinition parse(Element element, ParserContext parserContext) {
       registerTransactionalEventListenerFactory(parserContext);
       String mode = element.getAttribute("mode");
       if ("aspectj".equals(mode)) {
          // mode="aspectj"
          registerTransactionAspect(element, parserContext);
       }
       else {
          // mode="proxy"
          AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
       }
       return null;
    }

// AnnotationDrivenBeanDefinitionParser
    private static class AopAutoProxyConfigurer { 
    
       public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
          // 注册了InfrastructureAdvisorAutoProxyCreator类 该类实现了BeanPostProcessor接口
          AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
    
          String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
          if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
             Object eleSource = parserContext.extractSource(element);
    
             // 创建TransactionAttributeSource BeanDefinition
             RootBeanDefinition sourceDef = new RootBeanDefinition(
                   "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
             sourceDef.setSource(eleSource);
             sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
             String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
    
             // 创建TransactionInterceptor BeanDefinition
             RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
             interceptorDef.setSource(eleSource);
             interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
             /** * 注册事务管理器 * * 默认会寻找<tx:annotation-driven/>配置的transaction-manager属性作为事务管理器 * 否则会寻找beanName为transactionManager的Bean作为事务管理器 */
             registerTransactionManager(element, interceptorDef);
             // 为TransactionInterceptor添加TransactionAttributeSource引用
             interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
             String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
    
             // 创建TransactionAttributeSourceAdvisor BeanDefinition
             RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
             advisorDef.setSource(eleSource);
             advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
             // 为TransactionAttributeSourceAdvisor添加TransactionAttributeSource、TransactionInterceptor引用
             advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
             advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
             if (element.hasAttribute("order")) {
                advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
             }
             parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
    
             CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
             compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
             compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
             compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
             parserContext.registerComponent(compositeDef);
          }
       }
    }

注册 `InfrastructureAdvisorAutoProxyCreator` 类，查看该类继承图，发现该类实现了`BeanPostProcessor` 接口，在bean实例化时会调用其 `postProcessAfterInitialization` 方法，而其实现在父类 `AbstractAutoProxyCreator` 中

![InfrastructureAdvisorAutoProxyCreator继承图][InfrastructureAdvisorAutoProxyCreator]

// AbstractAutoProxyCreator
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
       if (bean != null) {
          Object cacheKey = getCacheKey(bean.getClass(), beanName);
          if (!this.earlyProxyReferences.contains(cacheKey)) {
             return wrapIfNecessary(bean, beanName, cacheKey);
          }
       }
       return bean;
    }

// AbstractAutoProxyCreator
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
       if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
          return bean;
       }
    
       if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
          return bean;
       }
       // 如果是aop基础类或配置不需要代理 直接返回
       if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
          this.advisedBeans.put(cacheKey, Boolean.FALSE);
          return bean;
       }
    
       // 获取bean匹配的增强器
       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
       if (specificInterceptors != DO_NOT_PROXY) {
          this.advisedBeans.put(cacheKey, Boolean.TRUE);
          // 创建代理
          Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
          this.proxyTypes.put(cacheKey, proxy.getClass());
          return proxy;
       }
    
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
       return bean;
    }

`getAdvicesAndAdvisorsForBean` 方法具体就是为了获取配置为增强器的bean，而在`AopAutoProxyConfigurer.configureAutoProxyCreator`方法注册的`BeanFactoryTransactionAttributeSourceAdvisor` 类实现了 `Advisor`，会被查找出来，另外被注入的两个也会被查找出来

![BeanFactoryTransactionAttributeSourceAdvisor继承图][BeanFactoryTransactionAttributeSourceAdvisor]

// AbstractAdvisorAutoProxyCreator
    protected Object[] getAdvicesAndAdvisorsForBean(
          Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
       // 查找合适的增强器
       List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
       if (advisors.isEmpty()) {
          return DO_NOT_PROXY;
       }
       return advisors.toArray();
    }

// AbstractAdvisorAutoProxyCreator
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
       // 寻找合适的增强器
       List<Advisor> candidateAdvisors = findCandidateAdvisors();
       // 确定增强器能否应用在bean上
       List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
       extendAdvisors(eligibleAdvisors);
       if (!eligibleAdvisors.isEmpty()) {
          eligibleAdvisors = sortAdvisors(eligibleAdvisors);
       }
       return eligibleAdvisors;
    }

// AbstractAdvisorAutoProxyCreator
    protected List<Advisor> findAdvisorsThatCanApply(
          List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
    
       ProxyCreationContext.setCurrentProxiedBeanName(beanName);
       try {
          // 获取当前bean可用的增强器
          return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
       }
       finally {
          ProxyCreationContext.setCurrentProxiedBeanName(null);
       }
    }

// AopUtils
    public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
       if (candidateAdvisors.isEmpty()) {
          return candidateAdvisors;
       }
       List<Advisor> eligibleAdvisors = new LinkedList<>();
       // 首先处理引介增强是否可以应用在当前bean上
       for (Advisor candidate : candidateAdvisors) {
          if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
             eligibleAdvisors.add(candidate);
          }
       }
       boolean hasIntroductions = !eligibleAdvisors.isEmpty();
       for (Advisor candidate : candidateAdvisors) {
          if (candidate instanceof IntroductionAdvisor) {
             // 引介增强已处理
             continue;
          }
          // 判断当前增强是否可以应用在当前bean上
          if (canApply(candidate, clazz, hasIntroductions)) {
             eligibleAdvisors.add(candidate);
          }
       }
       return eligibleAdvisors;
    }

// AopUtils
    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
       // 判断引介增强是否匹配
       if (advisor instanceof IntroductionAdvisor) {
          return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
       }
       else if (advisor instanceof PointcutAdvisor) {
          PointcutAdvisor pca = (PointcutAdvisor) advisor;
          // 判断是否可以应用在当前bean上
          return canApply(pca.getPointcut(), targetClass, hasIntroductions);
       }
       else {
          // It doesn't have a pointcut so we assume it applies.
          return true;
       }
    }

// BeanFactoryTransactionAttributeSourceAdvisor
    public Pointcut getPointcut() {
       return this.pointcut;
    }

// AopUtils
    public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
       Assert.notNull(pc, "Pointcut must not be null");
       if (!pc.getClassFilter().matches(targetClass)) {
          return false;
       }
    
       /** * 获取方法匹配器 * * TransactionAttributeSourcePointcut的getMethodMatcher()方法 * 实现在其父类StaticMethodMatcherPointcut */
       MethodMatcher methodMatcher = pc.getMethodMatcher();
       if (methodMatcher == MethodMatcher.TRUE) {
          // No need to iterate the methods if we're matching any method anyway...
          return true;
       }
    
       IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
       if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
          introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
       }
    
       Set<Class<?>> classes = new LinkedHashSet<>();
       if (!Proxy.isProxyClass(targetClass)) {
          classes.add(ClassUtils.getUserClass(targetClass));
       }
       classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    
       for (Class<?> clazz : classes) {
          Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
          for (Method method : methods) {
             if (introductionAwareMethodMatcher != null ?
                   introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                   methodMatcher.matches(method, targetClass)) {
                return true;
             }
          }
       }
    
       return false;
    }

调用的 `matches` 方法在 `TransactionAttributeSourcePointcut` 中实现

// TransactionAttributeSourcePointcut
    public boolean matches(Method method, @Nullable Class<?> targetClass) {
       if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
          return false;
       }
       TransactionAttributeSource tas = getTransactionAttributeSource();
       // 判断是否有事务属性
       return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    }

// AbstractFallbackTransactionAttributeSource
    public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
       if (method.getDeclaringClass() == Object.class) {
          return null;
       }
    
       // First, see if we have a cached value.
       Object cacheKey = getCacheKey(method, targetClass);
       Object cached = this.attributeCache.get(cacheKey);
       if (cached != null) {
          // Value will either be canonical value indicating there is no transaction attribute,
          // or an actual transaction attribute.
          if (cached == NULL_TRANSACTION_ATTRIBUTE) {
             return null;
          } else {
             return (TransactionAttribute) cached;
          }
       } else {
          // We need to work it out.
          // 获取事务属性
          TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
          // Put it in the cache.
          if (txAttr == null) {
             this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
          } else {
             String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
             if (txAttr instanceof DefaultTransactionAttribute) {
                ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
             }
             if (logger.isDebugEnabled()) {
                logger.debug("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
             }
             this.attributeCache.put(cacheKey, txAttr);
          }
          return txAttr;
       }
    }

// AbstractFallbackTransactionAttributeSource
    protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
       // Don't allow no-public methods as required.
       if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
          return null;
       }
    
       // 根据指定的接口方法和目标类获取目标方法
       Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    
       // 查询目标类的具体方法是否有事务属性
       TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
       if (txAttr != null) {
          return txAttr;
       }
    
       // 查询目标类上是否有事务属性
       txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
       if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
          return txAttr;
       }
    
       if (specificMethod != method) {
          // 查看原始方法上是否有事务属性
          txAttr = findTransactionAttribute(method);
          if (txAttr != null) {
             return txAttr;
          }
          // 查看原始方法所属的类上是否有事务属性
          txAttr = findTransactionAttribute(method.getDeclaringClass());
          if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
             return txAttr;
          }
       }
    
       return null;
    }

// AnnotationTransactionAttributeSource
    protected TransactionAttribute findTransactionAttribute(Method method) {
       return determineTransactionAttribute(method);
    }
    
    protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
       return determineTransactionAttribute(clazz);
    }
    
    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {
       for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
          // 解析事务注解
          TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);
          if (attr != null) {
             return attr;
          }
       }
       return null;
    }

// SpringTransactionAnnotationParser
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
       AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
             ae, Transactional.class, false, false);
       if (attributes != null) {
          return parseTransactionAnnotation(attributes);
       }
       else {
          return null;
       }
    }

解析 `@Transactional` 注解属性

// SpringTransactionAnnotationParser
    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
       RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
       Propagation propagation = attributes.getEnum("propagation");
       rbta.setPropagationBehavior(propagation.value());
       Isolation isolation = attributes.getEnum("isolation");
       rbta.setIsolationLevel(isolation.value());
       rbta.setTimeout(attributes.getNumber("timeout").intValue());
       rbta.setReadOnly(attributes.getBoolean("readOnly"));
       rbta.setQualifier(attributes.getString("value"));
       ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<>();
       Class<?>[] rbf = attributes.getClassArray("rollbackFor");
       for (Class<?> rbRule : rbf) {
          RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
          rollBackRules.add(rule);
       }
       String[] rbfc = attributes.getStringArray("rollbackForClassName");
       for (String rbRule : rbfc) {
          RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
          rollBackRules.add(rule);
       }
       Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
       for (Class<?> rbRule : nrbf) {
          NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
          rollBackRules.add(rule);
       }
       String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
       for (String rbRule : nrbfc) {
          NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
          rollBackRules.add(rule);
       }
       rbta.getRollbackRules().addAll(rollBackRules);
       return rbta;
    }

### 执行过程解析 ###

`TransactionInterceptor` 实现了 `MethodInterceptor`，在执行通知方法时会调用 `TransactionInterceptor` 的 `invoke` 方法

// TransactionInterceptor
    public Object invoke(final MethodInvocation invocation) throws Throwable {
       Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    
       // 在事务中调用方法
       return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    }

// TransactionAspectSupport
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
          final InvocationCallback invocation) throws Throwable {
    
       TransactionAttributeSource tas = getTransactionAttributeSource();
       // 获取事务属性
       final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
       // 获取平台事务管理器
       final PlatformTransactionManager tm = determineTransactionManager(txAttr);
       final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
    
       if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
          // Standard transaction demarcation with getTransaction and commit/rollback calls.
          // 创建事务
          TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
          Object retVal = null;
          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;
       }
    
       else {
          final ThrowableHolder throwableHolder = new ThrowableHolder();
    
          // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
          try {
             Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
                TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                try {
                   return invocation.proceedWithInvocation();
                }
                catch (Throwable ex) {
                   if (txAttr.rollbackOn(ex)) {
                      // A RuntimeException: will lead to a rollback.
                      if (ex instanceof RuntimeException) {
                         throw (RuntimeException) ex;
                      }
                      else {
                         throw new ThrowableHolderException(ex);
                      }
                   }
                   else {
                      // A normal return value: will lead to a commit.
                      throwableHolder.throwable = ex;
                      return null;
                   }
                }
                finally {
                   cleanupTransactionInfo(txInfo);
                }
             });
    
             // Check result state: It might indicate a Throwable to rethrow.
             if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
             }
             return result;
          }
          catch (ThrowableHolderException ex) {
             throw ex.getCause();
          }
          catch (TransactionSystemException ex2) {
             if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                ex2.initApplicationException(throwableHolder.throwable);
             }
             throw ex2;
          }
          catch (Throwable ex2) {
             if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
             }
             throw ex2;
          }
       }
    }

// TransactionAspectSupport
    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) {
             // 获取事务状态
             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);
    }

// AbstractPlatformTransactionManager
    public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
       // 获取事务
       Object transaction = doGetTransaction();
    
       // Cache debug flag to avoid repeated checks.
       boolean debugEnabled = logger.isDebugEnabled();
    
       if (definition == null) {
          // Use defaults if no transaction definition given.
          definition = new DefaultTransactionDefinition();
       }
    
       // 判断是否存在事务
       if (isExistingTransaction(transaction)) {
          // Existing transaction found -> check propagation behavior to find out how to behave.
          //处理已经存在的事务
          return handleExistingTransaction(definition, transaction, debugEnabled);
       }
    
       // Check definition settings for new transaction.
       if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
          throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
       }
    
       // No existing transaction found -> check propagation behavior to find out how to proceed.
       // 当前没有事务 且 事务传播设置为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);
          if (debugEnabled) {
             logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
          }
          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 ex) {
             resume(null, suspendedResources);
             throw ex;
          }
       }
       else {
          // Create "empty" transaction: no actual transaction, but potentially synchronization.
          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);
       }
    }

// DataSourceTransactionManager
    protected Object doGetTransaction() {
       DataSourceTransactionObject txObject = new DataSourceTransactionObject();
       txObject.setSavepointAllowed(isNestedTransactionAllowed());
       ConnectionHolder conHolder =
             (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
       txObject.setConnectionHolder(conHolder, false);
       return txObject;
    }

// AbstractPlatformTransactionManager
    private TransactionStatus handleExistingTransaction(
          TransactionDefinition definition, Object transaction, boolean debugEnabled)
          throws TransactionException {
    
       if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
          throw new IllegalTransactionStateException(
                "Existing transaction found for transaction marked with propagation 'never'");
       }
    
       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);
       }
    
       // 事务传播类型为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 {
             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) {
             resumeAfterBeginException(transaction, suspendedResources, beginEx);
             throw beginEx;
          }
       }
    
       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.
             boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
             DefaultTransactionStatus status = newTransactionStatus(
                   definition, transaction, true, newSynchronization, debugEnabled, null);
             doBegin(transaction, definition);
             prepareSynchronization(status, definition);
             return status;
          }
       }
    
       // 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);
       return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
    }

// AbstractPlatformTransactionManager
    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);
             }
             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);
             return new SuspendedResourcesHolder(
                   suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
          }
          catch (RuntimeException | Error ex) {
             // doSuspend failed - original transaction is still active...
             doResumeSynchronization(suspendedSynchronizations);
             throw ex;
          }
       }
       else if (transaction != null) {
          // Transaction active but no synchronization active.
          Object suspendedResources = doSuspend(transaction);
          return new SuspendedResourcesHolder(suspendedResources);
       }
       else {
          // Neither transaction nor synchronization active.
          return null;
       }
    }

// DataSourceTransactionManager
    protected Object doSuspend(Object transaction) {
       DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
       // 重置connectionHolder为null
       txObject.setConnectionHolder(null);
       return TransactionSynchronizationManager.unbindResource(obtainDataSource());
    }

// DataSourceTransactionManager
    protected void doBegin(Object transaction, TransactionDefinition definition) {
       DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
       Connection con = null;
    
       try {
          // suspend操作中已经重置connectionHolder
          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);
    
          // 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).
          if (con.getAutoCommit()) {
             txObject.setMustRestoreAutoCommit(true);
             if (logger.isDebugEnabled()) {
                logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
             }
             // 设置事务自动提交为false 交由spring管理
             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.
          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);
       }
    }

// TransactionAspectSupport
    protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
          @Nullable TransactionAttribute txAttr, String joinpointIdentification,
          @Nullable TransactionStatus status) {
    
       TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
       if (txAttr != null) {
          // We need a transaction for this method...
          if (logger.isTraceEnabled()) {
             logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
          }
          // The transaction manager will flag an error if an incompatible tx already exists.
          txInfo.newTransactionStatus(status);
       }
       else {
          // The TransactionInfo.hasTransaction() method will return false. We created it only
          // to preserve the integrity of the ThreadLocal stack maintained in this class.
          if (logger.isTraceEnabled())
             logger.trace("Don't need to create transaction for [" + joinpointIdentification +
                   "]: This method isn't transactional.");
       }
    
       // We always bind the TransactionInfo to the thread, even if we didn't create
       // a new transaction here. This guarantees that the TransactionInfo stack
       // will be managed correctly even if no transaction was created by this aspect.
       txInfo.bindToThread();
       return txInfo;
    }

### 事务提交 ###

查看 `TransactionAspectSupport` 的 `commitTransactionAfterReturning` 方法

// TransactionAspectSupport
    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());
       }
    }

// AbstractPlatformTransactionManager
    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);
    }

// AbstractPlatformTransactionManager
    private void processCommit(DefaultTransactionStatus status) throws TransactionException {
       try {
          boolean beforeCompletionInvoked = false;
    
          try {
             boolean unexpectedRollback = false;
             prepareForCommit(status);
             triggerBeforeCommit(status);
             triggerBeforeCompletion(status);
             beforeCompletionInvoked = true;
    
             if (status.hasSavepoint()) {
                if (status.isDebug()) {
                   logger.debug("Releasing transaction savepoint");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                status.releaseHeldSavepoint();
             }
             else if (status.isNewTransaction()) {
                if (status.isDebug()) {
                   logger.debug("Initiating transaction commit");
                }
                unexpectedRollback = status.isGlobalRollbackOnly();
                // 执行提交操作
                doCommit(status);
             }
             else if (isFailEarlyOnGlobalRollbackOnly()) {
                unexpectedRollback = status.isGlobalRollbackOnly();
             }
    
             // Throw UnexpectedRollbackException if we have a global rollback-only
             // marker but still didn't get a corresponding exception from commit.
             if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                      "Transaction silently rolled back because it has been marked as rollback-only");
             }
          }
          catch (UnexpectedRollbackException ex) {
             // can only be caused by doCommit
             triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
             throw ex;
          }
          catch (TransactionException ex) {
             // can only be caused by doCommit
             if (isRollbackOnCommitFailure()) {
                doRollbackOnCommitException(status, ex);
             }
             else {
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
             }
             throw ex;
          }
          catch (RuntimeException | Error ex) {
             if (!beforeCompletionInvoked) {
                triggerBeforeCompletion(status);
             }
             doRollbackOnCommitException(status, ex);
             throw ex;
          }
    
          // Trigger afterCommit callbacks, with an exception thrown there
          // propagated to callers but the transaction still considered as committed.
          try {
             triggerAfterCommit(status);
          }
          finally {
             triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
          }
    
       }
       finally {
          cleanupAfterCompletion(status);
       }
    }

// DataSourceTransactionManager
    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();
       }
       catch (SQLException ex) {
          throw new TransactionSystemException("Could not commit JDBC transaction", ex);
       }
    }

### 事务回滚 ###

查看 `TransactionAspectSupport` 的 `completeTransactionAfterThrowing` 方法

// TransactionAspectSupport
    protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
       // 判断是否存在事务
       if (txInfo != null && txInfo.getTransactionStatus() != null) {
          if (logger.isTraceEnabled()) {
             logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
                   "] after exception: " + ex);
          }
          // 是否满足回滚条件
          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;
             }
          }
          else {
             // We don't roll back on this exception.
             // Will still roll back if TransactionStatus.isRollbackOnly() is true.
             try {
                // 存在异常也提交事务 因为不满足回滚条件
                txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
             }
             catch (TransactionSystemException ex2) {
                logger.error("Application exception overridden by commit exception", ex);
                ex2.initApplicationException(ex);
                throw ex2;
             }
             catch (RuntimeException | Error ex2) {
                logger.error("Application exception overridden by commit exception", ex);
                throw ex2;
             }
          }
       }
    }

// AbstractPlatformTransactionManager
    public final void rollback(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;
       // 执行回滚操作
       processRollback(defStatus, false);
    }

// AbstractPlatformTransactionManager
    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
       try {
          boolean unexpectedRollback = unexpected;
    
          try {
             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");
                      }
                      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);
    
          // 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 {
          // 完成之后清理并恢复挂起事务
          cleanupAfterCompletion(status);
       }
    }

// DataSourceTransactionManager
    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();
       }
       catch (SQLException ex) {
          throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
       }
    }

// AbstractPlatformTransactionManager
    private void cleanupAfterCompletion(DefaultTransactionStatus status) {
       // 设置事务状态为完成
       status.setCompleted();
       if (status.isNewSynchronization()) {
          TransactionSynchronizationManager.clear();
       }
       if (status.isNewTransaction()) {
          // 事务完成后清理操作
          doCleanupAfterCompletion(status.getTransaction());
       }
       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());
       }
    }

// DataSourceTransactionManager
    protected void doCleanupAfterCompletion(Object transaction) {
       DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    
       // Remove the connection holder from the thread, if exposed.
       // 解除数据库连接与线程绑定
       if (txObject.isNewConnectionHolder()) {
          TransactionSynchronizationManager.unbindResource(obtainDataSource());
       }
    
       // Reset connection.
       Connection con = txObject.getConnectionHolder().getConnection();
       try {
          if (txObject.isMustRestoreAutoCommit()) {
             // 设置事务自动提交属性为true
             con.setAutoCommit(true);
          }
          // 重置数据库连接属性
          DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
       }
       catch (Throwable ex) {
          logger.debug("Could not reset JDBC Connection after transaction", ex);
       }
    
       if (txObject.isNewConnectionHolder()) {
          if (logger.isDebugEnabled()) {
             logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
          }
          DataSourceUtils.releaseConnection(con, this.dataSource);
       }
    
       txObject.getConnectionHolder().clear();
    }

至此，所有过程分析完成。

# 参考资料 #

Spring源码深度解析  
[https://blog.csdn.net/dalinsi/article/details/53203540][https_blog.csdn.net_dalinsi_article_details_53203540]

[InfrastructureAdvisorAutoProxyCreator]: /images/20220512/4794ea43b91640b296c32e67f99df3d9.png
[BeanFactoryTransactionAttributeSourceAdvisor]: /images/20220512/69465de12a744e7f82ea90b0ceecd56b.png
[https_blog.csdn.net_dalinsi_article_details_53203540]: https://blog.csdn.net/dalinsi/article/details/53203540