向您图文并茂生动讲解Spring AOP 源码（2）

前言

往期文章：

• Spring IoC - Spring IoC 的设计
• Spring IoC - IoC 容器初始化 源码解析
• Spring IoC - 依赖注入 源码解析
• Spring AOP - 注解方式使用介绍（长文详解）
• 向您生动地讲解Spring AOP 源码（1）

在上一章 向您生动地讲解Spring AOP 源码（1） 中，作者介绍了【开启AOP自动代理的玄机】和【自动代理的触发时机】。

在本章中，作者会向您介绍， Spring AOP 是如何解析我们配置的Aspect，生成 Advisors 链的？

闲话不多说，让我们直接开始。

获取对应 Bean 适配的Advisors 链

获取对应 Bean 适配的 Advisors 链，分为两步。

1. 获取容器所有的 advisors 作为候选，即解析Spring 容器中所有 Aspect 类中的 advice 方法，包装成 advisor；
2. 从候选的 Advisors 中筛选出适配当前 Bean的 Advisors 链；

未免读者阅读不连贯，我们重新贴一下上篇文章中我们最后讲解的一段源码，由此继续往下讲述。

源码位置： AbstractAutoProxyCreator#wrapIfNecessary(..)

源码位置： AspectJAwareAdvisorAutoProxyCreator#shouldSkip(..)

源码位置： AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean(..) 、 AbstractAdvisorAutoProxyCreator#findEligibleAdvisors(..)

可以看到两个方法都调用了 findCandidateAdvisors() 方法，也就是去获取候选的 Advisors，我们进去看看里面干了什么。

1. 获取候选的 Advisors

从Debug 出来的线程栈可以看出， AnnotationAwareAspectJAutoProxyCreator 通过 持有 BeanFactoryAspectJAdvisorsBuilder 对象，来获取Advisor链。

再往下看。源码位置： BeanFactoryAspectJAdvisorsBuilder#buildAspectJAdvisors

内容较长，请大家跟着注释耐心看下去。

这个方法除了等下要讲 advisorFactory.getAdvisors(..) 以外，需要注意的就是其为了避免每次都去获取所有的beanName，解析判断，引入了缓存的机制；还有就是Aspect类是根据Spring Bean 是否被 @Aspect 注解修饰来判断的。

我们接下去看，真正的去获取我们的Advisor的方法， this.advisorFactory.getAdvisors(factory) 方法如下：

源码位置： ReflectiveAspectJAdvisorFactory#getAdvisors(..)

@Override
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        //获取我们的标记为Aspect的类
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        //获取我们的切面类的名称
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
        //校验我们的切面类
        validate(aspectClass);

        // 这里使用了装饰器模式，目的是使MetadataAwareAspectInstanceFactory只实例化一次
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
                new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

        List<Advisor> advisors = new ArrayList<>();
        //获取到切面类中的所有方法，但是该方法不会解析到标注了@PointCut注解的方法
        for (Method method : getAdvisorMethods(aspectClass)) {
            // 循环解析我们切面中的方法
            // 获取当前方法的增强器Advisor
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }
        // 如果寻找的增强器不为空而且又配置了增强延迟初始化那么需要在首位加入同步实例化增强器
        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }
        // Find introduction fields.
        // 获取 DeclareParents 注解
        for (Field field : aspectClass.getDeclaredFields()) {
            Advisor advisor = getDeclareParentsAdvisor(field);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        return advisors;
    }

解析advice 方法成 advisor对象，

源码位置： ReflectiveAspectJAdvisorFactory#getAdvisor(..)

@Override
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
                              int declarationOrderInAspect, String aspectName) {
        //校验
        validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
        //获取当前方法的切入点 pointcut
        AspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
        if (expressionPointcut == null) {
            return null;
        }
        //根据切点信息生成 advisor
        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

生成advisor

如何生成advisor也值得一提。

注释方式下，我们声明的advice 方法是这样的。（不熟悉范例的可以看上一篇文章）

@Aspect
@Component
public class PointCutConfig {
    // ... 省略
    // service 层
    @Pointcut("within(ric.study.demo.aop.svc..*)")
    public void inSvcLayer() {}
    // ... 省略
}
@Aspect
@Component
public class GlobalAopAdvice {

    @Before("ric.study.demo.aop.PointCutConfig.inSvcLayer()")
    public void logBeforeSvc(JoinPoint joinPoint) {
        System.out.println("在service 层前打印日志");
        System.out.println("拦截的service 方法的方法签名: " + joinPoint.getSignature());
    }
}

生成之后是这样的，

advice 的对象类型是 InstantiationModelAwarePointcutAdvisorImpl ，我们来看下生成advisor时调用的这个类的构造函数，

里面包括了一个重要的方法instantiateAdvice，即创建Advice，这也是我要强调的重点，怎么解析出来一个advice。

源码位置： InstantiationModelAwarePointcutAdvisorImpl#instantiateAdvice(..)

源码位置： ReflectiveAspectJAdvisorFactory#getAdvice(..)

第一次解析Advisor的时机

关于第一次解析Advisor的时机，我刚开始也搞混了。所以在这里说明一下。

这个图是之前贴过的，第一次触发的截图。

AnnotationAwareAspectJAutoProxyCreator 继承了 AbstractAutoProxyCreator 实现了 InstantiationAwareBeanPostProcessor 接口：

会在生成target class 对象之前，调用 postProcessBeforeInstantiation(..) ，具体的代码可以去看 AbstractAutowireCapableBeanFactory#createBean(..) 方法。我们这边直接看一下 postProcessBeforeInstantiation(..) 在 AbstractAutoProxyCreator 中的实现。

/**
     * 在创建Bean的流程中还没调用构造器来实例化Bean的时候进行调用(实例化前后)
     * AOP解析切面在这里完成
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 构建我们的缓存key
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            // 如果被解析过直接返回
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            // 判断是不是基础的Bean（Advice、PointCut、Advisor、AopInfrastructureBean）是就直接跳过
            // 判断是不是应该跳过 (AOP解析直接解析出我们的切面信息(并且把我们的切面信息进行缓存)，
            // 而事务在这里是不会解析的)
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }

2. 筛选 出 适配当前类的 Advisors

这里来一条分割线，至此， findCandidateAdvisors() 算是解析完毕了。

但是我们通过这个方法只是获得了所有候选的advisors，还记得我们这一节的标题不？

【获取对应 Bean 适配的Advisors 链】

那么我们下一步就是要过滤出 适配当前这个 target class 的 advisors。

也就是上图的 findAdvisorsThatCanApply(..)

从给出的候选 Advisors 找出可以作用在 当前bean 的 Advisors 链

Debug阶段，筛选之前的候选 advisors 和筛选之后的可用的 advisors，

源码位置： AbstractAdvisorAutoProxyCreator#findAdvisorsThatCanApply(..)

源码位置： AopUtils#findAdvisorsThatCanApply(..)

我们接下去看筛选的关键方法 AopUtils#canApply(..)

筛选的工作主要由 ClassFilter 和 MethodMatcher 完成，比如AspectJExpressionPointcut的实现了ClassFilter和MethodMatcher接口，最终由AspectJ表达式解析，这个地方就复杂了，也不是核心点。

又是一条分割线。

到这里之后，Advisor的筛选过程我们算是讲完了。

经过排序之后，我们算是拿到了这个目标类使用的 Advisors 链。

现在，让我们再回到最初的起点。

源码位置： AbstractAutoProxyCreator#wrapIfNecessary(..)

小结

到这里，大家可以回顾一下，我们总算是把 TODO-1 【Spring AOP 如何 获取对应 Bean 适配的Advisors 链】介绍完毕了，总结一下核心逻辑就是：

1. 获取当前 IoC 容器中所有的 Aspect 类

2. 给 每个Aspect 类的advice 方法创建一个 Spring Advisor，这一步又能细分为

   1. 遍历所有advice 方法
   2. 解析方法的注解和pointcut
   3. 实例化 Advisor 对象
3. 获取到 候选的 Advisors，并且缓存起来，方便下一次直接获取

4. 从候选的 Advisors 中筛选出与目标类 适配的Advisor

   1. 获取到 Advisor 的 切入点 pointcut
   2. 获取到 当前 target 类 所有的 public 方法
   3. 遍历方法，通过 切入点 的 methodMatcher 匹配当前方法，只有有一个匹配成功就相当于当前的Advisor 适配
5. 对筛选之后的 Advisor 链进行排序
6. 结束

下一节中，我们会介绍 【代理类的创建过程】，我们下次再会。

如果本文有帮助到你，希望能点个赞，这是对我的最大动力。