Spring-事务的源码分析（七）

Spring-事务的源码分析（七）

都知道事务是通过spring AOP来实现的；前面文章已经分析过AOP的实现原理了，而事务只不过是AOP中的一个增强器而已；所以接下来将分析一下事务增强器的原理。

spring的核心就是IC依赖注入，那么就要先解析依赖配置，然后再注入。所以spring的功能都会出现两块，一块是解析mxl，一块是构建BeanDefinition。
事务增强器也是这样，先要解析事务的标签，然后才是执行事务。

解析tx事务标签

来看一下我们在xml中定义的事务标签是在那里被解析的？

public class TxNamespaceHandler extends NamespaceHandlerSupport {
   
    static final String TRANSACTION_MANAGER_ATTRIBUTE = "transaction-manager";
    static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";
    static String getTransactionManagerName(Element element) {
        return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
                element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
    }

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

从代码中可以看出，事务的开始一切都从：AnnotationDrivenBeanDefinitionParser 类的parse开始了。

开始解析xml标签了

/**
     * 解析annotation-driven开头的标签--> {@code <tx:annotation-driven/>} tag. Will
     * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
     * with the container as necessary.
     */
    @Override
    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;
    }

解析tx事务的标签的核心全部在InfrastructureAdvisorAutoProxyCreator这个里面，
InfrastructureAdvisorAutoProxyCreator -> AbstractAdvisorAutoProxyCreator -> AbstractAutoProxyCreator
所有的解析工作大部分都在AbstractAutoProxyCreator类里面解析完成的。前面已经分析了aop时已经分析完毕了，所以在这里就不继续分析了。

执行事务增强器

当判断某个bean适用于事务增强时，也就是用于增强器BeanFactoryTransactionAttributeSourceAdvisor这个类，所以在自定义标签解析时，注入的类成为了整个事务功能的基础。
BeanFactoryTransactionAttributeSourceAdvisor作为Advisor的实现类，需要遵从Advisor的处理方式，当代理被调用时会调用这个类的增强方法，也就是此bean的Advise，又因为在事务标签解析时我们把TransactionInterceptor类型的bean注入到了BeanFactoryTransactionAttributeSourceAdvisor中，所以在调用事务增强器增强的代理类时会先执行TransactionInterceptor进行增强，也就是执行TransactionInterceptor中的invoke方法完成整个事务的逻辑。

时序图：

从时序图中可以看出：
1. 解析注解事务中的属性；
2. 根据属性设置创建事务；
3. 在当前线程中执行用户真正的代码；
4. 如果执行过程中有异常则执行回滚逻辑；
5. 如果没有异常，则提交事务。
在前面讲解事务时说到过，spring事务是基于数据库本身的事务的，从时序图中也可以看出，创建事务，回滚事务，提交事务，操作都需要去操作数据库连接类DataSourceTransactionManager。

创建事务

看着时序图已经可以往下走了，下面将展示源码中个人觉得重要的点，其他不重要的由于篇幅问题就不帖出来了。
第一步：整个事务执行框架
TransactionInterceptor中的invoke执行了TransactionAspectSupport的invokeWithinTransaction方法。

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

        //获取事务属性，如果没有属性，则该方法没有事务 ** getTransactionAttribute重点**
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        final PlatformTransactionManager tm = determineTransactionManager(txAttr); //获取beanFactory中的事务管理器
        final String joinpointIdentification = methodIdentification(method, targetClass);
        //声明式事务处理
        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            //创建事务
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // This is an around advice: Invoke the next interceptor in the chain.
                // 执行被增强的方法
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // 异常回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally { //清除信息
                cleanupTransactionInfo(txInfo);
            } //提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        else {
            // 编程式事务处理It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            .......
            .......
         }
    }

可以看到整个事务在上面的方法中已经全部包含了，创建事务，执行代码，回滚，提交。spring把具体操作又拆分到各个业务类中了。

第二步：获取事务注解属性
就是解析方法上面的：@Transactional(propagation = Propagation.REQUIRES_NEW)这个里面的属性设置。
跟着上面的时序图直接来到parseTransactionAnnotation这个方法中看看。

//开始解析各种事务的标签
    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<RollbackRuleAttribute>();
        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;
    }

第三步：根据上面获取的属性，创建事务
TransactionAspectSupport.createTransactionIfNecessary

protected TransactionInfo createTransactionIfNecessary(
            PlatformTransactionManager tm, 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;
                }