前文回顾

在前面我们了解到了AnnotationAwareAspectJAutoProxyCreator是如何解析Aspect切面类成Advisor列表的,在解析完Advisors之后,Spring 就要开始对符合条件的Bean做"织入"操作了.

织入切面逻辑的入口

Spring AOP是在Bean的初始化过程中进行的，Spring Bean的生命周期从宏观上可以简单视为:
实例化->依赖注入->初始化->销毁.
在完成依赖注入之后，Spring会执行initializeBean方法对Bean做初始化:

• org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        // 激活BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 激活BeanPostProcessor的postProcessBeforeInitialization方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 激活InitializingBean的afterPropertiesSet方法、initMethod
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        // 激活BeanPostProcessor的postProcessAfterInitialization方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

在执行完invokeInitMethods方法之后,Spring接着触发了BeanPostProcessor的postProcessAfterInitialization方法.
AnnotationAwareAspectJAutoProxyCreator继承自AbstractAutoProxyCreator,AbstractAutoProxyCreator又通过SmartInstantiationAwareBeanPostProcessor实现了BeanPostProcessor这个顶层接口.
因此,在applyBeanPostProcessorsAfterInitialization中会触发org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization.

wrapIfNecessary

• org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 当Bean被循环引用,并且被暴露了
        // 就会通过 getEarlyBeanReference来创建代理类
        // 通过判断 earlyProxyReferences 中是否存在beanName来决定是否需要对target类进行动态代理
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 代理
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

Spring在进行代理之前会判断Bean是否为空，如果不为空，那么会从缓存中查看当前Bean是否已经在之前被处理过了.
接着Spring还会查看一下earlyProxyReferences中是否存在当前bean，earlyProxyReferences是一个用来解决循环依赖的Map.
Spring处理正常Bean的织入都是在初始化后的，但是如果发生了循环依赖，Bean不得不提前暴露引用时，需要提前生成代理，此时在earlyProxyReferences中就会存放一个引用，证明当前的bean已经被提前暴露并代理了.
具体的逻辑在org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference中.

• org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // beanName不为空，并且存在于targetSourcedBeans中，也就是自定义的TargetSource被解析过了
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 如果Bean为advisedBeans，也不需要被代理
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // isInfrastructureClass和shouldSkip的作用:
    // 识别切面类，加载切面类成advisors
    // 为什么又执行一次是因为存在循环依赖的情况下无法加载advisor
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // Create proxy if we have advice.
    // 返回匹配当前Bean的所有Advice、Advisor、Interceptor
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建Bean对应的代理，SingletonTargetSource用于封装实现类的信息
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    // 下次代理不需要重复生成了
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

1. 判断缓存中是否存在当前Bean或者是当前Bean已经被代理过了，那么直接返回bean.
2. 尝试再次加载advisor，避免由于循环依赖导致advisor加载不完整.
3. 获取当前bean符合的advisor数组.
4. 创建代理类.

本文来分析getAdvicesAndAdvisorsForBean方法是如何在所有的advisors中找到匹配的advisor的.

• org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean

protected Object[] getAdvicesAndAdvisorsForBean(
        Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    // eligible->合适的、合格的
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

这里调用了findEligibleAdvisors来寻找合适的advisors，如果返回的集合为空，那么最后返回null.
如果返回了advisors，将其数组化返回.

• org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // 找到之前加载过的所有候选advisors
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 判断找到的Advisor能不能作用到当前类上
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    // 对获取到的advisor进行排序
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

1. 首先获取之前解析过的advisors列表-candidateAdvisors,这里是所有的切面类解析成的advisors.
2. 在candidateAdvisors中找到当前Bean匹配的advisor-findAdvisorsThatCanApply.
3. 将获取到的eligibleAdvisors进行排序.

• org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply

protected List<Advisor> findAdvisorsThatCanApply(
        List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
    // 给currentProxiedBeanName这个ThreadLocal变量设置上正在动态代理的beanName
    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {
        // 筛选出匹配Bean的Advisors
        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    }
    finally {
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}

最终是调用了AopUtils.findAdvisorsThatCanApply来筛选匹配Bean的Advisors.

• org.springframework.aop.support.AopUtils#findAdvisorsThatCanApply

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    if (candidateAdvisors.isEmpty()) {
        return candidateAdvisors;
    }
    // 存储最终匹配的Advisor集合
    List<Advisor> eligibleAdvisors = new ArrayList<>();
    for (Advisor candidate : candidateAdvisors) {
        // 当前advisor对象是否实现了IntroductionAdvisor接口
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor) {
            // already processed
            continue;
        }
        // canApply->判断当前的advisor的pointcut表达式是否匹配当前class
        if (canApply(candidate, clazz, hasIntroductions)) {
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

1. 遍历candidateAdvisors,如果advisor对象实现了IntroductionAdvisor(Introduction已经很少用了，这里不作讲解).执行canApply判断是否需要加入eligibleAdvisors.
2. 调用canApply来判断当前advisor的pointcut表达式是否匹配当前class.

• org.springframework.aop.support.AopUtils#canApply

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
    // 当前advisor是否实现IntroductionAdvisor
    if (advisor instanceof IntroductionAdvisor) {
        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    }
    // 判断是否为PointcutAdvisor
    else if (advisor instanceof PointcutAdvisor) {
        // 强转为PointcutAdvisor
        // Spring创建的advisor实例为InstantiationModelAwarePointcutAdvisorImpl,实现了PointcutAdvisor接口
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    else {
        // It doesn't have a pointcut so we assume it applies.
        // 如果advisor没有pointcut表达式，那么匹配所有的bean
        return true;
    }
}

1. 如果advisor是一个IntroductionAdvisor类型的实例，那么使用ClassFilter进行matches.
2. 通常我们的advisor都是InstantiationModelAwarePointcutAdvisorImpl实例，所以会执行重载的方法canApply.
3. 如果当前advisor没有pointcut表达式，那么匹配所有的bean.

• org.springframework.aop.support.AopUtils#canApply

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    // 如果ClassFilter不匹配，也就是初步筛选失败,直接返回
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }
    // 如果类级别匹配，那么再继续匹配方法是否符合切点表达式
    // 如果当前advisor所指代的方法切点表达式对任意方法都放行,则直接返回
    MethodMatcher methodMatcher = pc.getMethodMatcher();
    if (methodMatcher == MethodMatcher.TRUE) {
        // No need to iterate the methods if we're matching any method anyway...
        return true;
    }
    // 这里将methodMatcher强转为IntroductionAwareMethodMatcher类型
    // 如果目标类不包含Introduction类型的advisor，那么使用
    // IntroductionAwareMethodMatcher.matches方法进行匹配判断可以提升匹配的效率
    // 该方法会判断目标Bean中没有使用Introduction织入新的方法，则可以使用该方法进行静态匹配，从而提升效率
    // 因为Introduction类型的Advisor可以往目标类中织入新的方法，新的方法也可能是被AOP环绕的方法
    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
    }

    Set<Class<?>> classes = new LinkedHashSet<>();
    // 判断当前class是不是代理的class对象
    if (!Proxy.isProxyClass(targetClass)) {
        classes.add(ClassUtils.getUserClass(targetClass));
    }
    classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

    for (Class<?> clazz : classes) {
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        for (Method method : methods) {
            if (introductionAwareMethodMatcher != null ?
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                    // 使用方法匹配器进行匹配
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }

    return false;
}

这里就是构建拦截链中最关键的部分了，Spring要筛选出当前Bean匹配的advisor，借助了AspectJ的能力，也就是AspectJExpressionPointcut封装的AspectJ能力.它支持类级别的匹配，也支持方法级别的匹配，还可以匹配返回值、参数类型等等.
那么顾名思义:

1. ClassFilter用来匹配Class.
2. MethodMatcher用来匹配Method.

再来看看整个方法，整体可以看到，先调用了ClassFilter匹配当前Bean是否符合Advisor的切点表达式，再调用了methodMatcher来匹配当前Bean的所有方法是否存在符合advisor切点表达式的.
有兴趣的可以了解一下:
org.aspectj.weaver.tools.PointcutExpression#couldMatchJoinPointsInType.
org.aspectj.weaver.tools.ShadowMatch.

• 解析后得到的advisor数组

specificInterceptors

总结

1. Spring AOP的织入是发生在doCreateBean期间的，在其执行初始化时进行织入横切逻辑.但是发生循环依赖时，这个过程会被提前，也就是在暴露引用的时候可能会发生代理的创建.
2. 在解析到了所有advisors之后，Spring借助AspectJ对bean进行了进一步的筛选，进而筛选到更加精确的advisor,这也使得Spring AOP支持更多元的切入点.