SpringBoot 源码解析4：refresh 方法解析

1. refresh 方法解析

AbstractApplicationContext#refresh 方法为Spring最核心的方法，Bean的注册，实例化，初始化过程都是在此方法中完成的。

从SpringBoot启动流程可知，创建了ApplicationContext为AnnotationConfigServletWebServerApplicationContext，调用AbstractApplicationContext的refresh方法。

@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.
		// 获取DefaultListableBeanFactory
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		// 对bean工厂准备工作，配置
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			// 配置BeanFactory，对web的支持
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 调用BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			// 注册BeanPostProcessor
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			// 对国际化支持
			initMessageSource();

			// Initialize event multicaster for this context.
			// 初始化事件发布器
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			// 创建web服务
			onRefresh();

			// Check for listener beans and register them.
			// 注册时间监听器
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			// 实例化bean核心方法
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			// 启动web服务，发布事件
			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();
		}
	}
}

2. 准备刷新 AbstractApplicationContext#prepareRefresh

容器刷新前准备工作，对环境变量进行校验，初始化监听器等。

protected void prepareRefresh() {
	// Switch to active.
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);

	if (logger.isDebugEnabled()) {
		if (logger.isTraceEnabled()) {
			logger.trace("Refreshing " + this);
		}
		else {
			logger.debug("Refreshing " + getDisplayName());
		}
	}

	// Initialize any placeholder property sources in the context environment.
	initPropertySources();

	// Validate that all properties marked as required are resolvable:
	// see ConfigurablePropertyResolver#setRequiredProperties
	getEnvironment().validateRequiredProperties();

	// Store pre-refresh ApplicationListeners...
	if (this.earlyApplicationListeners == null) {
		this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
	}
	else {
		// Reset local application listeners to pre-refresh state.
		this.applicationListeners.clear();
		this.applicationListeners.addAll(this.earlyApplicationListeners);
	}

	// Allow for the collection of early ApplicationEvents,
	// to be published once the multicaster is available...
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

1. initPropertySources方法：对Environment中的servletContextInitParams和servletConfigInitParams的propertySource初始化。
2. getEnvironment().validateRequiredProperties() 校验了是否存在requiredProperties中包含的必须存在的属性，否则会抛出MissingRequiredPropertiesException，requiredProperties默认为空。
3. 初始化了事件监听器ApplicationListener和事件ApplicationEvent

3. 获取bean工厂 AbstractApplicationContext#obtainFreshBeanFactory

获取beanFactory，AnnotationConfigServletWebServerApplicationContext是GenericApplicationContext的子类，在实例化的时候，创建的是DefaultListableBeanFactory。

/**
* Create a new GenericApplicationContext.
 * @see #registerBeanDefinition
 * @see #refresh
 */
public GenericApplicationContext() {
	this.beanFactory = new DefaultListableBeanFactory();
}

4. 准备bean工厂 AbstractApplicationContext#prepareBeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	// Configure the bean factory with context callbacks.
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	// BeanFactory interface not registered as resolvable type in a plain factory.
	// MessageSource registered (and found for autowiring) as a bean.
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	// Register early post-processor for detecting inner beans as ApplicationListeners.
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	// Detect a LoadTimeWeaver and prepare for weaving, if found.
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// Register default environment beans.
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

1. 为bean工厂做准备，对bean工厂进行了配置。
2. 配置了ignoredDependencyInterfaces。在Spring注入的过程中，如果是ignoredDependencyInterfaces所包含的类型bean，会忽略注入。
3. 配置了resolvableDependencies，key依赖类型，value依赖bean。在Spring注入的过程中，如果注入的类型为resolvableDependencies对应的key，则注入resolvableDependencies所对应的value。
4. 添加了一些后置处理器BeanPostProcessor，注册了一些单例bean。
5. 注册了与Environment相关的单例。

5. ServletWebServerApplicationContext#postProcessBeanFactory

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
	beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	registerWebApplicationScopes();
}

1. 注册后置处理器WebApplicationContextServletContextAwareProcessor，在bean初始化之前，对bean设置ServletContext和ServletConfig。忽略了ServletContextAware接口依赖。
2. registerWebApplicationScopes注册了request、session、application作用域。
3. 创建了ServletRequest、ServletResponse、HttpSession、WebRequest可依赖对象工厂。

public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
		@Nullable ServletContext sc) {

	beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
	beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
	if (sc != null) {
		ServletContextScope appScope = new ServletContextScope(sc);
		beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
		// Register as ServletContext attribute, for ContextCleanupListener to detect it.
		sc.setAttribute(ServletContextScope.class.getName(), appScope);
	}

	beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
	beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
	beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
	beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
	if (jsfPresent) {
		FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
	}
}

6. 调用BeanFactoryPostProcessor AbstractApplicationContext#invokeBeanFactoryPostProcessors

主要逻辑委派到PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors方法，负责执行BeanDefinitionRegistry和BeanFactoryPostProcessor。

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	//
	Set<String> processedBeans = new HashSet<>();

	// 当前beanFactory为DefaultListableBeanFactory，可以查看类结构，是属于BeanDefinitionRegistry类型的
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		//regularPostProcessors 存放的是BeanDefinitionRegistryPostProcessor（优先），registryProcessors 存放的是BeanFactoryPostProcessor，而BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				//先执行BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				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<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		//首先，按照PriorityOrdered的顺序调用Spring容器中的BeanDefinitionRegistryPostProcessor
		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);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		//其次，按照Ordered的顺序调用Spring容器中的BeanDefinitionRegistryPostProcessor
		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();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		//最后，调用没有实现Ordered和PriorityOrdered的BeanDefinitionRegistryPostProcessor。但是SpringBoot内置了支持@Priority和@Order注解顺序比较器AnnotationAwareOrderComparator
		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.
		//最最后，在BeanDefinitionRegistryPostProcessor调用完毕之后，才会调用BeanFactoryPostProcessor。而且是先调用BeanDefinitionRegistryPostProcessor类型的BeanFactoryPostProcessor，再调用其他类型的BeanFactoryPostProcessor，这些BeanFactoryPostProcessor不是从beanFactory中获取的，而是之前流程手动添加到applicationContext中的。
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	//在这里，才会获取beanFactory中的BeanFactoryPostProcessor，下面BeanFactoryPostProcessor调用的顺序和BeanDefinitionRegistryPostProcessor调用的顺序逻辑一样的。先按照PriorityOrdered，其次Ordered，最后调用无序的
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	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);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement 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);

	// Finally, invoke all other 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();
}

1. 此方法主要负责调用BeanDefinitionRegistry和BeanFactoryPostProcessor。调用顺序如下：
   1.1. 先调用BeanDefinitionRegistry再调用BeanFactoryPostProcessor。
   1.2. 先调用手动注册的BeanDefinitionRegistry，再调用beanFactory中的BeanDefinitionRegistry。
   1.3. PriorityOrdered接口顺序 > Ordered接口顺序 > @Priority和@Order顺序 > 无序。
   1.4. BeanFactoryPostProcessor调用顺序和BeanDefinitionRegistry调用一样。
2. 在SpringBoot启动流程中，创建ApplicationContext中的scanner的时候，手动注册了ConfigurationClassPostProcessor，而ConfigurationClassPostProcessor是Spring注解式支持的核心。在调用ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法的过程中，Spring将需要注册的Bean的信息（比如：@Component注解标注的类）注册到DefaultListableBeanFactory#beanDefinitionMap，以便实例化。
3. TODO 请后续请参考 ConfigurationClassPostProcessor。
4. 为什么每次调用BeanDefinitionRegistryPostProcessor，都要从beanFactory中获取，而调用BeanFactoryPostProcessor只获取了一次？
   4.1. 因为BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry方法的用途是注册BeanDefinition的，在调用完BeanDefinitionRegistryPostProcessor之后，又会产生新的BeanDefinition，而这些的"新的BeanDefinition"有可能是BeanDefinitionRegistryPostProcessor。
   4.2. BeanFactoryPostProcessor只是修改beanDefinition的属性而已，不会产生新的BeanDefinition。

7. BeanPostProcessor注册 AbstractApplicationContext#registerBeanPostProcessors

从方法名称上就能知道，这个方法是注册BeanPostProcessor。实际上就是把存放在DefaultListableBeanFactory#beanDefinitionMap中的bean的定义信息实例化，保存到AbstractBeanFactory#beanPostProcessors。

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	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);
		}
	}

	// First, register the BeanPostProcessors that implement PriorityOrdered.
	// 顺序1：按照PriorityOrdered排序，然后注册
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// Next, register the BeanPostProcessors that implement 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);
		}
	}
	// 顺序2：按照Ordered排序，然后注册
	sortPostProcessors(orderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// Now, register all regular BeanPostProcessors.
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	//顺序3：注册无序的beanPostProcessor
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// Finally, re-register all internal BeanPostProcessors.
	//顺序4：对MergedBeanDefinitionPostProcessor排序，然后重新注册。先remove，再add
	sortPostProcessors(internalPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// Re-register post-processor for detecting inner beans as ApplicationListeners,
	// moving it to the end of the processor chain (for picking up proxies etc).
	//顺序5：注册ApplicationListenerDetector
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

1. BeanPostProcessor的注册顺序就是后期方法回调的顺序，它的顺序和BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor调用的顺序几乎是一样的。
2. by PriorityOrdered > by Ordered > 无序 > MergedBeanDefinitionPostProcessor > ApplicationListenerDetector。
3. 注册逻辑：AbstractBeanFactory#addBeanPostProcessor，先remove在add。

@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
	Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
	// Remove from old position, if any
	this.beanPostProcessors.remove(beanPostProcessor);
	// Track whether it is instantiation/destruction aware
	if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
		this.hasInstantiationAwareBeanPostProcessors = true;
	}
	if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
		this.hasDestructionAwareBeanPostProcessors = true;
	}
	// Add to end of list
	this.beanPostProcessors.add(beanPostProcessor);
}

8. 国际化支持 initMessageSource

这里是对国际化的支持，后续单独再起文章

9. 初始化事件分发器 AbstractApplicationContext#initApplicationEventMulticaster

初始化事件分发器SimpleApplicationEventMulticaster，负责事件的分发。

protected void initApplicationEventMulticaster() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isTraceEnabled()) {
			logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else {
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isTraceEnabled()) {
			logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
					"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
		}
	}
}

1. 判断是否存在名称为applicationEventMulticaster的bean或者beanDenifition或者factoryBean。
2. 如果存在，则返回，不存在则注册一个SimpleApplicationEventMulticaster。
3. SimpleApplicationEventMulticaster负责事件的分发，参考SpringBoot 源码解析2：启动流程
4. 为什么SpringBoot启动的时候已经创建了SimpleApplicationEventMulticaster，但是此时在AbstractApplicationContext#refresh还需要注册SimpleApplicationEventMulticaster？
   4.1. 之前SpringBoot启动的时候，是在SpringApplication内完成的，它的ApplicationListener监听器是手动注册的，为了监听SpringBoot启动的整个过程。
   4.2. 此时注册SimpleApplicationEventMulticaster是注册到BeanFactory中，给用户使用的，用户可以自定义事件和监听器处理业务。

10. 创建web容器 ServletWebServerApplicationContext#onRefresh

此方法创建了web容器，为了后续启动Servlet。通过加载的@ConditionalOnClass判断类是否加载，众所周知，SpringBoot内置了Tomcat，注册了TomcatServletWebServerFactory。
下面是Servlet容器自动配置：

private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = getServletContext();
	if (webServer == null && servletContext == null) {
	    //获取Servlet容器工厂
		ServletWebServerFactory factory = getWebServerFactory();
		//启动tomcat，并在tomcat声明周期Start的时候回调ServletContextInitializer
		this.webServer = factory.getWebServer(getSelfInitializer());
	}
	else if (servletContext != null) {
		try {
			getSelfInitializer().onStartup(servletContext);
		}
		catch (ServletException ex) {
			throw new ApplicationContextException("Cannot initialize servlet context", ex);
		}
	}
	initPropertySources();
}

protected ServletWebServerFactory getWebServerFactory() {
	// Use bean names so that we don't consider the hierarchy
	String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
	if (beanNames.length == 0) {
		throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
				+ "ServletWebServerFactory bean.");
	}
	if (beanNames.length > 1) {
		throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
				+ "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
	}
	return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

1. 从BeanFactory中获取ServletWebServerFactory，获取的是TomcatServletWebServerFactory。
2. 获取Servlet容器工厂，在tomcat声明周期Start的时候回调ServletContextInitializer，返回webServer。

11. 注册事件监听器 AbstractApplicationContext#registerListeners

注册事件监听器

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

1. 从SpringBoot启动流程可知，在SpringApplication#prepareContext方法中，已经将SpringApplication中的事件监听器copy到了ApplicationContext中。
2. 而这里先将ApplicationListener实例注册，在将Bean工厂中的属于ApplicationListener的beanName注册。
3. 监听器的回调原理请参考：SpringBoot 源码解析3：事件监听器

12. Bean的实例化 AbstractApplicationContext#finishBeanFactoryInitialization

完成BeanFactory对bean的实例化，在此之前，所有的beanDefinition都已注册到DefaultListableBeanFactory#beanDefinitionMap。

12.1 DefaultListableBeanFactory#finishBeanFactoryInitialization

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.
	beanFactory.setTempClassLoader(null);

	// Allow for caching all bean definition metadata, not expecting further changes.
	// 冻结beanDinifition，不期望后期beanDinition再被修改
	beanFactory.freezeConfiguration();

	// Instantiate all remaining (non-lazy-init) singletons.
	// 实例化的真正逻辑
	beanFactory.preInstantiateSingletons();
}

此方法很简单，看注释。

12.2 DefaultListableBeanFactory#preInstantiateSingletons

@Override
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// 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.
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// Trigger initialization of all non-lazy singleton beans...
	// 获取到所有BeanDifinition注册的beanName，遍历创建
	for (String beanName : beanNames) {
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
		    // 判断当前的bean是否为FactoryBean
			if (isFactoryBean(beanName)) {
			    // 如果是FactoryBean，那么就获取到当前的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());
					}
					//如果factoryBean是SmartFactoryBean，并且是迫切加载，那么就实例化当前bean
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
			    //如果不是FactoryBean，那么就创建
				getBean(beanName);
			}
		}
	}

	// Trigger post-initialization callback for all applicable beans...
	// 判断单例池中的bean如果是SmartInitializingSingleton，那么就回调afterSingletonsInstantiated方法
	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();
			}
		}
	}
}

1. 判断当前的bean是否属于FactoryBean类型，如果不是FactoryBean类型，那么就直接去创建当前bean。如果不是FactoryBean，并且为SmartFactoryBean，判断是否要迫切加载。
2. 判断单例池中的bean如果是SmartInitializingSingleton，那么就回调afterSingletonsInstantiated方法。

13. 启动web容器 ServletWebServerApplicationContext#finishRefresh

@Override
protected void finishRefresh() {
	super.finishRefresh();
	WebServer webServer = startWebServer();
	if (webServer != null) {
		publishEvent(new ServletWebServerInitializedEvent(webServer, this));
	}
}

启动web容器，发布ServletWebServerInitializedEvent事件