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

34次阅读

共计 6463 个字符，预计需要花费 17 分钟才能阅读完成。

前言

往期文章：

  • 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(..)

Search the given candidate Advisors to find all Advisors that can apply to the specified bean.

从给出的候选 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. 结束

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

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

正文完
spring
发表至：无分类
2019-11-11
 0