SpringAOP核心類有哪些

類結(jié)構(gòu)圖

我們先來看下AnnotationAwareAspectJAutoProxyCreator類的結(jié)構(gòu)圖。

 

上圖中一些 類/接口的介紹：

AspectJAwareAdvisorAutoProxyCreator: 公開了AspectJ的調(diào)用上下文，并弄清楚來自同一切面的多個Advisor在AspectJ中的優(yōu)先級規(guī)則。

AbstractAdvisorAutoProxyCreator: 通用自動代理創(chuàng)建器，它基于檢測到的每個顧問程序?yàn)樘囟╞ean構(gòu)建AOP代理。

AbstractAutoProxyCreator: 擴(kuò)展了  ProxyProcessorSupport，實(shí)現(xiàn)了SmartInstantiationAwareBeanPostProcessor、BeanFactoryAware 接口，是BeanPostProcessor 實(shí)現(xiàn)，該實(shí)現(xiàn)使用AOP代理包裝每個合格的bean，并在調(diào)用bean本身之前委派給指定的攔截器。

BeanFactoryAware: 實(shí)現(xiàn)了該接口的Bean可以知道它屬于那個 BeanFactory，Bean可以通過Spring容器查找它的協(xié)同者（依賴查找），但大多數(shù)的Bean是通過構(gòu)造器參數(shù)和Bean方法（依賴注入）來獲取它的協(xié)同者。

BeanPostProcessor：工廠鉤子，允許自定義修改新的bean實(shí)例。例如，檢查標(biāo)記接口或使用代理包裝bean。如果我們需要在Spring容器中完成Bean的實(shí)例化，配置和其初始化前后添加一些自己的邏輯處理，我們就可以定義一個或多個BeanPostProcessor接口的實(shí)現(xiàn)，然后注冊到容器中。

InstantiationAwareBeanPostProcessor: BeanPostProcessor  的子接口，它添加了實(shí)例化之前的回調(diào)，以及實(shí)例化之后但設(shè)置了顯式屬性或自動裝配之前的回調(diào)。它內(nèi)部提供了3個方法，再加上BeanPostProcessor接口內(nèi)部的2個方法，實(shí)現(xiàn)這個接口需要實(shí)現(xiàn)5個方法。InstantiationAwareBeanPostProcessor 接口的主要作用在于目標(biāo)對象的實(shí)例化過程中需要處理的事情，包括實(shí)例化對象的前后過程以及實(shí)例的屬性設(shè)置。

SmartInstantiationAwareBeanPostProcessor: InstantiationAwareBeanPostProcessor 接口的擴(kuò)展，多出了3個方法，添加了用于預(yù)測已處理bean的最終類型的回調(diào)，再加上父接口的5個方法，所以實(shí)現(xiàn)這個接口需要實(shí)現(xiàn)8個方法，主要作用也是在于目標(biāo)對象的實(shí)例化過程中需要處理的事情。

總之：AspectJAwareAdvisorAutoProxyCreator為 AspectJ 切面類創(chuàng)建自動代理。

核心類解析

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（ 目標(biāo)對象被實(shí)例化之前調(diào)用的方法，可以返回目標(biāo)實(shí)例的一個代理用來代替目標(biāo)實(shí)例 ）、postProcessAfterInstantiation（該方法在Bean實(shí)例化之后執(zhí)行，返回false，會忽略屬性值的設(shè)置；如果返回true，會按照正常流程設(shè)置屬性值） 和 postProcessPropertyValues（對屬性值進(jìn)行修改，未來版本將會刪除）

@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（預(yù)測Bean的類型）、determineCandidateConstructors（選擇合適的構(gòu)造器）、getEarlyBeanReference（解決循環(huán)引用問題）。

@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的一個核心類，它實(shí)現(xiàn)了SmartInstantiationAwareBeanPostProcessor、BeanFactoryAware 接口，實(shí)現(xiàn)了代理創(chuàng)建的邏輯，使用AOP代理包裝每個合格的bean，并在調(diào)用bean本身之前委派給指定的攔截器。

AbstractAdvisorAutoProxyCreator通用自動代理創(chuàng)建器，它基于檢測每個bean的增強(qiáng)器，為特殊的bean構(gòu)建AOP代理。子類可以重寫此findCandidateAdvisors()方法，以返回適用于任何對象的advisor的自定義列表，子類還可以重寫繼承的AbstractAutoProxyCreator.shouldSkip()方法，以將某些對象排除在自動代理之外。

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

AspectJAwareAdvisorAutoProxyCreator擴(kuò)展 AbstractAdvisorAutoProxyCreator，公開了AspectJ的調(diào)用上下文，并在多個增強(qiáng)器來自同一切面時搞清楚AspectJ的建議優(yōu)先級順序。按AspectJ優(yōu)先級排序其余部分：

@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);
    }
}

在增強(qiáng)鏈頭部增加一個ExposeInvocationInterceptor，使用AspectJ表達(dá)式切入點(diǎn)和使用AspectJ樣式的advisor時，需要這些附加advisor。

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

如果此后處理器不應(yīng)該考慮將給定的bean用于自動代理，子類應(yīng)重寫此方法以返回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是用于處理當(dāng)前應(yīng)用程序上下文中的所有AspectJ注釋方面以及Spring Advisor。如果Spring  AOP的基于代理的模型能夠應(yīng)用任何AspectJ注釋的類，它們的advisor將被自動識別，這涵蓋了方法執(zhí)行連接點(diǎn)，Spring  Advisor的處理遵循AbstractAdvisorAutoProxyCreator中建立的規(guī)則。

生成代理對象

從使用aop:xxx標(biāo)簽來自動生成代理的話，先看看AopNamespaceHandler，使用aop:config標(biāo)簽則使用 ConfigBeanDefinitionParser 解析，使用了aop:aspectj-autoproxy標(biāo)簽則使用 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 創(chuàng)建代理
• aop:aspectj-autoproxy使用 AnnotationAwareAspectJAutoProxyCreator 創(chuàng)建代理

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實(shí)現(xiàn)了 BeanPostProcessor等上面介紹的接口，主要作用于Bean初始化前后，實(shí)例化前后，所有的Bean都被作用到。InstantiationAwareBeanPostProcessor是 BeanPostProcessor的子接口，但它的調(diào)用時間點(diǎn)發(fā)生在Bean實(shí)例化前，在真正調(diào)用doCreateBean()創(chuàng)建bean實(shí)例之前執(zhí)行postProcessBeforeInstantiation()。

AbstractAutoProxyCreator.java

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    Object cacheKey = getCacheKey(beanClass, beanName);  // 得到一個緩存的唯一key（根據(jù)beanClass和beanName生成唯一key）
    // 如果當(dāng)前targetSourcedBeans（通過自定義TargetSourceCreator創(chuàng)建的TargetSource）不包含cacheKey
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {  //advisedBeans（已經(jīng)被增強(qiáng)的Bean，即AOP代理對象）中包含當(dāng)前cacheKey，返回null，即走Spring默認(rèn)流程
            return null;
        }
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {// 如果是基礎(chǔ)設(shè)施類（如Advisor、Advice、AopInfrastructureBean的實(shí)現(xiàn)）不進(jìn)行處理;（略）
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // 如果有自定義的TargetSource，在此處創(chuàng)建代理
    // 禁止目標(biāo)Bean的不必要的默認(rèn)實(shí)例化：
    // TargetSource將以自定義方式處理目標(biāo)實(shí)例。
    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() 創(chuàng)建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)) {  // 如果之前調(diào)用過getEarlyBeanReference獲取包裝目標(biāo)對象到AOP代理對象（如果需要），則不再執(zhí)行
            return wrapIfNecessary(bean, beanName, cacheKey);  // 包裝目標(biāo)對象到AOP代理對象（如果需要）
        }
    }
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { // 通過TargetSourceCreator進(jìn)行自定義TargetSource不需要包裝
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {  // 不應(yīng)該被增強(qiáng)對象不需要包裝
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { // 基礎(chǔ)設(shè)施或應(yīng)該skip的不需要保證
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 如果有advise則創(chuàng)建代理。
    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)); // 創(chuàng)建代理對象
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}