Spring AOP 动态代理创建器（AnnotationAwareAspectJAutoProxyCreator）

最新推荐文章于 2021-07-25 14:20:34 发布

wyfvsfy

最新推荐文章于 2021-07-25 14:20:34 发布

阅读量556

点赞数 1

分类专栏： Spring

本文链接：https://blog.csdn.net/wyfvsfy/article/details/95179785

版权

Spring 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

回顾

上一章节主要介绍了启动 Spring AOP 的入口是从 @EnableAspectJAutoProxy 这个注解开始的。
其最终目的是为了将 beanId 为 “org.springframework.aop.config.internalAutoProxyCreator” 对应的
Bean（AnnotationAwareAspectJAutoProxyCreator ）注册到 BeanFactory 中。
而这仅是完成了动态代理创建器（AnnotationAwareAspectJAutoProxyCreator）的注册部分，接下来将分析 AnnotationAwareAspectJAutoProxyCreator 的创建和初始化的源码。

1.1 AnnotationAwareAspectJAutoProxyCreator 继承结构图

主要关注以下三个接口

InstantiationAwareBeanPostProcessor 接口：后置处理器（BeanPostProcessor）。
BeanFactoryAware ：可以从容器中获取 BeanFactory 对象
Ordered ：优先被容器注册，优先级仅次于PriorityOrdered

1.2 BeanPostProcessor 注册流程

所有的Bean的创建都从 AbstractApplicationContext.refresh() 方法开始的。

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

在 refresh() 方法中我们关注以下两个方法：

registerBeanPostProcessors(beanFactory) 实例化所有已经注册到BeanFactory中的BeanPostProcessor。
finishBeanFactoryInitialization(beanFactory) 实例化所有单例对象。

从这两个方法的顺序可以看到，BeanPostProcessor 是在普通 Bean 之前实例化的。这就意味着，普通Bean 在初始化的过程中会被各种 BeanPostProcessor 进行拦截。

由于 AnnotationAwareAspectJAutoProxyCreator 也是 BeanPostProcessor，所以它的实例化过程在 registerBeanPostProcessors(beanFactory) 方法中进行。

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			finishRefresh();
       }
   //省略部分代码

AbstractApplicationContext.registerBeanPostProcessors（）
从下面代码可看出 BeanPostProcessors 实例化的过程，使用代理模式委托给PostProcessorRegistrationDelegate.registerBeanPostProcessors（）代为处理的。

	/**
	 * Instantiate and invoke all registered BeanPostProcessor beans,
	 * respecting explicit order if given.
	 * <p>Must be called before any instantiation of application beans.
	 */
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

PostProcessorRegistrationDelegate.registerBeanPostProcessors（）这个方法是注册BeanPostProcessor 核心流程

首先在容器中注册一个BeanPostProcessorChecker，这个只是用来对在bean不适合所有的BeanPostProcessor调用的情况下，打印一些日志信息。
先注册实现了PriorityOrdered接口的BeanPostProcessor，再注册实现了Ordered接口的的BeanPostProcessor，然后注册没实现优先级接口的BeanPostProcessor，最后注册实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor。
注册ApplicationListenerDetector。用来检测bean是否是ApplicationListener，如果是判断是否是单例，如果不是单例，那么删除singtonNames中对应的key。

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

            //1.取得所有的bean后置处理器名称
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
  
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
  
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  
            //2. 将BeanPostProcessors分为实现了PriorityOrdered，Ordered和常规的类型
		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);
			}
		}

           //3. 首先，注册实现了PriorityOrdered接口的BeanPostProcessors
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		//4. 其次，注册实现了Ordered的BeanPostProcessors
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		 //5. 再次，注册所有常规的BeanPostProcessors
		List<BeanPostProcessor> 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);
            
            //6. 然后，注册所有的internal，也就是实现MergedBeanDefinitionPostProcessor的BeanPostProcessors
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		//7. 最后，注册ApplicationListenerDetector
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

通过这个方法 beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false) 获取的四个 BeanPostProcessor。按照上面的流程先排序然后创建。
在这里插入图片描述

1.3 AnnotationAwareAspectJAutoProxyCreator 的创建

由于 AnnotationAwareAspectJAutoProxyCreator 实现了Ordered 接口，所以 AnnotationAwareAspectJAutoProxyCreator 创建优先级排在 PriorityOrdered 接口实现类之后，实例化过程在 beanFactory.getBean() 中进行。
如下图所示：
在这里插入图片描述
AbstractBeanFactory.getBean() 执行到这个方法之后的流程就和普通的单例 Bean 的创建流程一样了。

@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
}

AbstractBeanFactory.doGetBean() 在这个方法中只需关注这段代码，最后执行 createBean() 这个方法。

// Create bean instance.
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

下面则是代码调用过程的截图，AnnotationAwareAspectJAutoProxyCreator 实例是通过反射 Constructor.newInstance() 进行创建。
在这里插入图片描述
图（1.3.1）

AbstractAutowireCapableBeanFactory.doCreateBean()
在这里插入图片描述
图（1.3.2）

在这里插入图片描述
图（1.3.3）

在这里插入图片描述
图（1.3.4）

在这里插入图片描述
图（1.3.5）

在这里插入图片描述
图（1.3.6）

1.4 AnnotationAwareAspectJAutoProxyCreator 的初始化

AnnotationAwareAspectJAutoProxyCreator 的初始化主要做的主要就是 aware 的赋值操作。

initializeBean() 方法的操作流程：

由于实现 BeanFactoryAware和BeanClassLoaderAware，所以需要执行 aware 的赋值操作。
执行后置处理器 applyBeanPostProcessorsBeforeInitialization ，这一步其他的 BeanPostProcessor 没有做任何操作。
调用 AnnotationAwareAspectJAutoProxyCreator 初始化方法，由于没有配置初始化方法，所以此处也没有做任何操作。
执行后置处理器 applyBeanPostProcessorsAfterInitialization，这一步其他的 BeanPostProcessor 也没有做任何操作。

1.4.1 AbstractAutowireCapableBeanFactory.doCreateBean（）功能总结

这个方法在创建 Bean 的过程中有三个重要操作：

createBeanInstance ：创建 Bean 实例
populateBean ：实现 Bean 属性的依赖注入。
initializeBean ：对创建后 Bean 进行初始化。

由于 AnnotationAwareAspectJAutoProxyCreator 类在 populateBean 方法中并没有任何属性需要依赖注入，所以我们只关心 initializeBean 这个方法。
在这里插入图片描述图（1.4.1）

1.4.2 initializeBean() 方法的代码分析

invokeAwareMethods() ，这个方法是对实现 aware 接口的类进行相关赋值操作。

从的结构图中可以看出 AnnotationAwareAspectJAutoProxyCreator 实现了 BeanFactoryAware 和 BeanClassLoaderAware 接口。

所以，这个方法就是将 BeanFactory 对象和 ClassLoader 对象赋值给 AnnotationAwareAspectJAutoProxyCreator 继承父类的属性上。
在这里插入图片描述
图（1.4.2.1）

DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory.invokeAwareMethods
在这里插入图片描述
图（1.4.2.2）

1.5 总结

到此为止，我们已经对 AnnotationAwareAspectJAutoProxyCreator 这个类的注册、创建和初始化进行了分析。
AnnotationAwareAspectJAutoProxyCreator

@EnableAspectJAutoProxy 注解中完成注册
由于继承了 BeanPostProcessor 这个接口，所以创建和初始化都是在普通Bean创建之前完成。
作为后置处理器，将在普通 Bean 执行创建和初始化过程中进行拦截，主要在 postProcessBeforeInstantiation 方法中进行创建 Advisors 和在 postProcessAfterInitialization 方法中获取增强器并创建动态代理。
所以，接下来将分析 AnnotationAwareAspectJAutoProxyCreator 这个类是如何创建增强器 Advisor 和动态代理对象的。

wyfvsfy

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring AOP 动态代理创建器（AnnotationAwareAspectJAutoProxyCreator）

回顾上一章节主要介绍了启动 Spring AOP 的入口是从 @EnableAspectJAutoProxy 这个注解开始的。其最终目的是为了将 beanId 为 “org.springframework.aop.config.internalAutoProxyCreator” 对应的Bean（AnnotationAwareAspectJAutoProxyCreator ）注册到 Bea...
复制链接

扫一扫

专栏目录