1.引

上一节分析了<tx:annotation-driven/> 标签的解析过程，并简单介绍了InfrastructureAdvisorAutoProxyCreator，这一节接着分析Spring事物的实现过程，InfrastructureAdvisorAutoProxyCreator注册后的后续操作，InfrastructureAdvisorAutoProxyCreator实现了BeanPostProcessor接口，那么接下来我们就以BeanPostProcessor接口的postProcessBeforeInstantiation方法和postProcessAfterInitialization为入口，开始今天的分析。（不了解BeanPostProcessor或者bean生命周期的同学可以参考前面的章节，都有介绍）

接下来的分析可能在分析AOP的时候有过介绍，但是大家要注意分析其中的一些不同点。

postProcessBeforeInstantiation方法在之前已经有过详细的介绍，这里我们不再分析，重点看postProcessAfterInitialization。而且接下来很大一部分的方法之前都有分析过，我们只分析事物标签提取的过程。其他的过程不在详解。

2.postProcessAfterInitialization方法简析

/**
 * 如果bean被子类标识为要代理的bean，则使用配置的拦截器创建代理。
 * Create a proxy with the configured interceptors if the bean is
 * identified as one to proxy by the subclass.
 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 为beanName和beanClass构建缓存key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            // 包装bean（创建代理的入口方法）
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 1、如果已经处理过或者不需要创建代理，则返回
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 2、创建代理
    // 2.1 根据指定的bean获取所有的适合该bean的增强
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        // 2.2 为指定bean创建代理
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    // 3、缓存
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

这里又涉及到了增强的提取，套路还是一样，先找出所有的增强，再找出适合当前类的增强。

3.查找适合当前类的增强

protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    /**
     * 获取符合条件的增强并返回
     */
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    // 如果获取到的增强是个空的集合,则返回DO_NOT_PROXY-->空数组
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    // 将获取到的增强转换为数组并返回
    return advisors.toArray();
}

/**
 * 为当前bean获取所有需要自动代理的增强
 */
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 1、查找所有候选增强
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 2、从所有增强集合中查找适合当前bean的增强
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    // 3、在eligibleAdvisors集合首位加入ExposeInvocationInterceptor增强
    // ExposeInvocationInterceptor的作用是可以将当前的MethodInvocation暴露为一个thread-local对象,该拦截器很少使用
    // 使用场景:一个切点(例如AspectJ表达式切点)需要知道它的全部调用上线文环境
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        // 4.对增强进行排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

3.1 查找所有增强

public List<Advisor> findAdvisorBeans() {
    // Determine list of advisor bean names, if not cached already.
    // 获取缓存的增强
    String[] advisorNames = this.cachedAdvisorBeanNames;
    // 缓存增强为空，则重新查找增强并缓存
    if (advisorNames == null) {
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the auto-proxy creator apply to them!
        // 从当前BeanFactory中获取所有类型为Advisor的bean
        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                this.beanFactory,
                Advisor.class,
                true,
                false);
        this.cachedAdvisorBeanNames = advisorNames;
    }
    // 当前BeanFactory中没有类型为Advisor的bean则返回一个空的集合
    if (advisorNames.length == 0) {
        return new ArrayList<>();
    }

    // 循环所有获取到的bean
    List<Advisor> advisors = new ArrayList<>();
    for (String name : advisorNames) {
        if (isEligibleBean(name)) {
            // 跳过正在创建的增强
            if (this.beanFactory.isCurrentlyInCreation(name)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping currently created advisor '" + name + "'");
                }
            }
            else {
                try {
                    // 通过getBean方法获取bean实例
                    advisors.add(this.beanFactory.getBean(name, Advisor.class));
                }
                catch (BeanCreationException ex) {
                    Throwable rootCause = ex.getMostSpecificCause();
                    if (rootCause instanceof BeanCurrentlyInCreationException) {
                        BeanCreationException bce = (BeanCreationException) rootCause;
                        String bceBeanName = bce.getBeanName();
                        if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                            // 跳过正在创建的增强
                            if (logger.isDebugEnabled()) {
                                logger.debug("Skipping advisor '" + name +
                                        "' with dependency on currently created bean: " + ex.getMessage());
                            }
                            // Ignore: indicates a reference back to the bean we're trying to advise.
                            // We want to find advisors other than the currently created bean itself.
                            continue;
                        }
                    }
                    throw ex;
                }
            }
        }
    }
    return advisors;
}

注意这里与之前分析AOP的不同点
此处，我们没有在配置文件、类中描述任何增强增强信息（例如：在之前的AOP分析中，我们在DogAspect类上开启了@Aspect），那么此处应该获取到什么样的增强信息呢？

这时候就用到了上一节分析的内容了，在上一节手动向容器中注册了TransactionInterceptor，那么这里获取到的增强就是TransactionInterceptor，并通过getBean方法将其实例化。那么到这里，我们已经拿到了所有增强（如果没有配置其他的增强的话）

3.2 查找适合当前类的增强

这里其他的非关键代码就不粘贴了，前面都有过介绍，直接来看canApply方法（不了解其中过程的同学可以参考前面AOP的介绍），在canApply方法中有这样的代码片段：

// 5、循环代理目标的所有接口和实现类的所有方法并调用matches方法做匹配判断
for (Class<?> clazz : classes) {
    Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
    for (Method method : methods) {
        if (introductionAwareMethodMatcher != null ?
                // 如果上一步得到的introductionAwareMethodMatcher对象不为空，则使用该对象的matches匹配
                introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                // 否则使用Pointcut的methodMatcher对象做匹配
                methodMatcher.matches(method, targetClass)) {
            return true;
        }
    }
}

这里会调用methodMatcher.matches(method, targetClass)完成目标类方法的匹配工作，并在此方法里完成了事物标签（注解）的提取工作。

public boolean matches(Method method, Class<?> targetClass) {
    if (TransactionalProxy.class.isAssignableFrom(targetClass)) {
        return false;
    }
    // 获取事物属性源
    TransactionAttributeSource tas = getTransactionAttributeSource();
    // 如果获取事物属性源为空,或者没有提取到事物标签,那么返回false,表示改目标类不会被事物增强代理
    // 在getTransactionAttribute完成了事物标签的提取工作
    return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

4.事物标签（注解）提取

public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
    if (method.getDeclaringClass() == Object.class) {
        return null;
    }

    // 1.检查是否缓存过该方法上的事物标签
    // 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.
        // 判断缓存的事物标签,如果缓存的方法上没有具体的事物标签,返回null;否则返回对应的事物标签
        if (cached == NULL_TRANSACTION_ATTRIBUTE) {
            return null;
        } else {
            return (TransactionAttribute) cached;
        }
    }
    // 2.如果没有缓存的事物标签,则重新提取事物标签并缓存
    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;
    }
}

该方法比较简单，我们继续看computeTransactionAttribute提取事物标签的过程：

protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
    // Don't allow no-public methods as required.
    // 1.如果设置了只允许公共(public)方法允许定义事物语义,而该方法是非公共(public)的则返回null
    // allowPublicMethodsOnly --> 该方法默认返回false,即允许非公共方法定义事物语义
    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
        return null;
    }

    // The method may be on an interface, but we need attributes from the target class.
    // If the target class is null, the method will be unchanged.
    // 2.如果method是一个接口,那么根据该接口和目标类,找到目标类上的对应的方法(如果有)
    // 注意:该原始方法不一定是接口方法
    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);


    // 3.提取事物标签
    // First try is the method in the target class.
    // 3.1 首先尝试从目标类的方法上提取事物标签
    TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
    if (txAttr != null) {
        return txAttr;
    }

    // Second try is the transaction attribute on the target class.
    // 3.2 其次,尝试从目标类上提取事物标签
    txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
    if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
        return txAttr;
    }

    // 3.3 如果从目标类上提取的方法,不等于原始方法 todo lyc 这里还要再次分析下
    if (specificMethod != method) {
        // Fallback is to look at the original method.
        // 首先尝试从原始方法上提取事物标签
        txAttr = findTransactionAttribute(method);
        if (txAttr != null) {
            return txAttr;
        }
        // Last fallback is the class of the original method.
        // 最后尝试从原始方法的实现类方法上提取事物标签
        txAttr = findTransactionAttribute(method.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }
    }

    return null;
}

这里我们看到，方法上的事物注解是优先于类上的事物注解的。而且这部分的处理，分为了两个部分：从给定的类或方法上提取事物注解。

/**
 * 从给定的方法上提取事物标签
 * @param method the method to retrieve the attribute for
 * @return
 */
@Override
@Nullable
protected TransactionAttribute findTransactionAttribute(Method method) {
    return determineTransactionAttribute(method);
}

/**
 * 从给定的类上提取事物标签
 * @param clazz the class to retrieve the attribute for
 * @return
 */
@Override
@Nullable
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、JtaTransactionAnnotationParser、Ejb3TransactionAnnotationParser，我们只关心SpringTransactionAnnotationParser的转换就行了。接下来以SpringTransactionAnnotationParser为例看具体的事物标签提取和转换：

public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
    // 1.提取事物注解标签（该方法较长就不粘贴了，感兴趣的自己看一下，比较简单）
    AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
            ae,
            Transactional.class,
            false,
            false);
    // 2.解析事物标签
    if (attributes != null) {
        return parseTransactionAnnotation(attributes);
    }
    else {
        return null;
    }
}

/**
 * 解析事物标签属性
 */
protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
    RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
    // 1.解析propagation属性
    Propagation propagation = attributes.getEnum("propagation");
    rbta.setPropagationBehavior(propagation.value());
    // 2.解析isolation属性
    Isolation isolation = attributes.getEnum("isolation");
    rbta.setIsolationLevel(isolation.value());
    // 3.解析timeout属性
    rbta.setTimeout(attributes.getNumber("timeout").intValue());
    // 4.解析readOnly属性
    rbta.setReadOnly(attributes.getBoolean("readOnly"));
    // 5.解析value属性
    rbta.setQualifier(attributes.getString("value"));
    ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<>();
    // 6.解析rollbackFor属性
    Class<?>[] rbf = attributes.getClassArray("rollbackFor");
    for (Class<?> rbRule : rbf) {
        RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 7.解析rollbackForClassName属性
    String[] rbfc = attributes.getStringArray("rollbackForClassName");
    for (String rbRule : rbfc) {
        RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 8.解析noRollbackFor属性
    Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
    for (Class<?> rbRule : nrbf) {
        NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 9.解析noRollbackForClassName属性
    String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
    for (String rbRule : nrbfc) {
        NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    rbta.getRollbackRules().addAll(rollBackRules);
    return rbta;
}

到这里，我们就完成了目标类或者目标类方法上的事物标签提取了。

代理的创建等工作之前已经分析过，大家可以参考AOP的分析自己跟踪代码，接下来的章节，我们分析Spring事物代理方法的调用，解析Spring是如何实现事物的。