Spring事务（二）：事务的执行流程

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    ...
    if (...) {
        //1\. shouldSkip:
        // - AspectJAwareAdvisorAutoProxyCreator  shouldSkip ᴦ @Aspect ע࣬
        //   е@Before/@After/@AroundעװΪAdvisorٵø(Ҳ
        //   AbstractAutoProxyCreator)shouldSkip
        // - InfrastructureAdvisorAutoProxyCreatorֱִAbstractAutoProxyCreatorshouldSkip
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
    if(...)  {
        ...

        // 2\. getAdvicesAndAdvisorsForBeanȡڵǰadvisor
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(
            beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        ...
        return proxy;
    }
    return null;
}

public List<Advisor> findAdvisorBeans() {
    String[] advisorNames = this.cachedAdvisorBeanNames;
    if (advisorNames == null) {
        // ҵǰbeanFactory Advisor  bean class
        // AdvisorûʵAdvisorؽӿڣҲxmlָ
        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                this.beanFactory, Advisor.class, true, false);
        this.cachedAdvisorBeanNames = advisorNames;
    }
    ...
    List<Advisor> advisors = new ArrayList<>();
    for (String name : advisorNames) {
        ...
        // advisorbean namespringлȡ bean
        advisors.add(this.beanFactory.getBean(name, Advisor.class));
        ...
    }
    ...
    return advisors;
}

/**
 * жadvisorܷĿclass
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
    ...
    // жǷΪ PointcutAdvisoradvisorΪBeanFactoryTransactionAttributeSourceAdvisor
    // ʵPointcutAdvisorĴִ
    else if (advisor instanceof PointcutAdvisor) {
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        //ʹ PointcutAdvisor ж
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    ...
}

/**
 * жadvisorܷĿclass
 */
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    //1\. еǷų
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }
    // ȡƥMethodMatcher.TRUE ΪĬϵ MethodMatcher 
    MethodMatcher methodMatcher = pc.getMethodMatcher();
    if (methodMatcher == MethodMatcher.TRUE) {
        return true;
    }
    ...
    // classestargetClassObjectиࡢнӿ
    Set<Class<?>> classes = new LinkedHashSet<>();
    // ʡԻȡtargetClassĸಽ
    ...
    for (Class<?> clazz : classes) {
        // ȡ clazz ķǰķObjectи෽ӿڵĬϷ
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        for (Method method : methods) {
            // 2\. ƥĹؼ
            if (introductionAwareMethodMatcher != null ?
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }
    return false;
}

public class BeanFactoryTransactionAttributeSourceAdvisor 
        extends AbstractBeanFactoryPointcutAdvisor {

    @Nullable
    private TransactionAttributeSource transactionAttributeSource;

    /**
     *  pointcut
     */
    private final TransactionAttributeSourcePointcut pointcut = 
            new TransactionAttributeSourcePointcut() {
        @Override
        @Nullable
        protected TransactionAttributeSource getTransactionAttributeSource() {
            return transactionAttributeSource;
        }
    };

    /**
     *  transactionAttributeSource
     */
    public void setTransactionAttributeSource(TransactionAttributeSource 
            transactionAttributeSource) {
        this.transactionAttributeSource = transactionAttributeSource;
    }

    /**
     *  ClassFilter
     */
    public void setClassFilter(ClassFilter classFilter) {
        this.pointcut.setClassFilter(classFilter);
    }

    /**
     * ȡ pointcut
     */
    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }
}

public class ProxyTransactionManagementConfiguration 
        extends AbstractTransactionManagementConfiguration {

    // ʡ
    ...

    /**
     * ȡSpring @Transactional ע⣬ӦԹSpringṹ
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    /**
     * ǿ.
     * transactionAttributeSourcetransactionAttributeSource() صĶ
     */
    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
            TransactionAttributeSource transactionAttributeSource,
            TransactionInterceptor transactionInterceptor) {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = 
                new BeanFactoryTransactionAttributeSourceAdvisor();
        // ࣬ @Transactional 
        advisor.setTransactionAttributeSource(transactionAttributeSource);
        ...
        return advisor;
    }

}

abstract class TransactionAttributeSourcePointcut 
        extends StaticMethodMatcherPointcut implements Serializable {

    protected TransactionAttributeSourcePointcut() {
        // ڹ췽 ClassFilter
        setClassFilter(new TransactionAttributeSourceClassFilter());
    }

    /**
     * pointcut  matches 
     */
    @Override
    public boolean matches(Method method, Class<?> targetClass) {
        // õĽΪAnnotationTransactionAttributeSource
        TransactionAttributeSource tas = getTransactionAttributeSource();
        return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    }

    /**
     *  BeanFactoryTransactionAttributeSourceAdvisor ָ
     */
    @Nullable
    protected abstract TransactionAttributeSource getTransactionAttributeSource();

    /**
     * ڲ࣬ʵ ClassFilter
     */
    private class TransactionAttributeSourceClassFilter implements ClassFilter {

        /**
         * ClassFilter  matches
         */
        @Override
        public boolean matches(Class<?> clazz) {
            // ǷΪTransactionalProxyPlatformTransactionManagerPersistenceExceptionTranslatorʵ
            if (TransactionalProxy.class.isAssignableFrom(clazz) ||
                    PlatformTransactionManager.class.isAssignableFrom(clazz) ||
                    PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
                return false;
            }
            //ж TransactionAttributeSource ȡǷΪ
            // õĽΪAnnotationTransactionAttributeSource
            TransactionAttributeSource tas = getTransactionAttributeSource();
            return (tas == null || tas.isCandidateClass(clazz));
        }
    }

}

public abstract class StaticMethodMatcherPointcut 
        extends StaticMethodMatcher implements Pointcut {
    // ʡһЩ
    ...

    @Override
    public final MethodMatcher getMethodMatcher() {
        return this;
    }
}

abstract class TransactionAttributeSourcePointcut 
        extends StaticMethodMatcherPointcut implements Serializable {
    // ʡһЩ
    ...
}

@Override
public boolean isCandidateClass(Class<?> targetClass) {
    // ҵеannotationParsersѭƥ
    for (TransactionAnnotationParser parser : this.annotationParsers) {
        if (parser.isCandidateClass(targetClass)) {
            return true;
        }
    }
    return false;
}

public class SpringTransactionAnnotationParser 
        implements TransactionAnnotationParser, Serializable {

    /**
     * жǷ @Transactional ע
     */
    @Override
    public boolean isCandidateClass(Class<?> targetClass) {
        return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
    }
}

public abstract class AbstractFallbackTransactionAttributeSource 
        implements TransactionAttributeSource {

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

        // ʡԴӻлȡ
        ...
        else {
            // ȡ Transaction ԣ @Transactional ע
            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
            // ʡԷ뻺
            ...
            return txAttr;
        }
    }
}

protected TransactionAttribute computeTransactionAttribute(Method method, 
        @Nullable Class<?> targetClass) {
    // ĬϱҪ public ֧
    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
        return null;
    }
    // 1\. ȡȷеķ紫classIFooʵʵĵclassDefaultFoo
    //    ôӦý IFoo#method תΪ DefaultFoo#method
    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    // 2\. ӷϻȡ @Transactional 
    TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
    if (txAttr != null) {
        return txAttr;
    }
    // 3\. ϻȡ @Transaction 
    txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
    if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
        return txAttr;
    }
    if (specificMethod != method) {
        // 4\. ȷеķҲҴķϵ
        txAttr = findTransactionAttribute(method);
        if (txAttr != null) {
            return txAttr;
        }
        // 5\. ϶ûҵȷеϵ
        txAttr = findTransactionAttribute(method.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }
    }
    // 6\. ûлȡշnull
    return null;
}

    // ӷϻȡ @Transactional 
    protected TransactionAttribute findTransactionAttribute(Method method) {
        return determineTransactionAttribute(method);
    }

    // ϻȡ @Transactional 
    protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
        return determineTransactionAttribute(clazz);
    }

    // յõķ
    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        for (TransactionAnnotationParser parser : this.annotationParsers) {
            //  @Transactional ע
            TransactionAttribute attr = parser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }

    /**
     * ȡ Transactional ע⣬򷵻 null
     */
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        // ȡ Transactional ע⣬򷵻 null
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

    /**
     *  Transactional עľ
     */
    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());
        // ijʱʱ
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        // ǷΪֻ
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));
        // ع쳣
        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
        for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        // ع쳣
        for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

public Object invoke(MethodInvocation invocation) throws Throwable {
    Class<?> targetClass = (invocation.getThis() != null 
        ? AopUtils.getTargetClass(invocation.getThis()) : null);
    // ¿
    return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
        final InvocationCallback invocation) throws Throwable {
    TransactionAttributeSource tas = getTransactionAttributeSource();
    // ȡ@Transactional
    final TransactionAttribute txAttr = (tas != null 
        ? tas.getTransactionAttribute(method, targetClass) : null);
    // ȡIOCлȡ
    final TransactionManager tm = determineTransactionManager(txAttr);

    // ʡ ReactiveTransactionManager Ĵ
    ...

    PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
    // ȡȫ޶ʽΪ".."
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

    // Ĵ߼ҲǽҪĵط
    if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
        // 1\. 
        TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
        Object retVal;
        try {
            // 2\. ִоҵ
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // 3\. 쳣ع
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            // Ϣ
            cleanupTransactionInfo(txInfo);
        }
        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
            TransactionStatus status = txInfo.getTransactionStatus();
            if (status != null && txAttr != null) {
                retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
            }
        }
        // 4\. ύ񣬴лжǷ֧
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }
    else {
        // ʡ
        ...
    }
}