回顾
- 上一章节主要介绍了启动 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 和 动态代理对象的。