Spring源码分析笔记--事务管理

核心类

InfrastructureAdvisorAutoProxyCreator

本质是一个后置处理器，和AOP的后置处理器类似，但比AOP的使用级别低。当开启AOP代理模式后，优先使用AOP的后置处理器。

AopConfigUtils：

/**
 * The bean name of the internally managed auto-proxy creator.
 */
//和AOP一样都向容器注入以此为name的后置处理器，进行代理类的创建
public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
      "org.springframework.aop.config.internalAutoProxyCreator";

/**
 * Stores the auto proxy creator classes in escalation order.
 */
//按升级的顺序存储进行代理类创建的后置处理器
private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<Class<?>>();

/**
 * Setup the escalation list.
 */
//代理创建类后置处理器升级列表，下标越大等级越高
static {
   APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
   APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
   APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
}

源码跟踪

查看注解@EnableTransactionManagement源码，通过@Import导入TransactionManagementConfigurationSelector类，在类的重写方法中可以看到向容器注入了两个类AutoProxyRegistrar、ProxyTransactionManagementConfiguration

AutoProxyRegistrar

用于向容器中注册事务管理用的后置处理器

==》org.springframework.context.annotation.AutoProxyRegistrar#registerBeanDefinitions

AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);

==》org.springframework.aop.config.AopConfigUtils#registerAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry)

==》org.springframework.aop.config.AopConfigUtils#registerAutoProxyCreatorIfNecessary(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)

==》org.springframework.aop.config.AopConfigUtils#registerOrEscalateApcAsRequired

//此类下检查容器中是否有name为："org.springframework.aop.config.internalAutoProxyCreator"的后置处理器bean，如果没有则注册，如果有则比较等级大小，若是等级大则对原beanDefination升级。例如：如果启用了AOP则不用升级

 

ProxyTransactionManagementConfiguration

配置事务管理所需的管理器、参数等

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
//类似AOP，这里创建了一个用于事务Advisor的Bean
   @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
      BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
      advisor.setTransactionAttributeSource(transactionAttributeSource());
      advisor.setAdvice(transactionInterceptor());
      advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
      return advisor;
   }
//封装事务管理配置的参数，@Transactional(..)中的参数
   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionAttributeSource transactionAttributeSource() {
      return new AnnotationTransactionAttributeSource();
   }
//封装事务用的advice为Interceptor，并关联上了事务管理器
// TransactionInterceptor与AOP的Interceptor一样都继承自MethodInterceptor
//事务管理器主要用来控制事务，commit、rollback等
   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionInterceptor transactionInterceptor() {
      TransactionInterceptor interceptor = new TransactionInterceptor();
      interceptor.setTransactionAttributeSource(transactionAttributeSource());
      if (this.txManager != null) {
         interceptor.setTransactionManager(this.txManager);
      }
      return interceptor;
   }

}

运行时源码

运行时原理同AOP，对添加了@Transactional注解的类做代理，对被代理类的方法进行增强处理,执行一个拦截器链。跟踪进去可以发现Interceptor chain中多了一个TransactionIntercepor。通过此Interceptor在方法前开启事务，在方法后commit或rollback。

TransactionInterceptor

==》org.springframework.transaction.interceptor.TransactionInterceptor#invoke

==》 org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

// If the transaction attribute is null, the method is non-transactional.
//获取事务相关属性、管理器
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
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;
}

流程梳理

1、 创建后置处理器InfrastructureAdvisorAutoProxyCreator

2、 创建TransactionInterceptor，加入interceptor chain。

3、 对指定后置处理器为InfrastructureAdvisorAutoProxyCreator的bean使用TransactionInterceptor进行事务处理。