目录
finishBeanFactoryInitialization(beanFactory)
registerListeners()
检查侦听器bean并注册它们。
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
getApplicationListeners()获取到的ApplicationListener集合。将这些对象添加到多播器中。
接着获取到实现了ApplicationListener的beanNames,添加到多播器中。然后执行发布早期的应用程序事件。
finishBeanFactoryInitialization(beanFactory)
实例化所有剩余的(非延迟初始化)单例。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 为此上下文初始化转换服务
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
//如果beanFactory之前没有注册嵌入值解析器,则注册默认的嵌入值解析器:主要用于注解属性值的解析
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
//尽早初始化LoadTimeWeaverAware Bean,以便尽早注册其转换器
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
//停止使用临时的ClassLoader进行类型匹配
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
//冻结所有Bean定义,表示已注册的Bean定义将不再被修改或进一步处理。 这允许工厂积极地缓存bean定义元数据。因为接下来就要创建bean的实例了
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
//确保所有非延迟初始单例都实例化,同时考虑到FactoryBeans 。 如果需要,通常在工厂设置结束时调用。
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
//遍历一个副本以允许使用init methods ,这些方法依次注册新的bean定义。尽管这可能不是常规工厂引导程序的一部分,但可以正常运行
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
//遍历beanNames,触发所有非懒加载单例bean的初始化
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//不是抽象类 && 是单例 && 不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//beanName对应的bean是否为FactoryBean
if (isFactoryBean(beanName)) {
//获取FactoryBean实例
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//不是FactoryBean,获取bean实例
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
//触发所有适用bean的初始化后回调.这里只有SmartInitializingSingleton
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
SmartInitializingSingleton文档翻译:BeanFactory引导过程中,在单例预实例化阶段结束时触发了回调接口。 该接口可以由单例bean实现,以便在常规的单例实例化算法之后执行一些初始化,避免意外的早期初始化带来的副作用(例如,来自ListableBeanFactory.getBeansOfType调用)。 从这个意义上讲,它是InitializingBean的替代方法,后者在bean的本地构造阶段结束时立即触发。
这个回调变体有点类似于org.springframework.context.event.ContextRefreshedEvent但是不需要实现org.springframework.context.ApplicationListener ,不需要过滤整个上下文层次结构中的上下文引用。这也意味着更多对beans包的依赖性最小,并且由独立的ListableBeanFactory实现兑现,而不仅仅是在org.springframework.context.ApplicationContext环境中。
注意:如果要启动/管理异步任务,则最好实现org.springframework.context.Lifecycle ,它为运行时管理提供了更丰富的模型,并允许分阶段启动/关闭
finishRefresh()
ServletWebServerApplicationContext#finishRefresh
protected void finishRefresh() {
super.finishRefresh();
//启动web服务
WebServer webServer = startWebServer();
//推送web服务初始化完成事件到相应的监听器
if (webServer != null) {
publishEvent(new ServletWebServerInitializedEvent(webServer, this));
}
}
父类AbstractApplicationContext#finishRefresh
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
//初始化LifecycleProcessor。 如果上下文中未定义,则使用DefaultLifecycleProcessor。
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
//首先将刷新传播到生命周期处理器。例如swagger、quartz等实现了生命周期接口。
getLifecycleProcessor().onRefresh();
// Publish the final event.
//推送上下文刷新完毕事件到相应的监听器
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}