Tabla de contenido
finishBeanFactoryInitialization (beanFactory)
registerListeners ()
Compruebe los beans de escucha y regístrelos.
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);
}
}
}Colección ApplicationListener obtenida por getApplicationListeners (). Agregue estos objetos al multicaster.
Luego obtenga los beanNames que implementan ApplicationListener y agréguelos al multicaster. Luego, ejecute el evento de la aplicación al principio del lanzamiento.
finishBeanFactoryInitialization (beanFactory)
Cree una instancia de todos los singleton restantes (inicializados no diferidos).
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();
}
}
}
}Traducción de documentos de SmartInitializingSingleton: durante el proceso de arranque de BeanFactory, la interfaz de devolución de llamada se activa al final de la fase de creación de instancias de singleton. Esta interfaz puede ser implementada por un bean singleton para realizar alguna inicialización después del algoritmo de instanciación singleton convencional para evitar los efectos secundarios de una inicialización temprana inesperada (por ejemplo, de la llamada ListableBeanFactory.getBeansOfType). En este sentido, es una alternativa a InitializingBean, que se activa inmediatamente al final de la fase de construcción local del bean.
Esta variante de devolución de llamada es algo similar a org.springframework.context.event.ContextRefreshedEvent pero no necesita implementar org.springframework.context.ApplicationListener y no necesita filtrar referencias de contexto en toda la jerarquía de contexto. Esto también significa que una mayor dependencia del paquete beans es mínima, y se cumple con la implementación independiente ListableBeanFactory, no solo en el entorno org.springframework.context.ApplicationContext.
Nota: Si desea iniciar / administrar tareas asincrónicas, es mejor implementar org.springframework.context.Lifecycle, que proporciona un modelo más rico para la administración del tiempo de ejecución y permite el inicio / apagado por fases.
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);
}