从源码层面剖析@Transactional实现原理

1.组件注入

在SpringBoot中，通过@EnableTransactionManagement注解开启事务管理，而该注解上添加了@Import(TransactionManagementConfigurationSelector.class)注解，通过TransactionManagementConfigurationSelector向容器中注入了两个组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration

其中AutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，给容器中添加了InfrastructureAdvisorAutoProxyCreator后置处理器

而ProxyTransactionManagementConfiguration给容器中添加了BeanFactoryTransactionAttributeSourceAdvisor事务增强器，并未增强器设置了TransactionAttributeSource和事务拦截器TransactionInterceptor

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

    @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;
    }

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

    @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;
    }
}

2.代理对象的生成

前面在分析AOP原理时讲到，在创建代理对象前，需要先获取该对象的拦截器链，包括：1. 获取所有Advisor 2. 在所有Advisor中挑选适用的Advisor

BeanFactoryTransactionAttributeSourceAdvisor同样实现了 Advisor 接口。那么在获取所有增强器时自然会将此 bean 提取出来

在挑选适用的Advisor时，BeanFactoryTransactionAttributeSourceAdvisor间接实现了PointcutAdvisor，因此会进入 canApply 函数中的第二个 if 判断。会将BeanFactoryTransactionAttributeSourceAdvisor中的getPointcut()方法的返回值作为参数继续调用 canApply 方法。

接着回去判断这个类或者类的方法上是否添加了@Transactional注解，如果有的话，继续调用parseTransactionAnnotation方法解析详细的属性

至此，就讲BeanFactoryTransactionAttributeSourceAdvisor注入了目标对象的拦截器链中，BeanFactoryTransactionAttributeSourceAdvisor的adviceBeanName属性中。创建代理的时候，会调用Advisor.getAdvice方法，此时就会得到的该增强方法TransactionInterceptor，因为TransactionInterceptor实现了Advice，将其作为 CGLIB 的 CallBack 信息，@Transactional修饰方法所在的类作为 CGLIB 的父类信息，CGLIB 根据这些信息生成对应的子类的 Class 对象作为代理类。所以，在调用事务增强器增强的代理类时，会首先执行TransactionInterceptor进行增强，同时，也就是在TransactionInterceptor类中的invoke方法中完成了整个事务的逻辑。

3.方法拦截

当程序执行事务方法的时候，就会先走增强器TransactionInterceptor.invoke方法：

public Object invoke(final MethodInvocation invocation) throws Throwable {
      
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

        return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
            @Override
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }

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

        // 获取对应事务属性
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        // 获取 beanFactory 中的 transactionManager，需要配置
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        // 获取方法唯一标识（类.方法 如 xxx.UserServiceImpl.save）
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        // 声明式事务处理 @Transactional
        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // 创建 TransactionInfo,开启事务
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // 执行被增强方法
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // 异常回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            // 提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }
        //省略编程式事务和异常处理

可以看到在该拦截器的方法实现中，对目标方法进行了类似于环绕通知对事务处理，由此就为该方法添加了事务功能

参考文献：https://www.jianshu.com/p/9fa0b3c17810