【阅读前提】： 需了解AOP注解开发流程：链接

一、注解 @EnableAspectJAutoProxy

在配置类中添加注解@EnableAspectJAutoProxy，便开启了AOP（面向切面编程） 功能。此注解也是了解AOP源码的入口。

@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {

【1】@EnableAspectJAutoProxy是什么？我们进入注解，查看其源码如下：发现调用EnableAspectJAutoProxy类，同时使用 @Import注解向容器中导入 AspectJAutoProxyRegistrar 组件：作用是给容器中注册自定义的Bean。

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

【2】进入AspectJAutoProxyRegistrar类，调用registerBeanDefinitions中的register...Necessary方法注册组件。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
             //向容器（registry）中注入组件	
             AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

【3】 进入register...Necessary方法，通过源码分析：该方法向容器中注册一个AnnotationAwareAspectJAutoProxyCreator（支持注解模式的面向切面自动代理创建器）组件，其名称为internalAutoProxyCreator。需要注意的是其注册的是一个BeanDefinition（Bean的定义信息，并没有实例化。后续分析时会说到） 。

//debug 进来后，发现cls参数的值等于 AnnotationAwareAspectJAutoProxyCreator 这个参数也是直接写死的，如下：。
//registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
		Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	//AUTO_PROXY_CREATOR_BEAN_NAME == internalAutoProxyCreator 
	//因第一次进来，所以容器中不存在 internalAutoProxyCreator 
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		return null;
	}
	//创建一个新的对象封装 cls
	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	//将封装的cls对象注册到容器中，并将名称定义为AUTO_PROXY_CREATOR_BEAN_NAME == internalAutoProxyCreator 就上上述判断的语句。
	//此时我们就应该分析 AnnotationAwareAspectJAutoProxyCreator对象的作用
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}

二、研究AnnotationAwareAspectJAutoProxyCreator

此自动代理创建器的内部功能，其等价于AOP的主要功能。 此类的继承结构如下：

我们进入自动代理的抽象父类AbstractAutoProxyCreator中发现，其实现了SmartInstantiationAwareBeanPostProcessor后置处理器（在bean初始化前后做一些操作，AOP的特点）和BeanFactoryAware自动装配BeanFactory。

@SuppressWarnings("serial")
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

AOP原理分析技巧：【看给容器中注册了什么组件， 这个组件什么时候工作，这个组件的功能是什么？】，研究透这些，原理也就清楚了。

我们从AbstractAutoProxyCreator父类向AnnotationAwareAspectJAutoProxyCreator子类的顺序，查看其内部关于后置处理器和自动装备的方法并加入断点：

【1】AbstractAutoProxyCreator：包含后置处理器前后的两个方法和自动装配的方法。

//后置处理器相关的方法1
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
	Object cacheKey = getCacheKey(beanClass, beanName);
	if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
		if (this.advisedBeans.containsKey(cacheKey)) {
			return null;
		}
		if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return null;
		}
	}
//后置处理器相关的方法2
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	if (bean != null) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
			return wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}
//自动装备相关的方法
@Override
public void setBeanFactory(BeanFactory beanFactory) {
	this.beanFactory = beanFactory;
}

【2】AbstractAdvisorAutoProxyCreator：重写了setBeanFactory方法。

//自动装备方法
@Override
public void setBeanFactory(BeanFactory beanFactory) {
	super.setBeanFactory(beanFactory);
	if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
		throw new IllegalArgumentException(
				"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
	}
	initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}

【3】对 2中的initBeanFactory方法进行了重写。

@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	super.initBeanFactory(beanFactory);
	if (this.aspectJAdvisorFactory == null) {
		this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
	}
	this.aspectJAdvisorsBuilder =
			new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}

三、Debug 测试类流程梳理

【1】创建 IOC 容器，传入主配置类MainConfigOfAOP

//获取容器中的类
ApplicationContext ApplicationContext = 
                                    new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

【2】调用AnnotationConfigApplicationContext构造器：注册配置类和刷新容器（创建容器中的所有Bean，类似于初始化容器）

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
        //创建对象
	this();
        //注册配置类
	register(annotatedClasses);
        //刷新容器
	refresh();
}

【3】调用refresh方法：主要查看registerBeanPostProcessors(beanFactory); 方法，其作用是注册bean后置处理器，用方便来拦截bean的创建。

@Override
public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
        ....
	// 注册 bean 后置处理器，用来拦截 bean 的创建
	registerBeanPostProcessors(beanFactory);
        ....
}

【4】进入registerBeanPostProcessors调用的方法：先获取 IOC 容器中已经定义了的需要创建对象的所有后置处理器BeanPostProcessor（已定义：指我们在解析配置类的时候@EnableAspectJAutoProxy会为我们注册一个AnnotationAwareAspectJAutoProxyCreator后置处理器的定义，包括默认的一些后置处理器的定义）例如：

上述列表中的internalAutoProxyCreator后置处理器，就是我们分析@EnableAspectJAutoProxy时注入的那个处理器。后置处理的注册分为以下三种情况：

 ■ 优先注册实现了PriorityOrdered（优先级）接口的BeanPostProcessors；

 ■ 其次注册实现了Ordered接口的BeanPostProcessors；

 ■ 注册所有常规Beanpstprocessors；

internalAutoProxyCreator后置处理器实现了Ordered接口。分析代码可知：【根据bean定义名称internalAutoProxyCreator从beanFactory中获取注入的后置处理器】调用的方法 = beanFactory.getBean(ppName, BeanPostProcessor.class);

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    //获取ioc容器中已经定义了的需要创建对象的所有 BeanPostProcessor
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    //也会注意一些其他后置处理器，bean 是在 beanPostProcessor 实例化期间创建的，即 bean 不适合由所有 beanPostProcessors 处理。这个其实不重要，可以省略...
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 +    postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    //判断哪些后置处理器配置了优先级
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
	    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
	    priorityOrderedPostProcessors.add(pp);
	    if (pp instanceof MergedBeanDefinitionPostProcessor) {
	        internalPostProcessors.add(pp);
	    }
	}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
	    orderedPostProcessorNames.add(ppName);
	}else {
	    nonOrderedPostProcessorNames.add(ppName);
	}
    }
    // 优先注册实现了 PriorityOrdered（优先级） 的 BeanPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    // 其次注册实现了Ordered 接口的 BeanPostProcessors.
    List orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        //根据 bean定义的名称internalAutoProxyCreator 从 beanFactory 中获取注入的后置处理器
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
	orderedPostProcessors.add(pp);
	if (pp instanceof MergedBeanDefinitionPostProcessor) {
	    internalPostProcessors.add(pp);
	}
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    // 注册所有常规beanpstprocessors。
    List nonOrderedPostProcessors = new ArrayList<>();
        for (String ppName : nonOrderedPostProcessorNames) {
	    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
	    nonOrderedPostProcessors.add(pp);
	    if (pp instanceof MergedBeanDefinitionPostProcessor) {
	        internalPostProcessors.add(pp);
	    }
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    // 最后，重新注册所有内部beanpstprocessors。
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

【5】进入上述所说的beanFactory.getBean(ppName, BeanPostProcessor.class); 方法如下：因第一次进入容器，因此获取不到实例。会通过 getSingleton方法创建BeanPostProcessor的实例，并保存到容器中。

@Override
public  T getBean(String name, Class requiredType) throws BeansException {
	return doGetBean(name, requiredType, null, false);
}
//上述方法内部调用的是 doGetBean(name, requiredType, null, false); 代码如下：
@SuppressWarnings("unchecked")
protected  T doGetBean(final String name, @Nullable final Class requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //因为第一次获取，容器中不存在此实例。因此 sharedInstance==null
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
        ...
        }else {
	    // 创建 bean 实例
	    if (mbd.isSingleton()) {
	        sharedInstance = getSingleton(beanName, () -> {
	        try {
		    return createBean(beanName, mbd, args);
	        }catch (BeansException ex) {
		    destroySingleton(beanName);
		    throw ex;
	        }
	    });
	    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	    }
    }

【6】创建internalAutoProxyCreator的AnnotationAwareAspectJAutoProxyCreator实例。步骤如下：

//1、创建bean的实例
createBean(beanName, mbd, args);
//2、给Bean 的各属性赋值
populateBean(beanName, mbd, instanceWrapper);
//3、初始化 bean ，比较重要，因为后置处理器就是在此前后进行工作的
exposedObject = initializeBean(beanName, exposedObject, mbd);

【7】重点是：初始化initializeBean方法，查看实现的步骤如下：

//1、调用 invokeAwareMethods 处理Aware 接口的方法回调，beanName=internalAutoProxyCreator 实现了 BeanAware 接口
invokeAwareMethods(beanName, bean);
//2、应用后置处理器 BeforeInitialization
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//3、执行自定义的初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
//4、执行后置处理器的 After方法
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
//下面是上述方法的具体实现
//1、invokeAwareMethods 实现如下：
private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
                //.....
                //实现了 BeanFactoryAware 接口，因此执行 setBeanFactory.
                //bean==AnnotationAwareAspectJAutoProxyCreator
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}
//2、applyBeanPostProcessorsBeforeInitialization 实现如下：
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
    throws BeansException {
	Object result = existingBean;
        //获取所有的后置处理器，执行前置Before 处理器。
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}
//3、invokeInitMethods 方法的具体实现
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
		throws Throwable {
	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isTraceEnabled()) {
			logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction