Spring源码-IOC之AbstractApplicationContext#refresh

版本 Spring Framework 6.0.9

1. refresh

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {

    void refresh() throws BeansException, IllegalStateException;
    // 省略其他代码...
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {

    private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 标志应用程序上下文刷新阶段开始
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
			// 准备上下文环境，设置启动时间、活动状态，初始化属性源和刷新前事件及监听器等。
			prepareRefresh();
            // 获取bean工厂对象
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // 对bean工厂填充功能，进行一些配置
			prepareBeanFactory(beanFactory);
			try {
                // 留给子类覆盖，对BeanFactory进行额外的处理。
				postProcessBeanFactory(beanFactory);
                // 标志后置处理器相关处理步骤开始，调用bean工厂后置处理
				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // 按顺序实例化并调用所有已注册的 BeanFactoryPostProcessor bean
				invokeBeanFactoryPostProcessors(beanFactory);
                // 按顺序实例化并注册所有 BeanPostProcessor bean
				registerBeanPostProcessors(beanFactory);
                // 标识后置处理器相关处理步骤已完成
				beanPostProcess.end();
                // 初始化国际化相关的属性
				initMessageSource();
                // 初始化事件广播器，用于事件的发布和监听。
				initApplicationEventMulticaster();
                // 模板方法，留给子类覆盖，用于扩展refresh动作。
				onRefresh();
                // 将实现 ApplicationListener 的 Bean 添加到事件广播器中
				registerListeners();
                // 实例化所有非懒加载的单例Bean
				finishBeanFactoryInitialization(beanFactory);
                // 完成刷新过程，通知生命周期处理器和事件监听器，发出ContextRefreshedEvent事件。
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}
                // 销毁已创建的单例bean
				destroyBeans();
                // 设置active标志为false
				cancelRefresh(ex);
				throw ex;
			}
			finally {
                // 重置 Spring 的反射元数据缓存
				resetCommonCaches();
                // 标志context的刷新方法结束
				contextRefresh.end();
			}
		}
	}

    // 省略其他代码...
}

refresh是接口ConfigurableApplicationContext的方法，定义：加载或刷新配置的持久层表示，可能是Java Config类、XML文件、properties文件或关系型数据库模式。
接口ConfigurableApplicationContext的子类AbstractApplicationContext对refresh方法做了基本实现，方法体由一系列方法调用组成

prepareRefresh 准备刷新

obtainFreshBeanFactory 获取bean工厂

prepareBeanFactory 准备bean工厂

postProcessBeanFactory 后处理bean工厂

invokeBeanFactoryPostProcessors 调用bean工厂后置处理器

registerBeanPostProcessors 注册bean后置处理器

initMessageSource 初始化国际化组件

initApplicationEventMulticaster 初始化事件多播器组件

onRefresh 刷新

registerListeners 注册监听器

finishBeanFactoryInitialization 实例化bean

finishRefresh 完成刷新

蓝色为准备环境； 绿色为创建、初始化bean工厂，并用工厂实例化bean； 黄色为上下文初始化一些特有的功能。

1.1 prepareRefresh

	protected void prepareRefresh() {
		// 设置启动时间
		this.startupDate = System.currentTimeMillis();
        // 设置关闭标志为false
		this.closed.set(false);
		// 设置激活标志为true
		this.active.set(true);

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

		// 将StubPropertySource转换成实际属性源
		initPropertySources();

        // 验证环境中Required的属性是否不为空
		getEnvironment().validateRequiredProperties();

		// 存储预刷新的ApplicationListeners
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// 将本地应用程序侦听器重置为刷新前状态。
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

        // 初始化早期事件集合
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

prepareRefresh方法主要设置启动时间、active、close标记以及初始化PropertySource。

	protected void initPropertySources() {
		// For subclasses: do nothing by default.
	}

prepareRefresh中的initPropertySources是个空方法，由子类实现。在web体系中目的是将StubPropertySource转换成实际的属性源ServletContextPropertySource和ServletConfigPropertySource。

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {

	@Override
	public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			// 创建一个StandardEnvironment(包含一个系统属性、环境的PropertySourcesPropertyResolver实例)
			this.environment = createEnvironment();
		}
		return this.environment;
	}

}

public abstract class AbstractEnvironment implements ConfigurableEnvironment {

	private final ConfigurablePropertyResolver propertyResolver;

	@Override
	public void validateRequiredProperties() throws MissingRequiredPropertiesException {
		this.propertyResolver.validateRequiredProperties();
	}

}

public abstract class AbstractPropertyResolver implements ConfigurablePropertyResolver {

    private final Set<String> requiredProperties = new LinkedHashSet<>();

	@Override
	public void validateRequiredProperties() {
		// 创建一个MissingRequiredPropertiesException异常，继承IllegalStateException，包含一个用具记录找不到所需的属性的集合missingRequiredProperties
		MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
		for (String key : this.requiredProperties) {
			if (this.getProperty(key) == null) {
				ex.addMissingRequiredProperty(key);
			}
		}
		// 存在找不到找不到所需的属性抛出异常
		if (!ex.getMissingRequiredProperties().isEmpty()) {
			throw ex;
		}
	}

}

getEnvironment().validateRequiredProperties();实际上是调用environment中ConfigurablePropertyResolver对象的validateRequiredProperties方法，校验其属性requiredProperties集合在环境中的关联值是否为空，如果为空则抛出MissingRequiredPropertiesException异常。

1.2 obtainFreshBeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 调用refreshBeanFactory方法来刷新当前Application的BeanFactory，由子类实现，该实例包含了所有的Bean定义信息，可以用于创建和管理Bean对象
		refreshBeanFactory();
		// 返回刷新后的BeanFactory实例，由子类实现，该实例可以用于后续的Bean操作，如获取Bean，注册Bean后置处理器，初始化消息源等
		return getBeanFactory();
	}

	protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

	public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

refreshBeanFactory和getBeanFactory都是抽象方法。

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	@Override
	protected final void refreshBeanFactory() throws BeansException {
		// 检查是否存在BeanFactory
		if (hasBeanFactory()) {
			// 如果存在则销毁现有的所有bean
			destroyBeans();
			// 关闭BeanFactory，移除上下文和工厂之间的关系
			closeBeanFactory();
		}
		try {
			// 为此上下文创建一个新的内部 Bean 工厂。每次 refresh() 尝试都调用。DefaultListableBeanFactory实例
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 设置BeanFactory的序列化ID
			beanFactory.setSerializationId(getId());
			// 对BeanFactory进行一些自定义的配置，如设置是否允许覆盖同名的Bean，是否允许循环依赖等
			customizeBeanFactory(beanFactory);
			// 加载Bean定义，这是一个模板方法，由具体的子类实现，如XmlWebApplicationContext，AnnotationConfigWebApplicationContext等，
			// 根据不同的配置方式，解析XML文件或注解类，将Bean定义封装成BeanDefinition对象，并注册到BeanFactory中
			loadBeanDefinitions(beanFactory);
			// 将新创建的BeanFactory设置为当前ApplicationContext的BeanFactory
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
	// 省略其他代码...
}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	@Override
	protected final void refreshBeanFactory() throws IllegalStateException {
		// 检查 refreshed 变量的值是否为 false，并将其原子地设置为 true。如果 refreshed 变量的值已经是 true，表示应用程序上下文已经进行过刷新，不支持多次刷新。
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		// 通过 this.beanFactory.setSerializationId(getId()) 设置 BeanFactory 的序列化ID（Serialization ID）。这个 ID 可以在应用程序上下文被序列化时用于标识 BeanFactory
		this.beanFactory.setSerializationId(getId());
	}
	// 省略其他代码...
}

有两个子类实现refreshBeanFactory方法

• AbstractRefreshableApplicationContext
  对bean工厂做了具体的刷新实现，先关闭现有工厂，再初始化一个新的bean工厂，为该工厂加载bean定义。
• GenericApplicationContext 没有具体操作，仅将上下文的id赋值给bean工厂属性serializationId。

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		DefaultListableBeanFactory beanFactory = this.beanFactory;
		// 如果 beanFactory 为 null，说明当前 BeanFactory 未初始化或已经关闭
		if (beanFactory == null) {
			throw new IllegalStateException("BeanFactory not initialized or already closed - " +
					"call 'refresh' before accessing beans via the ApplicationContext");
		}
		// 如果 beanFactory 为 null，说明当前 BeanFactory 未初始化或已经关闭
		return beanFactory;
	}
	// 省略其他代码...
}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		// 返回此上下文持有的单个内部BeanFactory（作为ConfigurationListableBeanFactory）
		return this.beanFactory;
	}
	// 省略其他代码...
}

AbstractRefreshableApplicationContext 和 GenericApplicationContext 也实现了getBeanFactory方法，方法体内容都是返回当前上下文的内部bean工厂，工厂类型为ConfigurableListableBeanFactory。

1.3 prepareBeanFactory

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置Bean工厂的类加载器，默认为当前线程的classLoader
		beanFactory.setBeanClassLoader(getClassLoader());
		// 设置Bean工厂的表达式解析器，解析Spel表达式
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		// 设置Bean工厂的属性编辑器注册器，
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 设置Bean工厂的上下文回调，设置到bean工厂的ignoredDependencyInterfaces属性中
		// 添加后置处理器ApplicationContextAwareProcessor，包含当前上下文，并且忽略给定的自动依赖注入接口，
		// 在Bean初始化后自动执行各Aware接口的set方法，包括ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、EnvironmentAware
		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.ignoreDependencyInterface(ApplicationStartupAware.class);

		// 预先设置用于自动依赖注入的接口对象,设置到bean工厂的resolvableDependencies属性中
		// 包括BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 添加后置处理器ApplicationListenerDetector,用于注册监听器，设置到bean工厂的beanPostProcessors属性中
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 系统属性org.graalvm.nativeimage.imagecode为空 && bean工厂包含loadTimeWeaver实例
		if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			// 添加LoadTimeWeaverAwareProcessor后置处理器
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// 设置用于类型匹配的临时ClassLoader，ContextTypeMatchClassLoader用于 AbstractApplicationContext 中的临时类型匹配，为了缓存字节数组重新定义、加载类时，从父类 ClassLoader 中选取最近加载的类型。
			// 设置到bean工厂的tempClassLoader属性中
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 设置到bean工厂的singletonObjects、earlySingletonObjects、manualSingletonNames属性中
		// bean工厂添加environment实例
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		// bean工厂添加 java 环境键值
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		// bean工厂添加系统环境
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
		// bean工厂添加应用程序启动记录器
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

prepareBeanFactory为obtainFreshBeanFactory阶段返回的bean工厂做了设置，包括添加类加载器、表达式解析器、属性编辑器注册器，一些bean的后置处理器及注册一些单例对象。

class ApplicationContextAwareProcessor implements BeanPostProcessor {
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware environmentAware) {
				environmentAware.setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware embeddedValueResolverAware) {
				embeddedValueResolverAware.setEmbeddedValueResolver(this.embeddedValueResolver);
			}
			if (bean instanceof ResourceLoaderAware resourceLoaderAware) {
				resourceLoaderAware.setResourceLoader(this.applicationContext);
			}
			if (bean instanceof ApplicationEventPublisherAware applicationEventPublisherAware) {
				applicationEventPublisherAware.setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware messageSourceAware) {
				messageSourceAware.setMessageSource(this.applicationContext);
			}
			if (bean instanceof ApplicationStartupAware applicationStartupAware) {
				applicationStartupAware.setApplicationStartup(this.applicationContext.getApplicationStartup());
			}
			if (bean instanceof ApplicationContextAware applicationContextAware) {
				applicationContextAware.setApplicationContext(this.applicationContext);
			}
		}
	}
	// 省略其他代码...
}

ApplicationContextAwareProcessor后置处理器在实例化Bean的时候调用，为bean实现了特定的Aware接口注入实例。

具体调用位置在refresh的finishBeanFactoryInitialization阶段中org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法 -> initializeBean -> applyBeanPostProcessorsBeforeInitialization

class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (bean instanceof ApplicationListener<?> applicationListener) {
			Boolean flag = this.singletonNames.get(beanName);
			if (Boolean.TRUE.equals(flag)) {
				this.applicationContext.addApplicationListener(applicationListener);
			}
			else if (Boolean.FALSE.equals(flag)) {
				if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
					// inner bean with other scope - can't reliably process events
					logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
							"but is not reachable for event multicasting by its containing ApplicationContext " +
							"because it does not have singleton scope. Only top-level listener beans are allowed " +
							"to be of non-singleton scope.");
				}
				this.singletonNames.remove(beanName);
			}
		}
		return bean;
	}
	// 省略其他代码...
}

ApplicationListenerDetector 后置处理器调用位置也是一样，如果bean实例实现了ApplicationListener接口，并且是单例对象，则会添加到上下文的事件多播器ApplicationEventMulticaster的内部类DefaultListenerRetriever中。

1.4 postProcessBeanFactory

	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

postProcessBeanFactory由子类实现，对BeanFactory进行额外的处理。如添加特定的bean后置处理器等。

public abstract class AbstractRefreshableWebApplicationContext extends AbstractRefreshableConfigApplicationContext
		implements ConfigurableWebApplicationContext, ThemeSource {
	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 向BeanFactory中添加ServletContextAwareProcessor后处理器。
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		// 忽略ServletContextAware接口的依赖注入。
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		//忽略ServletConfigAware接口的依赖注入。
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
		// 注册 Web 应用的 Scope，包括request、session、globalSession、application
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		// 向 BeanFactory 中注册一些环境相关的 Bean，servletContext、servletConfig、contextParameters、contextAttributes单例bean
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}
// 省略其他代码...
}

public class GenericWebApplicationContext extends GenericApplicationContext
		implements ConfigurableWebApplicationContext, ThemeSource {
	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 如果 servletContext 不为 null，BeanFactory中添加ServletContextAwareProcessor 后置处理器，并忽略 ServletContextAware 接口的依赖。
		if (this.servletContext != null) {
			beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
			beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		}
		// 注册 Web 应用的 Scope，包括request、session、globalSession、application
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		// 向 BeanFactory 中注册一些环境相关的 Bean，servletContext、contextParameters、contextAttributes单例bean
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
	}
	// 省略其他代码...
}

public class StaticWebApplicationContext extends StaticApplicationContext
		implements ConfigurableWebApplicationContext, ThemeSource {
	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 向bean工厂添加ServletContextAwareProcessor后处理器
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		// 忽略ServletContextAware接口的依赖
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		// 忽略ServletConfigAware接口的依赖
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
		// 注册 Web 应用的 Scope，包括request、session、globalSession、application
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		// 向 BeanFactory 中注册一些环境相关的 Bean，servletContext、servletConfig、contextParameters、contextAttributes单例bean
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}
	// 省略其他代码...
}

在web体系中，有三个实现类，内容差不多，为bean工厂添加ServletContextAwareProcessor后置处理器及为bean工厂注册web环境中一些特定实例。

1.5 invokeBeanFactoryPostProcessors

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 在beanFactory中调用所有的BeanFactoryPostProcessor，bean工厂后置处理器
		// 按bean工厂已存在、PriorityOrdered、Ordered、nonOrdered没有实现排序接口的BeanDefinitionRegistryPostProcessor，实例化对象，按顺序调用所有bean定义后置处理、再按顺序调用所有bean工厂后置处理
		// 再在获取BeanFactoryPostProcessor类型，按PriorityOrdered、Ordered、nonOrdered顺序执行bean工厂后置
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// 代码块是用来检测 LoadTimeWeaver，并为它进行准备。
		// LoadTimeWeaver 是一个用于加载时织入（load-time weaving）的接口，用于在类加载时对字节码进行植入增强操作。
		// 在这里，如果 BeanFactory 中包含名为 LOAD_TIME_WEAVER_BEAN_NAME 的 Bean（通常是由 ConfigurationClassPostProcessor 注册的），则会添加 LoadTimeWeaverAwareProcessor 到 BeanFactory 的 BeanPostProcessor 列表中，并设置一个临时的 ClassLoader。
		if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null &&
				beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

invokeBeanFactoryPostProcessors阶段中，PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors是调用beanFactory中所有的BeanFactoryPostProcessors，为bean工厂做后置处理。

final class PostProcessorRegistrationDelegate {
	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
		// 存放执行过的beanFactoryPostProcessors。
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry registry) {
			// 用于记录常规BeanFactoryPostProcessor
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			// 用于记录常规BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// 遍历上下文汇总所有参数传递进来的BeanFactoryPostProcessor,bean定义后置处理
			// 如果包含BeanDefinitionRegistryPostProcessor，先执行已经实例化的bean工厂后置处理器BeanDefinitionRegistryPostProcessor，在后处理节点之前加载更多的bean定义
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
					// 这里先调用一次
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// 存放当前需要执行，但是还没有执行的。
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 再通过bean工厂内的beanDefinitionNames，找到类型为BeanDefinitionRegistryPostProcessor的bean定义后置处理器，进行实例化
			// 根据BeanDefinitionRegistryPostProcessor类型获取beanName
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 属于PriorityOrdered级别的,PriorityOrdered对象集优先于Ordered对象集，同时实例化bean
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class) 实例化对象
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			// 同类别的可能不止一个，这里需要排序一下
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 把PriorityOrdered类型放进去registryProcessors
			registryProcessors.addAll(currentRegistryProcessors);
			// 调用刚刚实例化实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor后置处理器
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			// 执行后，把当前执行完的清空。
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			// 又找一遍BeanDefinitionRegistryPostProcessor类型的，但是找的是order优先级的。
			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);
			// 这里调用Ordered类型的bean定义后置处理器
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			// 调用剩下的BeanDefinitionRegistryPostProcessor后置处理器，即不是已经存在bean工厂的，也不是实现了PriorityOrdered和Ordered接口的类
			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, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			// 所有bean定义后置处理器执行完后，调用bean工厂后置处理
			// registryProcessors集合是实现了BeanDefinitionRegistryPostProcessor接口的类，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			// regularPostProcessors集合是实现了BeanFactoryPostProcessor接口的类
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// 调用bean工厂后置处理
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 获取BeanFactoryPostProcessor类型的beanName，上面都是获取的BeanFactoryPostProcessor子类BeanDefinitionRe gistryPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 如果上文processedBeans不包含，则根据不同的排序接口分组，依次调用
		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);
			}
		}

		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// 清除缓存的合并bean定义
		beanFactory.clearMetadataCache();
	}
	// 省略其他代码...
}

进入PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors方法，可以看出分为两部分。先补充一点，其中BeanFactoryPostProcessor有一个子类接口BeanDefinitionRegistryPostProcessor，方法的调用第一部分就是先获取所有BeanDefinitionRegistryPostProcessor，按PriorityOrdered、Ordered、nonOrdered顺序排序后调用postProcessBeanDefinitionRegistry方法，第二部分获取所有BeanFactoryPostProcessor，排序后调用postProcessBeanFactory方法。

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

1.6 registerBeanPostProcessors

	// AbstractApplicationContext#registerBeanPostProcessors
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 按PriorityOrdered、Ordered、nonOrdered顺序排序BeanPostProcessor后置处理器，添加到BeanFactory的BeanPostProcessor
		// 再将MergedBeanDefinitionPostProcessor类型的后置处理器添加到BeanFactory的BeanPostProcessor
		// 最后添加ApplicationListenerDetector后置处理器
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

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

		// 获取类型为BeanPostProcessor的beanName
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// 按PriorityOrdered、Ordered、nonOrdered分组，合并bean定义后置处理MergedBeanDefinitionPostProcessor类型另外一个组，最后执行
		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);
			}
		}
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// bean后置处理器注册到bean工厂属性beanPostProcessors中
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		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);
			}
		}
		// Ordered排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		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);
			}
		}
		// nonOrdered排序
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 添加ApplicationListenerDetector后置处理器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

registerBeanPostProcessors方法体中调用PostProcessorRegistrationDelegate的静态方法registerBeanPostProcessors。

具体内容与上一个阶段refresh阶段AbstractApplicationContext#invokeBeanFactoryPostProcessors类似，也是根据PriorityOrdered、Ordered、nonOrdered顺序排序后置处理器，不同点在于后置处理器类型为BeanPostProcessor，且添加成BeanFactory的BeanPostProcessor属性中去，非直接调用后置处理器的方法。

1.7 initMessageSource

	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 如果bean工厂已经存在名称为messageSource的bean，直接赋值给上下文的messageSource属性
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource hms &&
					hms.getParentMessageSource() == null) {
				hms.setParentMessageSource(getInternalParentMessageSource());
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// Use empty MessageSource to be able to accept getMessage calls.
			// 实例化一个DelegatingMessageSource独享
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			// 将DelegatingMessageSource对象注册到bean工厂
			// 即设置到bean工厂的singletonObjects、earlySingletonObjects、manualSingletonNames属性中
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
			}
		}
	}

initMessageSource阶段为当前bean工厂初始化一个MessageSource，用于支持国际化消息。

1.8 initApplicationEventMulticaster

	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 {
			// 实例化SimpleApplicationEventMulticaster，该类包含bean工厂
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			// 向bean工厂注册名为applicationEventMulticaster的SimpleApplicationEventMulticaster
			// 设置到bean工厂的singletonObjects、earlySingletonObjects、manualSingletonNames属性中
			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() + "]");
			}
		}
	}

initApplicationEventMulticaster阶段为当前bean工厂初始化一个ApplicationEventMulticaster。用于事件发布。

1.9 onRefresh

	protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

模板方法，留给子类实现。在SpringBoot中，spring-boot-starter-web启动器在这里启动内置的Tomcat。

1.10 registerListeners

	protected void registerListeners() {
		// 将静态的监听器添加到事件多播器里，ApplicationEventMulticaster.defaultRetriever.applicationListeners
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}
		
		// 获取类型为ApplicationListener的beanName，添加到事件多播器的属性dApplicationEventMulticaster.defaultRetriever.applicationListenerBeans
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 发布早期的应用程序事件
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

将所有ApplicationListener监听器添加到bean工厂的ApplicationEventMulticaster事件多播器中，具体存放在事件多播器的内部类DefaultListenerRetriever的applicationListeners集合中，并发布早期事件。

1.11 finishBeanFactoryInitialization

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 如果包含conversionService名称并且存在ConversionService类型，实例化名称为conversionService的ConversionService
		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));
		}

		// 给bean工厂embeddedValueResolvers添加lambda表达式，用于环境的PropertySourcesPropertyResolver解析属性值
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 获取类型为LoadTimeWeaverAware的beanName，不为空则实例化
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 停止使用临时 ClassLoader 进行类型匹配。
		beanFactory.setTempClassLoader(null);

		// 冻结所有bean定义，同时bean工厂缓存bean定义元数据
		// 清除合并元数据缓存
		// 设置configurationFrozen属性为true
		// 将集合beanDefinitionNames赋值给frozenBeanDefinitionNames数组
		beanFactory.freezeConfiguration();

		// 实例化所有非惰性加载的bean
		// 如果bean实现了SmartInitializingSingleton接口，则调用其afterSingletonsInstantiated方法
		// SmartInitializingSingleton:在BeanFactory引导期间的单例预实例化阶段结束时触发的回调接口，可执行一些初始化, 从这个意义上说，它是InitializingBean的一种替代方案
		beanFactory.preInstantiateSingletons();
	}

finishBeanFactoryInitialization方法是实例化bean的阶段，该方法先将ConversionService、LoadTimeWeaverAware这些Bean通过调用getBean方法给初始化，然后调用beanfactory.freezeConfiguration冻结Bean工厂中的BeanDefinition，不允许进一步更改，最后，调用preInstantiateSingletons来预实例化singleton。
具体实例化步骤则为我们熟悉的getBean、doGetBean、createBean、doCreateBean等方法，不在这里展开。

1.12 finishRefresh

	protected void finishRefresh() {
		// 清除上下文级别的资源缓存，开启扫描才有缓存
		clearResourceCaches();

		// 初始化生命周期处理器
		initLifecycleProcessor();

		// 调用生命周期处理器LifecycleProcessor的onRefresh方法
		// 获取类型为Lifecycle的bean，并调用其start方法
		getLifecycleProcessor().onRefresh();

		// 发布ContextRefreshedEvent事件
		publishEvent(new ContextRefreshedEvent(this));
	}

完成刷新过程做三件事。

	private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap<>(4);

	public void clearResourceCaches() {
		this.resourceCaches.clear();
	}

• 第一部分清除上下文资源缓存。

	protected void initLifecycleProcessor() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 如果存在名称为lifecycleProcessor的bean，则获取lifecycleProcessor赋值给上下文的lifecycleProcessor
		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
			this.lifecycleProcessor =
					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
			}
		}
		else {
			// 没有则默认创建一个DefaultLifecycleProcessor，包含bean工厂，将该实例赋值给上下文的lifecycleProcessor
			DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
			defaultProcessor.setBeanFactory(beanFactory);
			this.lifecycleProcessor = defaultProcessor;
			// 将DefaultLifecycleProcessor注册到bean工厂，设置到bean工厂的singletonObjects、earlySingletonObjects、manualSingletonNames属性中
			beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
						"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
			}
		}
	}

• 第二部分为当前上下文初始化LifecycleProcessor生命周期处理器，并调用DefaultLifecycleProcessor 的onfresh方法。

public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware {

	@Override
	public void onRefresh() {
		startBeans(true);
		this.running = true;
	}
	
	private void startBeans(boolean autoStartupOnly) {
		// 获取类型为Lifecycle的bean
		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
		Map<Integer, LifecycleGroup> phases = new TreeMap<>();

		lifecycleBeans.forEach((beanName, bean) -> {
			if (!autoStartupOnly || (bean instanceof SmartLifecycle smartLifecycle && smartLifecycle.isAutoStartup())) {
				// 按getPhase的int值分组
				// 如果是Lifecycle接口，则为0
				// 如果是SmartLifecycle接口，则为Integer.MAX_VALUE(0x7fffffff)
				// 或者是重写的值
				int phase = getPhase(bean);
				phases.computeIfAbsent(
						phase,
						p -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
				).add(beanName, bean);
			}
		});
		if (!phases.isEmpty()) {
			phases.values().forEach(LifecycleGroup::start);
		}
	}
	
	protected Map<String, Lifecycle> getLifecycleBeans() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		Map<String, Lifecycle> beans = new LinkedHashMap<>();
		// 获取类型为Lifecycle的beanName
		String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
		for (String beanName : beanNames) {
			// 获取规范的bean名称
			String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
			// 判断是否为工厂bean
			boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister);
			String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
			// bean工厂包含该bean示例，非工厂bean、类型属于Lifecycle或SmartLifecycle，则将该实例放入beans集合中，最终返回该集合
			if ((beanFactory.containsSingleton(beanNameToRegister) &&
					(!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) ||
					matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) {
				Object bean = beanFactory.getBean(beanNameToCheck);
				if (bean != this && bean instanceof Lifecycle lifecycle) {
					beans.put(beanNameToRegister, lifecycle);
				}
			}
		}
		return beans;
	}

	// 省略其他代码...
}

进入DefaultLifecycleProcessor #onfresh方法，进一步调用DefaultLifecycleProcessor #startBeans方法，并设置runngin属性为true。

startBeans方法方法中，首先调用getLifecycleBeans方法根据Lifecycle类型的bean实例并返回，筛选出SmartLifecycle的子类且isAutoStartup=true的bean示例，然后将这些实例按照phase值分组，并将SmartLifecycle类型的bean实例转换成LifecycleGroup对象，调用LifecycleGroup#start方法

	private class LifecycleGroup {
		public void start() {
			if (this.members.isEmpty()) {
				return;
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Starting beans in phase " + this.phase);
			}
			// 实现了Comparable接口，按getPhase获取的值排序
			Collections.sort(this.members);
			for (LifecycleGroupMember member : this.members) {
				doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
			}
		}
		
		private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
			Lifecycle bean = lifecycleBeans.remove(beanName);
			if (bean != null && bean != this) {
				// 返回指定bean所依赖的所有bean的名称,
				String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
				for (String dependency : dependenciesForBean) {
					doStart(lifecycleBeans, dependency, autoStartupOnly);
				}
				// 调用Lifecycle#start方法
				// bean未运行，autoStartupOnly为false或bean不是SmartLifecycle的子类或smartLifecycle.isAutoStartup为true
				if (!bean.isRunning() &&
						(!autoStartupOnly || !(bean instanceof SmartLifecycle smartLifecycle) || smartLifecycle.isAutoStartup())) {
					if (logger.isTraceEnabled()) {
						logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
					}
					try {
						bean.start();
					}
					catch (Throwable ex) {
						throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Successfully started bean '" + beanName + "'");
					}
				}
			}
		}
	}

进入LifecycleGroup#start方法，方法体内继续调用 doStart方法，如果实现了SmartLifecycle接口的bean实例，则最终调用生命周期Lifecycle#start方法。Lifecycle和SmartLifecycle主要区别在于Lifecycle需要我们显示调用org.springframework.context.support.AbstractApplicationContext#start方法才会触发start方法，stop方法也一样。

	@Override
	public void publishEvent(ApplicationEvent event) {
		publishEvent(event, null);
	}
	
	protected void publishEvent(Object event, @Nullable ResolvableType typeHint) {
		Assert.notNull(event, "Event must not be null");
		ResolvableType eventType = null;

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent applEvent) {
			applicationEvent = applEvent;
			eventType = typeHint;
		}
		else {
			ResolvableType payloadType = null;
			if (typeHint != null && ApplicationEvent.class.isAssignableFrom(typeHint.toClass())) {
				eventType = typeHint;
			}
			else {
				payloadType = typeHint;
			}
			applicationEvent = new PayloadApplicationEvent<>(this, event, payloadType);
		}

		// Determine event type only once (for multicast and parent publish)
		if (eventType == null) {
			eventType = ResolvableType.forInstance(applicationEvent);
			if (typeHint == null) {
				typeHint = eventType;
			}
		}

		// Multicast right now if possible - or lazily once the multicaster is initialized
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// Publish event via parent context as well...
		// 如果父上下文不为空，也发布事件
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext abstractApplicationContext) {
				abstractApplicationContext.publishEvent(event, typeHint);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}

• 第三部分调用上下文的事件多播器ApplicationEventMulticaster发布ContextRefreshedEvent事件。

1.13 resetCommonCaches

	protected void resetCommonCaches() {
		ReflectionUtils.clearCache();
		AnnotationUtils.clearCache();
		ResolvableType.clearCache();
		CachedIntrospectionResults.clearClassLoader(getClassLoader());
	}

最后清空重Spring 的常见反射元数据缓存。

2. refresh异常

	catch (BeansException ex) {
		if (logger.isWarnEnabled()) {
			logger.warn("Exception encountered during context initialization - " +
					"cancelling refresh attempt: " + ex);
		}

		// 销毁已创建的单例bean
		destroyBeans();

		// 设置“active”属性为false
		// 清空bean工厂序列化id
		cancelRefresh(ex);

		throw ex;
	}

如果在refresh过程中发生BeansException异常，则会调用destroyBeans方法销毁bean实例，并且设置激活标记为false。

2.1 destroyBeans

	protected void destroyBeans() {
		getBeanFactory().destroySingletons();
	}

进入destroyBeans方法，方法内调用bean工厂的destroySingletons方法。

有两个子类实现了destroySingletons方法

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
	@Override
	public void destroySingletons() {
		super.destroySingletons();
		// 将bean工厂属性manualSingletonNames清空，手动注册的单例名称列表
		updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
		// 将bean工厂属性allBeanNamesByType集合、singletonBeanNamesByType集合清空
		// 按类型映射的结合，
		clearByTypeCache();
	}
	// 省略其他代码...
}

DefaultListableBeanFactory 除了清空bean工厂的部分缓存，主要调用其父类的destroySingletons方法。

DefaultListableBeanFactory 还是调用DefaultSingletonBeanRegistry的destroySingletons方法。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	private final Map<String, DisposableBean> disposableBeans = new LinkedHashMap<>();
	
	public void destroySingletons() {
		if (logger.isTraceEnabled()) {
			logger.trace("Destroying singletons in " + this);
		}
		// 单例对象缓存map加锁，bean工厂属性singletonsCurrentlyInDestruction设置为true，标志正在销毁单例
		synchronized (this.singletonObjects) {
			this.singletonsCurrentlyInDestruction = true;
		}

		// key为bean名称，value为DisposableBean的实现类
		// 创建对象的地方在org.springframework.beans.factory.support.AbstractBeanFactory#registerDisposableBeanIfNecessary
		// disposableBeans实现了在doCreateBean的new设置进去，比如一个名称为user的bean，则就会有一个名称为user的DisposableBeanAdapter，用于在bean的声明周期中销毁bean
		String[] disposableBeanNames;
		synchronized (this.disposableBeans) {
			disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
		}
		// 循环调用destroySingleton销毁bean
		for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
			destroySingleton(disposableBeanNames[i]);
		}

		// 清空map
		// 两个bean之间的关系map
		this.containedBeanMap.clear();
		// key为bean的名称，value为其属性bean名称的Map
		this.dependentBeanMap.clear();
		// key为bean的名称，value为其依赖别的bean名称的Map
		this.dependenciesForBeanMap.clear();

		// 清除所有缓存的单例实例缓存map
		clearSingletonCache();
	}
	// 省略其他代码
}

DefaultSingletonBeanRegistry#destroySingletons方法获取当前bean工厂disposableBeans属性Map中的key，即bean实例名称集合，进一步调用destroySingleton方法。最后同样清空bean工厂缓存。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	private final Map<String, DisposableBean> disposableBeans = new LinkedHashMap<>();
	
	public void destroySingleton(String beanName) {
		// 删除单例缓存中给定名称的bean
		removeSingleton(beanName);

		// 将disposableBean实现类DisposableBeanAdapter拿出来,调用包含实际销毁bean的方法destroyBean
		DisposableBean disposableBean;
		synchronized (this.disposableBeans) {
			disposableBean = this.disposableBeans.remove(beanName);
		}
		destroyBean(beanName, disposableBean);
	}
	// 省略其他代码
}

进入destroySingleton方法，该先从单例相关缓存池子移除bean实例，再从disposableBeans属性Map中根据beanName获取DisposableBean 实例，调用destroyBean方法。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
		Set<String> dependencies;
		synchronized (this.dependentBeanMap) {
			dependencies = this.dependentBeanMap.remove(beanName);
		}
		// 如果当前bean属性有其他bean，递归调用destroySingleton
		if (dependencies != null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
			}
			for (String dependentBeanName : dependencies) {
				destroySingleton(dependentBeanName);
			}
		}

		// 这里才是真正销毁bean的操作
		if (bean != null) {
			try {
				// 这里调用的是org.springframework.beans.factory.support.DisposableBeanAdapter.destroy
				// 如果销毁的bean实现了DisposableBean接口，先调用bean的destroy方法
				// 下一步调用AutoCloseable接口的close方法
				// 再调用bean的destroyMethod，如果有声明的的话
				bean.destroy();
			}
			catch (Throwable ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
				}
			}
		}

		Set<String> containedBeans;
		synchronized (this.containedBeanMap) {
			// Within full synchronization in order to guarantee a disconnected Set
			containedBeans = this.containedBeanMap.remove(beanName);
		}
		if (containedBeans != null) {
			for (String containedBeanName : containedBeans) {
				destroySingleton(containedBeanName);
			}
		}

		synchronized (this.dependentBeanMap) {
			for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
				Map.Entry<String, Set<String>> entry = it.next();
				Set<String> dependenciesToClean = entry.getValue();
				dependenciesToClean.remove(beanName);
				if (dependenciesToClean.isEmpty()) {
					it.remove();
				}
			}
		}

		this.dependenciesForBeanMap.remove(beanName);
	}
	// 省略其他代码
}

destroyBean方法中，先从bean工厂的dependentBeanMap缓存池中判断名称为“beanName”的bean实例属性中是否依赖了其他bean实例，递归调用destroySingleton方法销毁。具体销毁操作在bean.destroy()；这一行代码。那么bean是什么。从destroyBean的方法参数中我们知道“bean”是实现了DisposableBean接口的实例对象，同时我们也知道是从bean工厂的disposableBeans池子中取出的对象，对象具体是DisposableBean的哪个实现类要回到refresh的finishBeanFactoryInitialization阶段，创建bean实例的步骤。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

	private final Map<String, DisposableBean> disposableBeans = new LinkedHashMap<>();
	
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// 省略其他代码...
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		// 省略其他代码...
	}
	
	protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
		if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
			if (mbd.isSingleton()) {
				registerDisposableBean(beanName, new DisposableBeanAdapter(
						bean, beanName, mbd, getBeanPostProcessorCache().destructionAware));
			}
			else {
				Scope scope = this.scopes.get(mbd.getScope());
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
				}
				scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
						bean, beanName, mbd, getBeanPostProcessorCache().destructionAware));
			}
		}
	}
	
	public void registerDisposableBean(String beanName, DisposableBean bean) {
		synchronized (this.disposableBeans) {
			this.disposableBeans.put(beanName, bean);
		}
	}
	// 省略其他代码...
}

具体位置在org.springframework.beans.factory.support.AbstractBeanFactory#registerDisposableBeanIfNecessary，实例化bean对象的时候，doCreateBean方法会调用registerDisposableBeanIfNecessary方法，实例化一个DisposableBeanAdapter对象，放到bean工厂的disposableBeans池子中，key为bean的名称，value为DisposableBeanAdapter对象，销毁bean实际操作即调用DisposableBeanAdapter#destroy方法。

class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {

	@Override
	public void destroy() {
		if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
			for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
				processor.postProcessBeforeDestruction(this.bean, this.beanName);
			}
		}

		// 执行bean的destroy方法，如果bean实现了DisposableBean接口
		if (this.invokeDisposableBean) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
			}
			try {
				((DisposableBean) this.bean).destroy();
			}
			catch (Throwable ex) {
				if (logger.isWarnEnabled()) {
					String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
					if (logger.isDebugEnabled()) {
						// Log at warn level like below but add the exception stacktrace only with debug level
						logger.warn(msg, ex);
					}
					else {
						logger.warn(msg + ": " + ex);
					}
				}
			}
		}

		// 执行bean的close方法
		if (this.invokeAutoCloseable) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking close() on bean with name '" + this.beanName + "'");
			}
			try {
				((AutoCloseable) this.bean).close();
			}
			catch (Throwable ex) {
				if (logger.isWarnEnabled()) {
					String msg = "Invocation of close method failed on bean with name '" + this.beanName + "'";
					if (logger.isDebugEnabled()) {
						logger.warn(msg, ex);
					}
					else {
						logger.warn(msg + ": " + ex);
					}
				}
			}
		}
		// 调用bean的destroyMethod方法
		else if (this.destroyMethods != null) {
			for (Method destroyMethod : this.destroyMethods) {
				invokeCustomDestroyMethod(destroyMethod);
			}
		}
		else if (this.destroyMethodNames != null) {
			for (String destroyMethodName : this.destroyMethodNames) {
				Method destroyMethod = determineDestroyMethod(destroyMethodName);
				if (destroyMethod != null) {
					invokeCustomDestroyMethod(
							ClassUtils.getInterfaceMethodIfPossible(destroyMethod, this.bean.getClass()));
				}
			}
		}
	}
	// 省略其他代码...
}

查看DisposableBeanAdapter#destroy的源码，销毁步骤是

• 调用销毁前的回调接口DestructionAwareBeanPostProcessor，如果有。
• 执行bean的destroy方法，如果bean实现了DisposableBean接口。
• 执行bean的close方法，如果bean实现了AutoCloseable接口。
• 执行bean的destroyMethod方法，如果bean有声明。

2.2 cancelRefresh

cancelRefresh方法除了设置active标记为false，其有两个实现类。

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	@Override
	protected void cancelRefresh(BeansException ex) {
		DefaultListableBeanFactory beanFactory = this.beanFactory;
		if (beanFactory != null) {
			beanFactory.setSerializationId(null);
		}
		super.cancelRefresh(ex);
	}
}

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	@Override
	protected void cancelRefresh(BeansException ex) {
		this.beanFacto	ry.setSerializationId(null);
		super.cancelRefresh(ex);
	}
}

两个子类都是将bean工厂的serializationId置空。

参考

• 【Spring总结】Refresh
• ApplicationContext源码浅析