文章目录
- BeanPostProcessors
- 1. BeanPostProcessors 注册( registerBeanPostProcessors(beanFactory);方法)
- 2. BeanPostProcessors 调用( registerBeanPostProcessors(beanFactory);方法)
- 2.1 第一次调用(实例化之前)调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法。
- 2.2 第二次调用(实例化之前,选择构造方法)调用SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors方法。
- 2.3 第三次调用(实例后之后,属性注入之前)调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition方法。
- 2.4 第四次调用(实例后之后,属性注入之前)调用org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference方法。
- 2.5 第五次调用(实例后之后,属性注入之前)调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法。
- 2.6 第六次调用(可以进行属性的注入)调用InstantiationAwareBeanPostProcessor.postProcessProperties或者postProcessPropertyValues(已过时)方法。
- 2.7 第七次调用(属性注入后,初始化之前)调用BeanPostProcessor.postProcessBeforeInitialization。
- 2.8 第八次调用(初始化之后)调用BeanPostProcessor.postProcessAfterInitialization。
BeanPostProcessors
bean的后置处理器
1. BeanPostProcessors 注册( registerBeanPostProcessors(beanFactory);方法)
在refresh()的 invokeBeanFactoryPostProcessors(beanFactory)中;所有的bean已经被注册到BeanDefintionMap中,但是只有BeanFactory的后置处理器进行了对象创建的工作。bean的后置处理器还没有进行。所有在registerBeanPostProcessors(beanFactory);中完成bean的后置处理器的对象创建工作。 Bean的后置处理器也分为两种:一种是Spring自带的后置处理器,一种是我们自定义的后置处理器
查看registerBeanPostProcessors(beanFactory);方法
// 这个方法开始注册后置处理器
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 根据接口类型获取全部的bean后置处理器的名称。
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 此处可以看出支持排序,创建几个排序集合。用于装不同顺序的beanpost的后置处理器。跟BeanFactoryPost的后置处理器一样。
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 此处创建的内部bean的后置处理器集合。专门用于存放MergedBeanDefinitionPostProcessor的。
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 也是排序集合
List<String> orderedPostProcessorNames = new ArrayList<>();
// 也是排序集合
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 编译全部。
for (String ppName : postProcessorNames) {
// // 先遍历,找出优先级最高的,实现PriorityOrdered.class接口的。
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 创建对象。
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 添加到此集合中
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 实现Ordered.class接口的,优先级第二。
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 添加到此集合中,但是不创建对象。
orderedPostProcessorNames.add(ppName);
}
else {
// 没有实现排序接口的最后添加到此集合中,,但是不创建对象。
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先进行排序工作。针对实现了PriorityOrdered接口的,优先级最高的。
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 优先注册PriorityOrdered接口的实现类。其实就是添加到beanPostProcessors中。
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 接下来针对实现了Ordered接口的进行对象的创建工作。
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
// 如果有实现MergedBeanDefinitionPostProcessor这个接口的,添加到internalPostProcessors这个集合中。
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 排序。
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注册.
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 最后创建没有排序的bean的后置处理器对象。。
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
// 如果有实现MergedBeanDefinitionPostProcessor这个接口的,添加到internalPostProcessors这个集合中。
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 注册
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 最后排序internal BeanPostProcessors集合注册
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 添加一个ApplicationListenerDetector后置处理器。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
通过以上代码可以看出,主要的逻辑是创建了bean的后置处理器对象,然后添加到beanPostProcessorsMap集合中。当然也支持排序接口。
2. BeanPostProcessors 调用( registerBeanPostProcessors(beanFactory);方法)
Spring在创建对象的时候经理了三次过程,实例化,属性赋值,初始化,针对每一次过程都有处理器来进行处理。
2.1 第一次调用(实例化之前)调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法。
在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation 方法中。
此方法传入的参数为Class<?> beanClass, String beanName 。返回值bean,说明此时bean还没有被创建出来。如果我们实现了这个接口交给我自己来创建bean。如果我们创建了bean,后续针对bean的一切行为都终止。并且直接调用bean初始化后置处理器,说明实现此接口,bean的生命周期全盘由我们来控制
2.2 第二次调用(实例化之前,选择构造方法)调用SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors方法。
在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 方法中。
此方法参数为Class<?> beanClass, String beanName,返回值为Constructor<?>[]
此时代码已经进去到开始实例化对象的逻辑中了。既然是实例化对象,肯定要确认构造方法。此接口就是让我们自己来确定实例化对象执行的构造方法。不回去影响后续的调用
2.3 第三次调用(实例后之后,属性注入之前)调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition方法。
在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean 方法中。
参数为 RootBeanDefinition beanDefinition, Class<?> beanType, String beanName 。无返回值。此方法的作用就是在实例化之后,属性注入之前针对BeanDefinition进行一些定制化的修改
2.4 第四次调用(实例后之后,属性注入之前)调用org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference方法。
在 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法中。
参数为 Object bean, String beanName 返回值为Object,此方法主要值解决循环依赖的问题,同样是在属性注入之前
2.5 第五次调用(实例后之后,属性注入之前)调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation方法。
在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean 方法中。
参数为Object bean, String beanName,返回值boolean。此方法的返回值可以选择当前的对象是否需要注入,或者根据条件觉得是否需要注入?
2.6 第六次调用(可以进行属性的注入)调用InstantiationAwareBeanPostProcessor.postProcessProperties或者postProcessPropertyValues(已过时)方法。
在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean 方法中。
参数PropertyValues pvs, Object bean, String beanName ,返回值PropertyValues。在这里进行属性的注入
2.7 第七次调用(属性注入后,初始化之前)调用BeanPostProcessor.postProcessBeforeInitialization。
在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) 方法中。
参数 Object bean, String beanName,返回值Object。此方法是在放在执行初始化函数的时候,针对对象进行修改,如果返回的null,后续的方法调用就不会走了
2.8 第八次调用(初始化之后)调用BeanPostProcessor.postProcessAfterInitialization。
在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)方法中。
参数Object bean, String beanName,此方法是在调用初始化之后进针对对象进行一些操作