Spring AOP核心类解析，这是最全的一篇了！！

时间 2020-12-04

标签 java git 程序员 github 面试 spring 缓存微信 ide post 栏目 Spring 繁體版

原文原文链接

写在前面

最近，很多小伙伴在催更【Spring注解驱动开发】专题，好吧，【Spring注解驱动开发】专题确实有很长时间没更新了。那咱们从今天开始更新【Spring注解驱动开发】专题，一样的，咱们仍是以源码解析为主。
文章已同步收录到：https://github.com/sunshinelyz/technology-binghe 和 https://gitee.com/binghe001/technology-binghe 。若是文件对你有点帮助，别忘记给个Star哦！java

关注【冰河技术】微信公众号，回复“Spring注解”领取工程源码。git

类结构图

咱们先来看下AnnotationAwareAspectJAutoProxyCreator类的结构图。程序员

上图中一些 类/接口 的介绍：github

AspectJAwareAdvisorAutoProxyCreator : 公开了AspectJ的调用上下文，并弄清楚来自同一切面的多个Advisor在AspectJ中的优先级规则。面试

AbstractAdvisorAutoProxyCreator : 通用自动代理建立器，它基于检测到的每一个顾问程序为特定bean构建AOP代理。spring

AbstractAutoProxyCreator : 扩展了 ProxyProcessorSupport，实现了SmartInstantiationAwareBeanPostProcessor、BeanFactoryAware 接口，是BeanPostProcessor 实现，该实现使用AOP代理包装每一个合格的bean，并在调用bean自己以前委派给指定的拦截器。缓存

BeanFactoryAware : 实现了该接口的Bean能够知道它属于那个 BeanFactory，Bean能够经过Spring容器查找它的协同者（依赖查找），但大多数的Bean是经过构造器参数和Bean方法（依赖注入）来获取它的协同者。微信

BeanPostProcessor ：工厂钩子，容许自定义修改新的bean实例。例如，检查标记接口或使用代理包装bean。若是咱们须要在Spring容器中完成Bean的实例化，配置和其初始化先后添加一些本身的逻辑处理，咱们就能够定义一个或多个BeanPostProcessor接口的实现，而后注册到容器中。ide

InstantiationAwareBeanPostProcessor : BeanPostProcessor 的子接口，它添加了实例化以前的回调，以及实例化以后但设置了显式属性或自动装配以前的回调。它内部提供了3个方法，再加上BeanPostProcessor接口内部的2个方法，实现这个接口须要实现5个方法。InstantiationAwareBeanPostProcessor 接口的主要做用在于目标对象的实例化过程当中须要处理的事情，包括实例化对象的先后过程以及实例的属性设置。post

SmartInstantiationAwareBeanPostProcessor : InstantiationAwareBeanPostProcessor 接口的扩展，多出了3个方法，添加了用于预测已处理bean的最终类型的回调，再加上父接口的5个方法，因此实现这个接口须要实现8个方法，主要做用也是在于目标对象的实例化过程当中须要处理的事情。

总之：AspectJAwareAdvisorAutoProxyCreator为 AspectJ 切面类建立自动代理。

核心类解析

BeanPostProcessor 接口中的两个方法 postProcessBeforeInitialization 和 postProcessAfterInitialization，做用是对Bean初始化先后添加一些本身的逻辑。

@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    return bean;
}

@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    return bean;
}

InstantiationAwareBeanPostProcessor 是 BeanPostProcessor 的子接口，它额外增长了3个新的方法：postProcessBeforeInstantiation（目标对象被实例化以前调用的方法，能够返回目标实例的一个代理用来代替目标实例）、postProcessAfterInstantiation（该方法在Bean实例化以后执行，返回false，会忽略属性值的设置；若是返回true，会按照正常流程设置属性值）和 postProcessPropertyValues（对属性值进行修改，将来版本将会删除）

@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    return null;
}

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    return true;
}

@Nullable
default PropertyValues postProcessPropertyValues(
    PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
    return pvs;
}

SmartInstantiationAwareBeanPostProcessor接口继承InstantiationAwareBeanPostProcessor接口，里面定义了3个方法：predictBeanType（预测Bean的类型）、determineCandidateConstructors（选择合适的构造器）、getEarlyBeanReference（解决循环引用问题）。

@Nullable
default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
    return null;
}

@Nullable
default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
    return null;
}

default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
    return bean;
}

AbstractAutoProxyCreator 是AOP的一个核心类，它实现了SmartInstantiationAwareBeanPostProcessor、BeanFactoryAware 接口，实现了代理建立的逻辑，使用AOP代理包装每一个合格的bean，并在调用bean自己以前委派给指定的拦截器。

AbstractAdvisorAutoProxyCreator 通用自动代理建立器，它基于检测每一个bean的加强器，为特殊的bean构建AOP代理。子类能够重写此findCandidateAdvisors()方法，以返回适用于任何对象的advisor的自定义列表，子类还能够重写继承的AbstractAutoProxyCreator.shouldSkip()方法，以将某些对象排除在自动代理以外。

protected List<Advisor> findCandidateAdvisors() {
       Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
     return this.advisorRetrievalHelper.findAdvisorBeans();
}

AspectJAwareAdvisorAutoProxyCreator 扩展 AbstractAdvisorAutoProxyCreator，公开了AspectJ的调用上下文，并在多个加强器来自同一切面时搞清楚AspectJ的建议优先级顺序。按AspectJ优先级排序其他部分：

@Override
@SuppressWarnings("unchecked")
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
    List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors = new ArrayList<>(advisors.size());
    for (Advisor element : advisors) {
        partiallyComparableAdvisors.add(
            new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
    }
    List<PartiallyComparableAdvisorHolder> sorted = PartialOrder.sort(partiallyComparableAdvisors);
    if (sorted != null) {
        List<Advisor> result = new ArrayList<>(advisors.size());
        for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
            result.add(pcAdvisor.getAdvisor());
        }
        return result;
    }
    else {
        return super.sortAdvisors(advisors);
    }
}

在加强链头部增长一个ExposeInvocationInterceptor，使用AspectJ表达式切入点和使用AspectJ样式的advisor时，须要这些附加advisor。

protected void extendAdvisors(List<Advisor> candidateAdvisors) {
      AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
}

若是此后处理器不该该考虑将给定的bean用于自动代理，子类应重写此方法以返回true

@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
    // TODO: Consider optimization by caching the list of the aspect names
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    for (Advisor advisor : candidateAdvisors) {
        if (advisor instanceof AspectJPointcutAdvisor &&
            ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
            return true;
        }
    }
    return super.shouldSkip(beanClass, beanName);
}

AspectJAwareAdvisorAutoProxyCreator 还有一个子类叫 AnnotationAwareAspectJAutoProxyCreator，子类AnnotationAwareAspectJAutoProxyCreator是用于处理当前应用程序上下文中的全部AspectJ注释方面以及Spring Advisor。若是Spring AOP的基于代理的模型可以应用任何AspectJ注释的类，它们的advisor将被自动识别，这涵盖了方法执行链接点，Spring Advisor的处理遵循AbstractAdvisorAutoProxyCreator中创建的规则。

生成代理对象

从使用<aop:xxx>标签来自动生成代理的话，先看看AopNamespaceHandler，使用<aop:config>标签则使用 ConfigBeanDefinitionParser 解析，使用了<aop:aspectj-autoproxy>标签则使用 AspectJAutoProxyBeanDefinitionParser 解析，依次类推。

@Override
public void init() {
    // In 2.0 XSD as well as in 2.1 XSD.
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

    // Only in 2.0 XSD: moved to context namespace as of 2.1
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

<aop:config>方式使用 AspectJAwareAdvisorAutoProxyCreator 建立代理
<aop:aspectj-autoproxy>使用 AnnotationAwareAspectJAutoProxyCreator 建立代理

ConfigBeanDefinitionParser.java

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    CompositeComponentDefinition compositeDef =
        new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    parserContext.pushContainingComponent(compositeDef);

    configureAutoProxyCreator(parserContext, element); // 注册AspectJAwareAdvisorAutoProxyCreator

    List<Element> childElts = DomUtils.getChildElements(element);
    for (Element elt: childElts) {
        String localName = parserContext.getDelegate().getLocalName(elt);
        if (POINTCUT.equals(localName)) {
            parsePointcut(elt, parserContext);
        }
        else if (ADVISOR.equals(localName)) {
            parseAdvisor(elt, parserContext);
        }
        else if (ASPECT.equals(localName)) {
            parseAspect(elt, parserContext);
        }
    }

    parserContext.popAndRegisterContainingComponent();
    return null;
}

private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
    AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
}

AopConfigUtils.java

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    CompositeComponentDefinition compositeDef =
        new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    parserContext.pushContainingComponent(compositeDef);

    configureAutoProxyCreator(parserContext, element); // 注册AspectJAwareAdvisorAutoProxyCreator

    List<Element> childElts = DomUtils.getChildElements(element);
    for (Element elt: childElts) {
        String localName = parserContext.getDelegate().getLocalName(elt);
        if (POINTCUT.equals(localName)) {
            parsePointcut(elt, parserContext);
        }
        else if (ADVISOR.equals(localName)) {
            parseAdvisor(elt, parserContext);
        }
        else if (ASPECT.equals(localName)) {
            parseAspect(elt, parserContext);
        }
    }

    parserContext.popAndRegisterContainingComponent();
    return null;
}

private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
    AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
}

AopConfigUtils.java

public static void registerAspectJAutoProxyCreatorIfNecessary(
    ParserContext parserContext, Element sourceElement) {
    // 在这里注册的是AspectJAwareAdvisorAutoProxyCreator
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
        parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext); // 注册组件
}

@Nullable
public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
    BeanDefinitionRegistry registry, @Nullable Object source) {

    return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
}

AspectJAwareAdvisorAutoProxyCreator 实现了 BeanPostProcessor 等上面介绍的接口，主要做用于Bean初始化先后，实例化先后，全部的Bean都被做用到。InstantiationAwareBeanPostProcessor 是 BeanPostProcessor的子接口，但它的调用时间点发生在Bean实例化前，在真正调用doCreateBean()建立bean实例以前执行postProcessBeforeInstantiation()。

AbstractAutoProxyCreator.java

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    Object cacheKey = getCacheKey(beanClass, beanName);　　// 获得一个缓存的惟一key（根据beanClass和beanName生成惟一key）
    // 若是当前targetSourcedBeans（经过自定义TargetSourceCreator建立的TargetSource）不包含cacheKey
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {　　//advisedBeans（已经被加强的Bean，即AOP代理对象）中包含当前cacheKey，返回null，即走Spring默认流程
            return null;
        }
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {// 若是是基础设施类（如Advisor、Advice、AopInfrastructureBean的实现）不进行处理;（略）
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // 若是有自定义的TargetSource，在此处建立代理
    // 禁止目标Bean的没必要要的默认实例化：
    // TargetSource将以自定义方式处理目标实例。
    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;
}

经过 AbstractAutoProxyCreator 中的 postProcessAfterInitialization() 建立AOP代理。

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {　　// 若是以前调用过getEarlyBeanReference获取包装目标对象到AOP代理对象（若是须要），则再也不执行
            return wrapIfNecessary(bean, beanName, cacheKey);　　// 包装目标对象到AOP代理对象（若是须要）
        }
    }
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { // 经过TargetSourceCreator进行自定义TargetSource不须要包装
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {　　// 不该该被加强对象不须要包装
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { // 基础设施或应该skip的不须要保证
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 若是有advise则建立代理。
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        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;
}

好了，今天就到这儿吧，我是冰河，咱们下期见~~

重磅福利

微信搜一搜【冰河技术】微信公众号，关注这个有深度的程序员，天天阅读超硬核技术干货，公众号内回复【PDF】有我准备的一线大厂面试资料和我原创的超硬核PDF技术文档，以及我为你们精心准备的多套简历模板（不断更新中），但愿你们都能找到心仪的工做，学习是一条时而郁郁寡欢，时而开怀大笑的路，加油。若是你经过努力成功进入到了心仪的公司，必定不要懈怠放松，职场成长和新技术学习同样，不进则退。若是有幸咱们江湖再见！

另外，我开源的各个PDF，后续我都会持续更新和维护，感谢你们长期以来对冰河的支持！！