AOP源码分析之@EnableAspectJAutoProxy

上节我们在Spring注解驱动开发AOP功能的篇幅中简单的通过案例来回顾了AOP的注解驱动开发的基本过程，同时也提过到一点，并不是我们的重点，本节我们来分析AOP底层源码是如何运作的，首先我们从注解@EnableAspectJAutoProxy作为我们的分析的入口。

当我们点进去之后发现：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;

boolean exposeProxy() default false;
}

这是Spring注解驱动编程的套路，在Springboot中我们会大量的看到同样的编码分割，其中上述源码中最重要的是注解@Import({AspectJAutoProxyRegistrar.class})的作用，简单的在这里说下该注解的作用：

  • @Import：一般是用来帮助我们导入其他的组件，在后面的篇幅我们再来介绍它的使用这里大家只需要知道是帮助我们导入其他组件就可以了，在此处是帮助我们导入组件AspectJAutoProxyRegistrar.class

既然是导入组件AspectJAutoProxyRegistrar.class，接下来我们来看看这个组件，继续点击进去来到：

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
AspectJAutoProxyRegistrar() {
}

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
    if (enableAspectJAutoProxy != null) {
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }

        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }

}

发现我们的组件AspectJAutoProxyRegistrar竟然实现了ImportBeanDefinitionRegistrar接口,简单的说一下该接口的作用：

ImportBeanDefinitionRegistrar 的作用

在整个spring容器技术中，我们都知道创建一个对象只需要在对应的bean上添加注解@Bean，这种方式是按照Spring的规定来帮助我们进行对象的创建,如下面这段代码：

@Bean
public MathCalculator calculator(){
    return new MathCalculator();
}

其中，Spring创建MathCalculator 的以方法名为name属性规则创建的，当然我们也可以指定要创建bean的name，只需通过注解@Bean的value属性指定，代码如下：

@Bean(value = "calculator1")
public MathCalculator calculator(){
    return new MathCalculator();
}

上述只是创建bean的一种方式，实际上Spring还为我们提供了一种自定义的创建bean的方式，也就是只要我们实现接口ImportBeanDefinitionRegistrar 即可，我们可以按照自己规则来完成bean的创建，我们来看相关源码

  • 该接口位于org.springframework.context.annotation包下：
public interface ImportBeanDefinitionRegistrar {
default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
    this.registerBeanDefinitions(importingClassMetadata, registry);
}

default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
}

在该接口我们发现有空实现的方法，此方法就需要我们来完成实现逻辑，由于篇幅有限本篇不在啰嗦了，大家只需知道有这样一种方式即可，后续我会进行相关知识和入门案例的编写，

了解了ImportBeanDefinitionRegistrar的作用之后，我们发下组件AspectJAutoProxyRegistrar实现其中的方法，通过Dbug我们来跟踪下代码的流程走向，其中在方法的实现中我们发现这段代码：

  AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

从字面意思来看来理解这段代码的意思就是如果需要注册一个切面注解代理生成器，有点蒙，不过没关系，我们Dbug来跟一下代码来到

AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary（BeanDefinitionRegistry registry）这个方法

  @Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null);
}

此方法又调用内部的两个参数的方法，接着Dbug进去我们来到：

  @Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

同样该方法调用了内部方法registerOrEscalateApcAsRequired(...)，其大致作用是：如果是一个必要的组件，向容器中注册或者来升级一下它，其组件的类型是AnnotationAwareAspectJAutoProxyCreator.clss,其实到这一步就知道了，原来是要给我们的容器中注册一个AnnotationAwareAspectJAutoProxyCreator ，不方，到这一步可以继续Dbug代码，也可以不用了，我们作为学者不妨在来看看该方法的实现，代码如下：

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }

        return null;
    } else {
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", -2147483648);
        beanDefinition.setRole(2);
        registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
        return beanDefinition;
    }
}

代码总体不是很难理解，Dbug截图如下：

Aop源码分析1.png

上图也就是我们方法的参数，其中registry 为Bean定义信息的注册器，cls就是AnnotationAwareAspectJAutoProxyCreator此类型，简单的来理解下这段代码的逻辑

  • 首先判断我们的registry注册器中是否包含org.springframework.aop.config.internalAutoProxyCreator 类型，很显然代码是不会进if条件的，因为我们是第一次注册，肯定不在的，这里也说明了一点我们要注册的AnnotationAwareAspectJAutoProxyCreator bean的真实类型为 internalAutoProxyCreator ，接着来到else分支，我们接着看：

  • 无非就是注册internalAutoProxyCreator 的bean的定义信息

到这一步我们自定义要创建的bean 【internalAutoProxyCreator 】也就完成了 ,我们也发现目前所有的核心都聚焦在AnnotationAwareAspectJAutoProxyCreator 这个类上，接下来的重点来分析它

AnnotationAwareAspectJAutoProxyCreator

该类位于 org.springframework.aop.aspectj.annotation包下，其继承实现关系如下图所示：

AnnotationAwareAspectJAutoProxyCreator.png

上述就是AnnotationAwareAspectJAutoProxyCreator 的继实现关系图，其中需要我们留意的是接口SmartInstantiationAwareBeanPostProcessor，此接口是一个后置处理器，我们来看下该接口的类图信息：

SmartInstantiationAwareBeanPostProcessor.png

其主要的作用是在Bean的初始化完成前后进行一些额外的操作，这是所有BeanPostProcessor【后置处理器】的作用

  • 不难发现在我们的 AbstractAutoProxyCreator中存在这样一段代码：
public void setBeanFactory(BeanFactory beanFactory) {
    this.beanFactory = beanFactory;
}
  • 在我们的AbstractAdvisorAutoProxyCreator类中同样是有这样一段代码：
 public void setBeanFactory(BeanFactory beanFactory) {
    super.setBeanFactory(beanFactory);
    if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
        throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
    } else {
        this.initBeanFactory((ConfigurableListableBeanFactory)beanFactory);
    }
}

protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    this.advisorRetrievalHelper = new AbstractAdvisorAutoProxyCreator.BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}

这里首先调用的是AbstractAutoProxyCreator #setBeanFactory(...)方法进行赋值

  • 同样在AbstractAutoProxyCreator中有方法#postProcessBeforeInstantiation(...)beanFactory初始化前的处理方法

  • 同样在AbstractAutoProxyCreator中有方法#postProcessAfterInstantiation(...)beanFactory初始化后的处理逻辑

  • 同样在我们的子类AnnotationAwareAspectJAutoProxyCreator中存在初始化beanFactory的#initBeanFactory(...)方法，实际调用AbstractAdvisorAutoProxyCreator#initBeanFactory(...)完成bean的初始化

上述简单叙述了BeanPostProcessor的出现的时机和具体的处理逻辑，在接下来我们来走一遭Spring给我们创建AnnotationAwareAspectJAutoProxyCreator 这个bean的流程

AnnotationAwareAspectJAutoProxyCreator的创建流程

首先来到我们的启动类如下：

//Aop测试
@Test
public void testAop(){
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAop.class);
    MathCalculator calculator = applicationContext.getBean(MathCalculator.class);
    calculator.div(10,5);

    applicationContext.close();
}

全程Dbug走一遭，在我们的AnnotationConfigApplicationContext这一行打上断点，首先会来到类AnnotationConfigApplicationContext中下面方法：

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    this.register(componentClasses);
    this.refresh();
}

其参数为我们的配置类，该方法其主要是帮助我们创建IOC容器和以及注册我们的配置类信息到容器中，最后通过方法refresh()完成对容器的初始化

  • 继续Dbug this.refresh()方法我们来到类AbstractApplicationContext的#refresh()方法，其中有这样一段代码需要我们注意一下：
this.registerBeanPostProcessors(beanFactory);

其主要的作用是通过BeanPostProcessor【后置处理器】的拦截操作方便我们对bean的创建，继续Dbug代码来到当前类AbstractApplicationContext的方法：

 protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
image.png

图中是方法参数的具体类型，从代码的实现我们看到的是调用PostProcessorRegistrationDelegate#registerBeanPostProcessors(...)两个参数方法，继续Dbug来到方法：

  • 一进方法我们发现：
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

上述代码片段主要是通过bean的名称类型来获取当前容器的后置处理器，具体的类型有：

Aop源码分析2.png
  • 接着我们也看到它通过如下代码片段：
beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

继续来到方法#addBeanPostProcessor 中，其主要的是添加一些别的后置处理器，代码片段如下：

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    this.beanPostProcessors.remove(beanPostProcessor);
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }

    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }

    this.beanPostProcessors.add(beanPostProcessor);
}

代码简单这里就不啰嗦了，还是回到我们的上面的核心方法里，期间定义了一些空的集合如：

    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList();
    List<String> orderedPostProcessorNames = new ArrayList();
    List<String> nonOrderedPostProcessorNames = new ArrayList();

接着是for循环 分类处理我们获取到后置处理器，从代码的片段来看：

 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }

这其中优先注册实现了PriorityOrdered这个接口的BeanPostProcessor其次是：

 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }

接着是处理实现了Ordered接口的后置处理器和普通的后置处理器【BeanPostProcessor】,通过for循环的分类处理之后，我们看到如下片段代码：

sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

对这些BeanPostProcessor的后置处理器进行排序，因为每个后置处理器的执行先后是有顺序的，接着看：

registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);

 private static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
    Iterator var2 = postProcessors.iterator();

    while(var2.hasNext()) {
        BeanPostProcessor postProcessor = (BeanPostProcessor)var2.next();
        beanFactory.addBeanPostProcessor(postProcessor);
    }

}

上述代码主要是处理beanFactory类型的后置处理器，具体大家参看接口BeanFactoryPostProcessor，该接口是是Spring中的一个拓展接口，其主要的目的是在beanFactory类型的bean标准初始化之后我们可以定制修改BeanFactory的内容

  • 该接口位于org.springframework.beans.factory.config包下，代码片段如下：
package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

@FunctionalInterface
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

接口中有一个方法需要我们实现可以自定义BeanFactory的内容，还是回到我们的位置上来，接着往下看到如下的代码片段：

  List<BeanPostProcessor> orderedPostProcessors = new ArrayList(orderedPostProcessorNames.size());
    Iterator var14 = orderedPostProcessorNames.iterator();

    while(var14.hasNext()) {
        String ppName = (String)var14.next();
        BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }

上述代码getBean(...)实质上是创建我们对象internalAutoProxyCreator的过程，Dbug截图如下，看了更了然：

image.png

ppName告诉我们是从容器中获取internalAutoProxyCreator bean实例，继续Dbug进去来到类AbstractBeanFactory#getBean(String name, Class<T> requiredType)此方法，代码片段如下：

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return this.doGetBean(name, requiredType, (Object[])null, false);
}
image.png

图中红框里的是参数的具体类型，接着我们看#doGetBean(...)方法，虽然代码很长，但大致意思我们还是可以理解的，这里不在一一去介绍，我们只说关键性的代码片段，这也是阅读源码的一个技巧，没必要要把每一行的代码都理解，只需要大概的明白是干啥的就行，扯远了接着看如下的代码片段：

    String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);

doGetBean方法一进来首先通过#transformedBeanName（...）对我们的bean进行简单的处理，其实就是获取要创建的bean的name,可能有的bean的名字是别名，接着通过name去获取bean实例，很显然第一次是获取不到的，接着进行一系列的判断处理，至于里面的逻辑这里就不提了，不是我们关系的，感兴趣的可以自己Dbug走一圈代码就明白了，下面的代码片段才是我们创建bean的入口：

 if (mbd.isSingleton()) {
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                        return this.createBean(beanName, mbd, args);
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
image.png

也就是我们的createBean(...)方法，我们继续跟踪代码来到类AbstractAutowireCapableBeanFactory中，该类位于org.springframework.beans.factory.support包下，其继承实现关系如下图：

AbstractAutowireCapableBeanFactory.png

这不是重点，我们接着看创建bean的过程，首先我们来看如下的代码片段：

beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse)
image.png

图中所示的是方法参数，其中参数mbdToUse中描述的是当前要创建bean的属性，如是否单例等进去方法我们来到：

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = this.determineTargetType(beanName, mbd);
            if (targetType != null) {
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }

        mbd.beforeInstantiationResolved = bean != null;
    }

    return bean;
}

代码其主要的作用是获取bean实例，当然由于我们才要创建bean，因此此处返回的bean是null的，返回createBean方法，由于通过上述方式我们获取到的bean是null，接着代码会来到如下片段：

  beanInstance = this.doCreateBean(beanName, mbdToUse, args);

上述方法才是我们创建Bean的最后一道工序，继续跟踪代码来到：

 if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

通过上述方法的处理，这里我们拿到了通过包装之后的类型AnnotationAwareAspectJAutoProxyCreator，其真实类型为org.springframework.aop.config.internalAutoProxyCreator

image.png

从上述Dbug的过程来看，是对我们internalAutoProxyCreator这个bean进行了包装，继续跟踪代码：

Object bean = instanceWrapper.getWrappedInstance();
image.png

这个代码片段获取包装的bean实例AnnotationAwareAspectJAutoProxyCreator的一些属性，接着跟踪代码：

this.populateBean(beanName, mbd, instanceWrapper);

上述代码片段主要是给我们要创建的bean进行属性的装备过程至于方法具体的逻辑这里不在细看，感兴趣的自己可以去看看，当我们bean的属性装配完成之后进行我们bean的实例化过程，代码片段如下：

exposedObject = this.initializeBean(beanName, exposedObject, mbd);

继续跟踪代码来到方法#initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) ，在方法中首先通过如下代码片段：

this.invokeAwareMethods(beanName, bean);

通过方法来处理实现了Aware接口的bean，具体实现如下：

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware)bean).setBeanName(beanName);
        }

        if (bean instanceof BeanClassLoaderAware) {
            ClassLoader bcl = this.getBeanClassLoader();
            if (bcl != null) {
                ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
            }
        }

        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware)bean).setBeanFactory(this);
        }
    }

}

代码简单就不在啰嗦了，接着来到如下的代码的片段：

   Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }

此方法之前我们也提过，主要是在bean初始化之前来进行一些操作的，继续跟踪代码来到：

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;

    Object current;
    for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
        BeanPostProcessor processor = (BeanPostProcessor)var4.next();
        current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
    }

    return result;
}

上述这段代码处理的逻辑是这样的，获取当前所有的BeanPostProcessor，然后调用#postProcessBeforeInitialization(...)进行相关逻辑的处理

图中看到的 是当前拿到的后置处理器和容器中的bean，具体干了什么我们进去看看次方法：

@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if (!(bean instanceof EnvironmentAware) && !(bean instanceof EmbeddedValueResolverAware) && !(bean instanceof ResourceLoaderAware) && !(bean instanceof ApplicationEventPublisherAware) && !(bean instanceof MessageSourceAware) && !(bean instanceof ApplicationContextAware)) {
        return bean;
    } else {
        AccessControlContext acc = null;
        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareInterfaces(bean);
                return null;
            }, acc);
        } else {
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }
}
image.png

上述在bean初始化之前操作完成时，接着来到：

 this.invokeInitMethods(beanName, wrappedBean, mbd);

通过此方法执行bean的初始化操作

image.png

最后通过如下方法：

  if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

在bean初始化完成之后通过调用#applyBeanPostProcessorsAfterInitialization(...)方法进行其他操作，继续跟踪代码来到：

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;

    Object current;
    for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
        BeanPostProcessor processor = (BeanPostProcessor)var4.next();
        current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
    }

    return result;
}

我们可以发现的是还是先获取所有的后置处理器，然后遍历调用#postProcessAfterInitialization(....)方法去完成

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

最后发现后置处理器直接将创建的bean给我们返回到容器中，也就是我们的AnnotationAwareAspectJAutoProxyCreator这个bean完成了真正的创建，最后我们来到类：PostProcessorRegistrationDelegate中的#registerBeanPostProcessors(...)方法的代码片段：

 registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

通过方法 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext))将我们的创建的AnnotationAwareAspectJAutoProxyCreator 添加到beanFactory中，继续跟踪代码来到：

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    this.beanPostProcessors.remove(beanPostProcessor);
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        this.hasInstantiationAwareBeanPostProcessors = true;
    }

    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        this.hasDestructionAwareBeanPostProcessors = true;
    }

    this.beanPostProcessors.add(beanPostProcessor);
}
image.png

到这里我们的AnnotationAwareAspectJAutoProxyCreator 完成了注册和创建过程

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,001评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,210评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 161,874评论 0赞 351
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,001评论 1赞 291
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,022评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,005评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,929评论 3赞 416
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,742评论 0赞 271
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,193评论 1赞 309
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,427评论 2赞 331
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,583评论 1赞 346
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,305评论 5赞 342
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,911评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,564评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,731评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,581评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,478评论 2赞 352