java 后端 面试 职场和发展 性能优化 spring boot Spring AOP 源码分析

【阅读前提】： 需了解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