Spring源码解析-IOC容器启动流程(二)
文章目录
- 一、前言
- 二、核心refresh()方法源码
- 三、refresh()流程解析
- 5.invokeBeanFactoryPostProcessors(beanFactory);
- 补充: BeanDefinitionRegistryPostProcessor
- invokeBeanFactoryPostProcessors总结
- 6. registerBeanPostProcessors(beanFactory)
- registerBeanPostProcessors总结：
- 7. initMessageSource()
- 8. initApplicationEventMulticaster()
- 9. onRefresh()
- 10. registerListeners()
- 四. 容器准备工作总结
一、前言
上一篇文章Spring源码解析-IOC容器启动流程(一)，前四步已经分析了容器的准备工作和BeanFactory的创建和预处理操作，这篇文章主要解析的是后几步的操作。
阅读本文建议提前了解Bean的生命周期，观察者模式，监听器的使用。
常用英译汉介绍：
| 英文 | 中文 |
|---|---|
| Source | 资源 |
| Annotation | 注解 |
| Refresh | 刷新 |
| Post | 后置的 |
| Processor | 处理器 |
| Init(initialize) | 初始化 |
| Invoke | 执行 |
| Regist | 注册 |
| Multicaster | 多路广播 |
了解这些常见的词汇后，看到类名、方法名和源码上的注释就可以大体猜出来干什么用的，这对阅读源码帮助很大。
二、核心refresh()方法源码
/*AbstractApplicationContext.class*/
@Override
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();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
三、refresh()流程解析
5.invokeBeanFactoryPostProcessors(beanFactory);
直接翻译得，执行BeanFactory后置处理(执行BeanFactoryPostProcessors中实现的方法)。为什么现在能执行BeanFactory的后置处理器？因为BeanFactory已经
完全了初始化了。
到这里我终于碰到了一个我接触过的类了，这是我在研究bean生命周期方法执行顺序时使用过的一个接口，里面实现的方法能在BeanFactory初始化之后执行，终于算搭上勾了，不知道各位读者是什么感受?。
既然提到了BeanFactoryPostProcessors接口，那就有必要再介绍一个有关的接口了。
补充: BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，是BeanFactoryPostProcessor的子接口。
spring官方解释是:允许在正常的BeanFactoryPostProcessor检测开始之前注册更多的自定义bean。如果自己实现了这个接口，就可以在BeanFactory后置处理器操作之前，自定义的注册bean，例子如下。
public class MyBeanFactoryRegistry implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
RootBeanDefinition dog= new RootBeanDefinition(Dog.class);
// 注册一个名为dog的bean
registry.registerBeanDefinition("dog", dog);
}
}
这样的话，容器中就多了一个id为dog的bean。
说完了这两个后置处理器，接下来进入invokeBeanFactoryPostProcessors方法：
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()));
}
}
第一句invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())就是我们要分析的重点，直译就是“执行BeanFactory后置处理器方法”，这个方法的两个参数，第一个就是要被增强的BeanFactory，第二个就是所有的BeanFactoryPostProcessor的方法集，类型是List
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<String>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
// 以下，都是对postProcessor的分类操作，不是重点
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// 以上，都是对postProcessor的分类操作，不是重点
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
// 拿到所有的BeanDefinitionRegistryPostProcessor类型的bean
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 对这些bean进行一次遍历，筛选出实现了优先级排序(PriorityOrdered)的bean，也是个分类操作
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 对这些有PriorityOrdered的bean排个序，根据优先级大小先后执行
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
// 执行这些bean
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 再执行实现了Ordered接口的BeanDefinitionRegistryPostProcessors
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);
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 {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 以上都是执行的BeanDefinitionRegistryPostProcessor中的方法，提前注册bean，下面就轮到BeanFactoryPostProcessors执行了
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 下面操作和上面相似，对BeanFactoryPostProcessors进行一个分类，干bean，湿bean，有害bean，可回收bean......把不同的bean往对应的桶里面add
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
}
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接口的BeanFactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 接下来执行实现了Ordered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后执行所有未执行的BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
beanFactory.clearMetadataCache();
}
好了，这个长方法用注释分析完流程了，现在做一个小总结：
invokeBeanFactoryPostProcessors总结
执行流程：
- 先执行所有BeanDefinitionRegistryPostProcessor的方法
(1) 获取所有的BeanDefinitionRegistryPostProcessor；
(2) 执行所有实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor；
(3) 执行所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor；
(4) 执行其他未执行的BeanDefinitionRegistryPostProcessor； - 再执行所有BeanFactoryPostProcessor的方法
(1) 获取所有的BeanFactoryPostProcessor；
(2) 执行实现了PriorityOrdered接口的BeanFactoryPostProcessor；
(3) 执行实现了Ordered接口的BeanFactoryPostProcessor；
(4) 执行其他未执行的BeanFactoryPostProcessor；
从上述执行顺序可以看出两点：
1. BeanDefinitionRegistryPostProcessor的优先级高于BeanFactoryPostProcessor接口。
2. PriorityOrdered的优先级高于Ordered接口。
6. registerBeanPostProcessors(beanFactory)
翻译方法名，“注册Bean的后置处理器”，注意，上一步是BeanFactory的后置处理器操作，这个是Bean的后置处理器注册！
有些读者可能会有疑问，这时的Bean压根没开始实例化啊，怎么这个Bean的后置处理器都工作起来了呢？
再强调一遍：是注册BeanPostProcessors，就是把Bean的后置处理器放到BeanFactory中，这个BeanFactory就是前几步初始化完成的，也是传入这个方法的参数，到时候由BeanFactory来创建实例化Bean并执行其后置处理器。
话不多说，进入方法瞧瞧：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
只有一个方法，再进入(看注释，不重要的步骤不用看了)：
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取所有的BeanPostProcessor
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<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
// 分类现场
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接口的BeanPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 注册实现了Ordered接口的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
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);
// 注册其他没注册的BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 注册所有的内部后置处理器
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
registerBeanPostProcessors总结：
Bean的后置处理器注册的流程和BeanFactory后置处理器注册流程类似。只要是后置处理器(PostProcessor)就可以实现PriorityOrdered或Ordered来设置优先级。所以同样是按照PriorityOrdered, Ordered, Others的顺序来注册后置处理器的。
7. initMessageSource()
初始化MessageSource组件(做国际化操作，消息绑定等)。
进入方法：
protected void initMessageSource() {
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果BeanFactory包含了MESSAGE_SOURCE_BEAN_NAME这个bean，就保存起来
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isDebugEnabled()) {
logger.debug("Using MessageSource [" + this.messageSource + "]");
}
}
// 否则就创建一个DelegatingMessageSource，并注册到BeanFactory
else {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
"': using default [" + this.messageSource + "]");
}
}
}
这个方法的主要功能就是确保BeanFactory里面注册了一个MessageSource。以后获取国际化配置文件的值的时候，可以自动注入MessageSource。
8. initApplicationEventMulticaster()
初始化事件派发器，这个操作和上一步操作差不多。
进入方法：
protected void initApplicationEventMulticaster() {
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果BeanFactory中有这个组件，保存下来
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
// 否则创建一个SimpleApplicationEventMulticaster，注册到BeanFactory中
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
"': using default [" + this.applicationEventMulticaster + "]");
}
}
}
确保BeanFactory里面注册了一个事件派发器
9. onRefresh()
这个是留给子类重写的
// Initialize other special beans in specific context subclasses.
onRefresh();
点进去什么都没有：
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}
10. registerListeners()
事件派发器中注册事件监听器。
上面所说的事件派发器(EventMulticaster)就是来广播监听器所捕获到的事件的。
protected void registerListeners() {
// 给事件派发器中注册所有的事件监听器.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 获取实现了ApplicationListener的组件
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 注册早期事件(在第一步中创建了早起事件集合)
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
// 如果早期事件集合不为空，派发早期事件，这也是第一批被派发出去的事件
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
四. 容器准备工作总结
前几步，我们发现都是在干类似的活，一直在往BeanFactory里面注册各种各样的东西，包括BeanPostProcessors, MessageSource, EventMulticaster。所以现在的阶段Spring容器已经完成的有以下几点：
- 所有的BeanPostProcessor都注册到了BeanFactory中
- 一些单实例bean已经被BeanFactory实例化并装入singletonObjects了，比如环境变量
- MessageSource注册到了BeanFactory中
- EventMulticaster也注册到了BeanFactory中
- 子类重写的onRefresh执行完毕
- 将所有的Listener添加到EventMulticaster中
最后两步操作见下一篇文章Spring源码解析-IOC容器启动流程(三)