目录
1、invokeBeanFactoryPostProcessors
2)、ApplicationListenerDetector
2、MergedBeanDefinitionPostProcessor
3、DestructionAwareBeanPostProcessor
1、invokeBeanFactoryPostProcessors
Spring允许在Bean的生命周期调用BeanPostProcessor回调方法,也允许在Spring容器生命周期内回调BeanFactoryPostProcessor的postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)方法,BeanDefinitionRegistryPostProcessor也是继承自BeanFactoryPostProcessor并且新定义了接口postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry),允许回调时处理已经注册好的beanDefinition信息。并且按照是否实现了PriorityOrdered或Ordered或未实现排序接口等六种情况进行处理回调对应的方法。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory,
getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
对上面六种情况,即九种接口进行回调后,再进行织入的处理。之前以为Spring项目肯定会写的很怎么样,但是看到这个方法懵逼了很久,原来也写这么长的方法。首先,getBeanFactoryPostProcessors是调用AbstractApplicationContext的beanFactoryPostProcessors容器,是硬编码(通过方法addBeanFactoryPostProcessor)添加到容器中的。比如Spring Boot项目在启动之前就会往里面添加:
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// BeanDefinitionRegistryPostProcessors类型容器
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 遍历通过addBeanFactoryPostProcessor方法硬编码添加的BeanFactoryPostProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// BeanDefinitionRegistryPostProcessor类型,需要回调两个接口
// (postProcessBeanDefinitionRegistry)
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
// 普通类型的BeanFactoryPostProcessor只回调接口 postProcessBeanFactory 即可
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 处理BeanDefinitionRegistryPostProcessors类型并且实现了PriorityOrdered接口
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,
true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 实现了PriorityOrdered或者Ordered都需要进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 遍历,回调BeanDefinitionRegistryPostProcessors的
// postProcessBeanDefinitionRegistry接口
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 处理BeanDefinitionRegistryPostProcessors实现了Ordered接口
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 还是排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 回调postProcessBeanDefinitionRegistry接口
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 实现了BeanDefinitionRegistryPostProcessors但是没有实现排序接口的所有
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 下面处理只实现了BeanFactoryPostProcessor接口的实现
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 同样还是按照是否实现了PriorityOrdered接口、或者Ordered接口, 为实现排序接口
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 处理实现PriorityOrdered接口的
// 排序再回调
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 处理实现Ordered接口的.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 排序再回调
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后处理所以为实现排序的BeanFactoryPostProcessors
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 不进行排序直接回调
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
过程其实没那么复杂,只是都写到同一个方法中了,里面用到了几个通用的方法。最主要的是回调invokeBeanDefinitionRegistryPostProcessors方法时候,ConfigurationClassPostProcessor类型的BeanDefinitionRegistryPostProcessor,在调用processConfigBeanDefinitions时候,对@Bean、@Component、@PropertySources、@ComponentScans、@ComponentScan、ImportResource接口等进行了实现。后面详解
2、registerBeanPostProcessors
实现了BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor的在上面就进行了回调。属于Spring容器级别的。而下面处理的是实现了BeanPostProcessor接口的,这里仅仅是进行注入到容器中,到后面每个Bean进行getBean时在生命周期中会进行回调。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
同样是委派给PostProcessorRegistrationDelegate进行实现
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取BeanPostProcessor类型
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 由于之前分析过,BeanFactory中有接口是关于注册的个数,所以需要进行计数
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 同样处理BeanPostProcessor还是按照是否实现PriorityOrdered,Ordered或者为实现排序
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
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类型,先排序再注册到AbstractBeanFactory的addBeanPostProcessor方法进行注册
// 添加到beanPostProcessors容器中
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 同样方式处理实现了Ordered接口的,先排序再添加到容器
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
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);
// 处理其余没有实现排序接口的BeanPostProcessors
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
// 处理实现了MergedBeanDefinitionPostProcessor类型
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后对MergedBeanDefinitionPostProcessor类型进行排序和注册,如果之前注册过
// 会进行先移除再注册,在sortPostProcessors中实现
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 添加一个监听探测器ApplicationListenerDetector
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
1)、registerBeanPostProcessors
注册BeanPostProcessor类型,分为是否集中情况进行处理
- 实现了PriorityOrdered接口(先排序再注册)
- 实现了Ordered接口(先排序再注册)
- MergedBeanDefinitionPostProcessor类型(同样先排序再注册)
- 最后为普通BeanPostProcessor直接进行注册
2)、ApplicationListenerDetector
是实现事件发送(详细参见Spring源码-事件监听机制(实现EventListener接口))很重要的一步,当然这里只是注册BeanPostProcess,调用还是在refresh的最后一步,将所有非懒加载的单利Bean初始化,则会回调该容器。结构如下:
class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {
private final transient AbstractApplicationContext applicationContext;
private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);
}
一个存储单利Bean的容器,实现了DestructionAwareBeanPostProcessor和MergedBeanDefinitionPostProcessor接口,并且顶级父类是BeanPostProcessor。
1、BeanPostProcessor
实现了postProcessAfterInitialization接口,那么在refresh在最后阶段会对非懒加载的所有单利Bean进行,getBean操作,则会回调该方法:
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof ApplicationListener) {
// potentially not detected as a listener by getBeanNamesForType retrieval
Boolean flag = this.singletonNames.get(beanName);
if (Boolean.TRUE.equals(flag)) {
// singleton bean (top-level or inner): register on the fly
this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
}
else if (Boolean.FALSE.equals(flag)) {
this.singletonNames.remove(beanName);
}
}
return bean;
}
逻辑比较简单,先判断是否ApplicationListener子类,判断是否单利类型。不是则将容器中该类型删除(不进行管理)。否则则添加到SimpleApplicationEventMulticaster的retrieverCache中,详细参见:Spring源码-事件监听机制(实现EventListener接口)
2、MergedBeanDefinitionPostProcessor
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
Class<?> beanType, String beanName);
default void resetBeanDefinition(String beanName) {
}
}
实现了postProcessMergedBeanDefinition接口,回调时将所有的Bean都添加自己的容器singletonNames中。当refresh的最后,所有非懒加载的单利bean把生命周期走完,则全部加载到该容器中。
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
Class<?> beanType, String beanName) {
this.singletonNames.put(beanName, beanDefinition.isSingleton());
}
3、DestructionAwareBeanPostProcessor
public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
default boolean requiresDestruction(Object bean) {
return true;
}
}
实现了resetBeanDefinition接口,比较简单,判断是否为ApplicationListener类型的子类。
public boolean requiresDestruction(Object bean) {
return (bean instanceof ApplicationListener);
}
实现了postProcessBeforeDestruction接口,那么在Bean进行销毁时,会调用该方法。则从添加的缓存中删除数据,则就不会再发送该事件,监听失效。
public void postProcessBeforeDestruction(Object bean, String beanName) {
if (bean instanceof ApplicationListener) {
try {
ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
multicaster.removeApplicationListener((ApplicationListener<?>) bean);
multicaster.removeApplicationListenerBean(beanName);
}
catch (IllegalStateException ex) {
// ApplicationEventMulticaster not initialized yet - no need to remove a listener
}
}
}