springboot2.1.7启动 AbstractApplicationContext refresh(三)

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);
	}