Spring注解驱动之AnnotationAwareAspectJAutoProxyCreator详解（一）

概述

要想知道AOP的原理，只需要搞清楚@EnableAspectJAutoProxy注解给容器中注册了什么组件，这个组件什么时候工作以及这个组件工作时候的功能是什么就行了，一旦把这个研究透了，那么AOP的原理我们就清楚了。
AnnotationAwareAspectJAutoProxyCreator的核心继承关系。

AnnotationAwareAspectJAutoProxyCreator
    ->AspectJAwareAdvisorAutoProxyCreator（父类）
        ->AbstractAdvisorAutoProxyCreator（父类）
            ->AbstractAutoProxyCreator（父类）
                implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware（两个接口）
1
2
3
4
5

通过以上继承关系，我们也知道了，它最终会实现两个接口，分别是：

• BeanPostProcessor：后置处理器，即在bean初始化完成前后做些事情。
• BeanFactoryAware：自动注入BeanFactory。

Spring怎么通过@EnableAspectJAutoProxy注解注册AnnotationAwareAspectJAutoProxyCreator组件

@EnableAspectJAutoProxy通过@Import注解注册bean，核心代码如下。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }

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

        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我这registerBeanDefinitions打上断点。

分析调用源码

入口方法。

public class AnnotationTest {
    public static void main(String[] args) {
        final AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
        MathCalculator bean = applicationContext.getBean(MathCalculator.class);
        bean.div(10, 1);
    }
}
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        this.register(annotatedClasses);
        this.refresh();
    }
1
2
3
4
5
6
7
8
9
10
11
12

新建AnnotationConfigApplicationContext对象的时候，调用this.refresh()方法。
调用链如下：

refresh();
-> this.invokeBeanFactoryPostProcessors(beanFactory);
-> invokeBeanDefinitionRegistryPostProcessors();
// 调用配置类后置处理器的后置处理bean定义注册器方法
-> org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry();
-> org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions();
-> org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions();
// configClass.getImportBeanDefinitionRegistrars()获取MainConfigOfAOP配置类上的注册器
-> this.loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
// 最终调用@Import({AspectJAutoProxyRegistrar.class})的registerBeanDefinitions方法，注册AnnotationAwareAspectJAutoProxyCreator组件
-> org.springframework.context.annotation.AspectJAutoProxyRegistrar#registerBeanDefinitions();
1
2
3
4
5
6
7
8
9
10
11

注册bean的伪代码

private static BeanDefinition registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, BeanDefinitionRegistry registry, Object source) {
  RootBeanDefinition beanDefinition = new RootBeanDefinition(AnnotationAwareAspectJAutoProxyCreator.class);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", -2147483648);
            beanDefinition.setRole(2);
            registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
            return beanDefinition;
    }
1
2
3
4
5
6
7
8

在AnnotationAwareAspectJAutoProxyCreator相关方法上打断点

接下来，我们就要为AnnotationAwareAspectJAutoProxyCreator这个组件里面和后置处理器以及Aware接口有关的方法都打上断点，看下它们何时运行、做了什么事。
继承关系还是比较复杂的。

AnnotationAwareAspectJAutoProxyCreator
    ->AspectJAwareAdvisorAutoProxyCreator（父类）
        ->AbstractAdvisorAutoProxyCreator（父类）
            ->AbstractAutoProxyCreator（父类）
                implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware（两个接口）
1
2
3
4
5

我们先从AbstractAutoProxyCreator这个抽象类开始分析。
我们找到该抽象类，并在里面查找与Aware接口以及BeanPostProcessor接口有关的方法，结果都是可以找到的。该抽象类中的setBeanFactory()方法就是与Aware接口有关的，因此我们将断点打在该方法上，如下图所示。

此外，我们还得找到该抽象类中与BeanPostProcessor接口有关的方法，即只要发现有与后置处理器相关的逻辑，就给所有与后置处理器有关的逻辑都打上断点。打的断点有两处，一处是在postProcessBeforeInstantiation()方法上，如下图所示。

一处是在postProcessAfterInitialization()方法上，如下图所示。

接下来，我们再来看它的子类（即AbstractAdvisorAutoProxyCreator） 。
在该抽象类中，我们只能找到一个与Aware接口有关的方法，即setBeanFactory()方法，虽然父类有setBeanFactory()方法，但是在这个子类里面已经把它重写了，因此最终调用的应该就是它。

大家注意，在重写的时候，在setBeanFactory()方法里面会调用一个initBeanFactory()方法。除此之外，该抽象类中就没有跟后置处理器有关的方法了。
接下来，我们就应该来看AspectJAwareAdvisorAutoProxyCreator这个类了，但由于这个类里面没有跟BeanPostProcessor接口有关的方法，所以我们就不必看这个类了，略过。
接下来，我们就要来看最顶层的类了，即AnnotationAwareAspectJAutoProxyCreator。查看该类时，发现有这样一个initBeanFactory()方法，我们在该方法上打上一个断点就好，如下图所示。

父类调用initBeanFactory()方法，虽然父类里面有写，但是又被它的子类给重写了，所以说相当于父类中的setBeanFactory()方法还是得调用它。
那在该类中还有没有跟后置处理器有关的方法呢？没有了。
综上，我们通过简单的人工分析，为这个AnnotationAwareAspectJAutoProxyCreator类中有关后置处理器以及自动装配BeanFactoryAware接口的这些方法都打上了一些断点，接下来，我们就要来进行debug调试分析了。
不过在这之前，我们还得为MainConfigOfAOP配置类中的如下两个方法打上断点。

然后，我们就可以正式以debug模式来运行IOCTest_AOP测试类了，顺便分析一下整个流程。

参考

Spring注解驱动开发第27讲——为AnnotationAwareAspectJAutoProxyCreator组件里面和后置处理器以及Aware接口有关的方法打上断点