SpringBoot源码解析(七)：应用上下文结构体系

SpringBoot源码系列文章

SpringBoot源码解析(一)：SpringApplication构造方法

SpringBoot源码解析(二)：引导上下文DefaultBootstrapContext

SpringBoot源码解析(三)：启动开始阶段

SpringBoot源码解析(四)：解析应用参数args

SpringBoot源码解析(五)：准备应用环境

SpringBoot源码解析(六)：打印Banner

SpringBoot源码解析(七)：应用上下文结构体系

前言

  在解析SpringBoot源码之前，需要对其使用的应用上下文（ApplicationContext）相关组件有清晰的了解。SpringBoot的核心在于基于Spring的扩展，其自动配置机制、嵌入式Web容器等特性都依赖于一套规范的上下文组件。因此，提前理清这些核心组件的功能和职责，可以显著提高源码阅读的效率，避免频繁地在代码中跳转而迷失方向。

  SpringBoot在调用SpringApplication.run()方法启动时，根据应用类型（如 Servlet 类型）通过createApplicationContext()方法推断并创建AnnotationConfigServletWebServerApplicationContext，用于初始化和管理 Web 应用的上下文环境。

一、AnnotationConfigServletWebServerApplicationContext类图

  类图如下（摆这个图用我好长时间🙇‍♂️），每个类的作用将在下面进行简要分析。

二、AnnotationConfigServletWebServerApplicationContext组件功能解析

1、BeanFactory（Bean管理核心接口）

  BeanFactory是Spring框架中最基础的IOC（Inversion of Control，控制反转）容器接口，它负责创建、管理和配置应用中的Bean（对象），并处理Bean的依赖注入与生命周期管理。BeanFactory支持延迟加载（懒加载），即在首次请求时才实例化Bean，适用于轻量级应用或资源受限的环境。

public interface BeanFactory {
    // bean名称前加&，返回的FactoryBean工厂实例，否则返回实际创建类型实例
    String FACTORY_BEAN_PREFIX = "&";

	// 根据指定的名称获取Bean实例
	// 返回的实例可能是单例模式下的共享实例，也可能是每次请求都会创建的新实例，具体取决于 Bean 的配置
	// 如果容器中不存在该名称的 Bean，则会抛出异常
    Object getBean(String name) throws BeansException;
	
	// 根据指定的名称和类型获取Bean实例
	// 如果名称对应的 Bean 类型与指定的类型不匹配，则会抛出异常
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
	
	// 根据指定的名称和参数获取Bean实例
    Object getBean(String name, Object... args) throws BeansException;

    // 根据指定的类型获取唯一匹配的Bean实例
    // 如果容器中不存在该类型的 Bean，或者存在多个该类型的 Bean，则会抛出异常 
    <T> T getBean(Class<T> requiredType) throws BeansException;

	// 根据指定的类型和参数获取Bean实例
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	// 返回一个可以提供指定类型Bean的ObjectProvider对象
	// ObjectProvider不会立即实例化Bean，只有在调用其方法时才会加载或创建Bean
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	// 通过ResolvableType，可以获取复杂类型或泛型Bean
	// 可以定义复杂的泛型结构，如 List<MyBean>、Map<String, MyBean> 等
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	// 检查容器中是否存在指定名称的 Bean
    boolean containsBean(String name);

	// 检查指定名称的Bean是否为单例（一个类只能有一个实例）
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	// 检查指定名称的Bean是否为原型（每次获取返回一个新实例）
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	// 检查指定名称的Bean是否匹配某个ResolvableType
	// 例如，检查一个Bean是否是List<String>类型
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	// 检查指定名称的Bean是否匹配某个Class类型
	// 这是基础的类型匹配检查，不支持泛型，但速度更快
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	// 返回Bean的Class类型（不考虑FactoryBean情况）
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	// 返回Bean的Class类型
	// allowFactoryBeanInit=true,初始化FactoryBean返回实际类型
    @Nullable
    Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	// 获取Bean的所有别名
    String[] getAliases(String name);
}

2、HierarchicalBeanFactory（支持父子容器）

  HierarchicalBeanFactory是Spring框架中定义的一个接口，它扩展了BeanFactory，用于支持Bean工厂的层次化结构管理。它的设计目的是允许一个Bean工厂拥有父级Bean工厂，并能够在当前Bean工厂和父级工厂之间协调Bean的管理和查找。

public interface HierarchicalBeanFactory extends BeanFactory {
	// 返回父级Bean工厂，如果没有父级，则返回null
	@Nullable
	BeanFactory getParentBeanFactory();
	// 判断本地 Bean 工厂是否包含指定名称的 Bean，忽略父级上下文中定义的 Bean
	boolean containsLocalBean(String name);
}

3、ListableBeanFactory（批量获取Bean）

  ListableBeanFactory是Spring框架中的一个接口，它扩展了BeanFactory，提供了按照类型、名称等多种方式列出Bean的功能。它是Spring应用上下文中一个核心接口，用于管理和访问Bean。

// "只考虑当前工厂"：检查范围限定为当前工厂的直接定义部分
// "不考虑层次结构"：不会递归查询父工厂或祖先工厂中的定义
public interface ListableBeanFactory extends BeanFactory {	

	// 检查此 Bean 工厂是否包含具有给定名称的 Bean 定义
	boolean containsBeanDefinition(String beanName);
	// 返回工厂中定义的 Bean 数量
	int getBeanDefinitionCount();
	// 返回此工厂中定义的所有 Bean 的名称
	String[] getBeanDefinitionNames();
	
	// 返回一个可以提供指定类型Bean的ObjectProvider对象，可选择是否延迟初始化
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit);
	// 返回一个可以提供复杂指定类型Bean的ObjectProvider对象，可选择是否延迟初始化
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit);

	// 返回与给定类型（包括给定类型子类）匹配的 Bean 名称
	String[] getBeanNamesForType(ResolvableType type);
	// 返回与给定复杂类型（包括给定子类）匹配的 Bean 名称
	// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
	String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
	// 返回与给定类型（包括子类）匹配的 Bean 名称
	String[] getBeanNamesForType(@Nullable Class<?> type);
	// 返回与给定类型（包括子类）匹配的 Bean 名称
	// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);


	// 返回一个 Map，包含匹配的 Bean 名称和对应的 Bean 实例
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
	// 返回一个 Map，包含匹配的 Bean 名称和对应的 Bean 实例
	// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

	// 查找带有指定注解的所有 Bean 名称
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
	// 一个 Map，包含匹配的 Bean 名称和对应带指定注解的Bean实例
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

	// 用于查找指定 Bean 上的特定类型注解，并返回该注解的实例
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

	// 用于查找指定 Bean 上的特定注解，并提供一个参数来控制是否允许初始化 FactoryBean
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(
			String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
			throws NoSuchBeanDefinitionException;
}

4、MessageSource（国际化消息支持）

  MessageSource是SpringFramework中用于国际化的接口，主要用来处理应用程序中的多语言消息。它允许你根据用户的语言环境（Locale）来动态加载和显示相应的消息。这对于支持多语言的应用程序非常重要。

// 消息解析的策略接口，支持消息的参数化和国际化
public interface MessageSource {
	// 尝试解析指定代码的消息，如果找不到则返回默认消息
	@Nullable
	String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);

	// 尝试解析消息。如果未找到消息，视为错误并抛出异常
	String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException;

	// 根据传入的 MessageSourceResolvable 参数解析消息，若未找到对应消息，抛出异常
	String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
}

5、EnvironmentCapable（环境变量访问能力）

  EnvironmentCapable是SpringFramework中的一个接口，它定义了获取Environment的能力。Environment是Spring的核心抽象之一，用于表示当前应用程序的环境信息，比如操作系统属性、配置属性、环境变量等。

public interface EnvironmentCapable {
	// 返回一个 Environment 对象，Environment 提供了多个方法来获取配置信息
	Environment getEnvironment();
}

6、ResourcePatternResolver（资源路径解析器）

  ResourcePatternResolver是Spring框架中的一个接口，用于将路径模式（如通配符 * 和 **）解析为资源（Resource）对象。简单来说，它提供了一种机制，可以通过路径模式加载符合条件的资源文件，比如从类路径、文件系统或 JAR 文件中加载多个资源。

public interface ResourcePatternResolver extends ResourceLoader {

	// 用于从类路径中匹配所有资源的伪 URL 前缀："classpath*:"
	String CLASSPATH_ALL_URL_PREFIX = "classpath*:";

	// 解析给定路径的资源，解析为Resource对象
	Resource[] getResources(String locationPattern) throws IOException;
}

7、ApplicationEventPublisher（发布事件）

  ApplicationEventPublisher是SpringFramework中的一个接口，用于将事件发布给监听器。它是Spring事件驱动编程模型的核心组件之一，能够实现组件之间的解耦通信。之前文章Spring发布-订阅模式：解耦与异步通信的高效实现对于此类有详细介绍

// 一个封装事件发布功能的接口
@FunctionalInterface
public interface ApplicationEventPublisher {
	// 默认方法，最终还是调用publishEvent(Object event)方法
	default void publishEvent(ApplicationEvent event) {
		publishEvent((Object) event);
	}
	// 发布事件
	void publishEvent(Object event);
}

8、ApplicationContext（应用上下文核心接口）

  ApplicationContext是Spring框架中的一个中央接口，它提供了对Bean工厂、事件发布、消息解析等核心功能的统一访问。

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	// 返回此应用程序上下文的唯一标识符，没有返回null
	@Nullable
	String getId();

	// 返回该上下文所属的已部署应用程序的名称，默认为空字符串
	String getApplicationName();
	
	// 返回此上下文的友好名称（显示名称），不会为null
	String getDisplayName();

	// 返回此上下文第一次加载时的时间戳（以毫秒为单位）
	long getStartupDate();

	// 父上下文，如果没有则返回null
	@Nullable
	ApplicationContext getParent();

	// 这个方法的作用是让开发者能够访问底层的 BeanFactory，从而手动管理和操作 Bean 的生命周期和依赖注入
	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

9、Lifecycle（Bean生命周期管理接口）

  Lifecycle是一个通用的生命周期接口，定义了组件的启动、停止和运行状态检查方法，通常用于控制具有生命周期管理能力的组件（如线程、定时任务、消息监听器等）。

public interface Lifecycle {

	// 启动组件，对于容器，它会将启动信号传播到容器内所有相关的子组件
	void start();

	// 停止组件，通常是同步操作，确保组件在方法返回时完全停止
	void stop();

	// 检查组件是否正在运行，只有当所有相关的子组件都运行时，才返回 true
	boolean isRunning();
}

10、ConfigurableApplicationContext（可配置应用上下文）

  ConfigurableApplicationContext是Spring应用上下文接口的扩展，定义了可配置的应用上下文，主要用于管理、配置和控制Spring 应用上下文的生命周期。它在 ApplicationContext 的基础上增加了许多高级功能，例如上下文刷新、关闭、父上下文设置等。

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {

	// 配置路径中多个配置路径之间的分隔符字符
	// 可以是逗号 (`,`)、分号 (`;`)、空格 (` `)、制表符 (`\t`) 或换行符 (`\n`)
	String CONFIG_LOCATION_DELIMITERS = ",; \t\n";

	// BeanFactory 中 ConversionService bean 的名称
	String CONVERSION_SERVICE_BEAN_NAME = "conversionService";

	// BeanFactory 中 LoadTimeWeaver bean 的名称
	String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";

	// BeanFactory 中 Environment bean 的名称
	String ENVIRONMENT_BEAN_NAME = "environment";

	// BeanFactory 中系统属性的 Bean 名称
	String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";

	// BeanFactory 中系统环境变量的 Bean 名称
	String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";

	// BeanFactory 中 ApplicationStartup bean 的名称
	// 收集和记录应用程序启动过程中的性能指标，省略不细讲
	String APPLICATION_STARTUP_BEAN_NAME = "applicationStartup";

	// JVM 中关闭钩子线程的默认名称
	String SHUTDOWN_HOOK_THREAD_NAME = "SpringContextShutdownHook";

	// 设置此应用程序上下文的唯一 ID
	void setId(String id);

	// 设置此应用程序上下文的父上下文
	void setParent(@Nullable ApplicationContext parent);

	// 设置此应用程序上下文的Environment
	void setEnvironment(ConfigurableEnvironment environment);

	// 返回此应用程序上下文的Environment
	@Override
	ConfigurableEnvironment getEnvironment();

	// 添加一个工厂处理器BeanFactoryPostProcessor，该处理器将在刷新时应用于内部 bean 工厂
	void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);

	// 添加一个新的 ApplicationListener，该监听器将在上下文事件（如刷新或关闭）时被通知
	void addApplicationListener(ApplicationListener<?> listener);

	// 加载或刷新配置的持久化表示，例如基于 Java 配置、XML 文件、属性文件等
	void refresh() throws BeansException, IllegalStateException;

	// 向 JVM 注册一个关闭钩子，在 JVM 关闭时关闭此上下文
	void registerShutdownHook();
	
	// 关闭此应用程序上下文，释放所有资源并销毁所有缓存的单例 bean
	@Override
	void close();

	// 确定此应用程序上下文是否处于活动状态
	boolean isActive();

	// 返回此应用程序上下文的内部 BeanFactory
	ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
}

11、WebApplicationContext（web应用上下文）

  WebApplicationContext是Spring框架中专门为Web应用设计的上下文接口。它扩展了ApplicationContext，增加了与Servlet API的集成功能，例如访问 ServletContext，支持Web特定的作用域（如request和session），并且通过分层结构实现了灵活的上下文管理。

public interface WebApplicationContext extends ApplicationContext {

	// 常量，表示根 WebApplicationContext 在启动过程中绑定到的属性名称
	// 用于在 Web 应用程序中查找根上下文，例如通过 WebApplicationContextUtils 工具类
	String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";

	// 分别对应请求范围（request）、会话范围（session）、全局应用范围（application）
	String SCOPE_REQUEST = "request";
	String SCOPE_SESSION = "session";
	String SCOPE_APPLICATION = "application";

	// 定义了 ServletContext 在 Spring 容器中的 Bean 名称
	String SERVLET_CONTEXT_BEAN_NAME = "servletContext";

	// 定义了 ServletContext 初始化参数（init-params）在 Spring 容器中的 Bean 名称。
	// 如果参数在 ServletConfig 和 ServletContext 中同名，则 ServletConfig 参数优先。
	String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";

	// 定义了 ServletContext 属性（attributes）在 Spring 容器中的 Bean 名称
	String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";

	// 返回当前应用程序的 ServletContext 对象。
	// 可用于直接访问与 Web 应用程序相关的上下文信息
	@Nullable
	ServletContext getServletContext();
}

12、ConfigurableWebApplicationContext（可配置web应用上下文）

  ConfigurableWebApplicationContext是一个用于管理和配置Web应用上下文的接口，支持与Servlet环境集成、动态加载配置文件以及命名空间管理。

// 此接口主要用于管理基于 Web 的应用程序上下文，并提供特定于 Web 环境的配置方法
public interface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext {

	// 用于引用上下文路径和/或 Servlet 名称的 ApplicationContext id 前缀
	String APPLICATION_CONTEXT_ID_PREFIX = WebApplicationContext.class.getName() + ":";

	// 在工厂中表示 ServletConfig 环境 Bean 的名称
	String SERVLET_CONFIG_BEAN_NAME = "servletConfig";

	// 设置此 Web 应用程序上下文的 ServletContext
	void setServletContext(@Nullable ServletContext servletContext);
	// 设置此 Web 应用程序上下文的 ServletConfig
	void setServletConfig(@Nullable ServletConfig servletConfig);
	// 返回此 Web 应用程序上下文的 ServletConfig（如果有）
	@Nullable
	ServletConfig getServletConfig();


	// 设置此 Web 应用程序上下文的命名空间
	void setNamespace(@Nullable String namespace);
	// 返回此 Web 应用程序上下文的命名空间（如果有）
	@Nullable
	String getNamespace();

	
	// 以 init-param 样式设置此 Web 应用程序上下文的配置位置
	void setConfigLocation(String configLocation);
	// 设置此 Web 应用程序上下文的配置位置
	void setConfigLocations(String... configLocations);
	// 返回此 Web 应用程序上下文的配置位置
	@Nullable
	String[] getConfigLocations();
}

13、WebServerApplicationContext（web服务应用上下文）

  WebServerApplicationContext专门用于管理嵌入式Web服务器（如Tomcat、Jetty 或 Undertow）的生命周期。它提供了与Web服务器交互的抽象，支持启动、停止和运行时管理Web服务器的状态。

public interface WebServerApplicationContext extends ApplicationContext {

	// 返回由上下文创建的内嵌的 Web 服务器实例，如果服务器尚未创建，则返回null
	WebServer getWebServer();
	
	// 返回Web服务器应用程序上下文的命名空间，如果未设置命名空间，则返回null
	String getServerNamespace();

	// 判断指定的上下文是否为WebServerApplicationContext，且具有匹配的服务器命名空间
	static boolean hasServerNamespace(ApplicationContext context, String serverNamespace) {
		return (context instanceof WebServerApplicationContext) && ObjectUtils
			.nullSafeEquals(((WebServerApplicationContext) context).getServerNamespace(), serverNamespace);
	}

	 // 如果指定的上下文是WebServerApplicationContext，则返回其服务器命名空间
	static String getServerNamespace(ApplicationContext context) {
		return (context instanceof WebServerApplicationContext)
				? ((WebServerApplicationContext) context).getServerNamespace() : null;

	}

}

// 简单的接口，表示一个完全配置的 Web 服务器（例如 Tomcat、Jetty 或 Netty）
public interface WebServer {
	
	// 启动 Web 服务器
	void start() throws WebServerException;

	// 停止 Web 服务器。
	void stop() throws WebServerException;
	
	// 返回监听的端口号，如果未分配端口则返回 -1
	int getPort();

	// 允许在不影响现有请求的情况下优雅地关闭服务器
	// 默认实现是直接返回立即关闭的结果，可以被覆盖实现实际的关闭逻辑
	default void shutDownGracefully(GracefulShutdownCallback callback) {
		// 默认行为：直接调用回调函数，立即完成关闭（不实际执行关闭逻辑）
		callback.shutdownComplete(GracefulShutdownResult.IMMEDIATE);
	}
}

14、ConfigurableWebServerApplicationContext（可配置web服务应用上下文）

  ConfigurableWebServerApplicationContext是一个用于配置和管理嵌入式Web服务器的Spring应用上下文接口，支持动态配置、服务器命名空间设置以及上下文生命周期管理。

// 通过此接口，开发者可以在 Web 服务器应用上下文中进行更灵活的配置和管理
public interface ConfigurableWebServerApplicationContext
		extends ConfigurableApplicationContext, WebServerApplicationContext {

	// 设置上下文的服务器命名空间。
	// 服务器命名空间通常用于区分不同的 Web 服务器实例或模块，尤其在复杂的微服务架构中非常有用。
	void setServerNamespace(String serverNamespace);
}

15、AbstractApplicationContext（抽象应用上下文）

  AbstractApplicationContext是Spring应用上下文的抽象实现类，负责提供通用的上下文生命周期管理、事件发布、资源加载以及BeanFactory的初始化等核心功能。

  所有具体的应用上下文（如 ClassPathXmlApplicationContext 和 AnnotationConfigApplicationContext）都继承自它。

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	... // 内容很多，这里只介绍下核心内容

	/**
	* 核心属性
	*/
	
	// bean工厂后置处理器
	// 在容器刷新时，允许在 Bean 定义加载完成但 Bean 实例化之前，修改 Bean 定义
	private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
	
	// 生命周期处理器，用于管理应用上下文中所有实现了 Lifecycle 接口的组件的启动和停止
	// 容器刷新时（onRefresh() 方法），启动所有实现了 Lifecycle 或 SmartLifecycle 接口的 Bean
	// 容器关闭时（onClose() 方法），停止所有实现了 Lifecycle 或 SmartLifecycle 接口的 Bean
	@Nullable
	private LifecycleProcessor lifecycleProcessor;

	// 事件广播器，负责将发布的事件分发给所有注册的监听器
	@Nullable
	private ApplicationEventMulticaster applicationEventMulticaster;

	// 用于存储在上下文刷新之前显式注册的 ApplicationListener
	// 这些监听器在容器初始化时注册，并在事件发布时被调用
	private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();


	/**
	* 核心方法
	*/
	
	// 核心方法，用于刷新上下文的配置和状态
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 1、刷新前预处理
			prepareRefresh();
			// 2、获取最新的bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 3、注册bean工厂的类加载器和部分后置处理器
			prepareBeanFactory(beanFactory);
			try {
				// 4、bean工厂的后置处理器（子类实现）
				postProcessBeanFactory(beanFactory);
				// 5、执行bean工厂的后置处理器
				invokeBeanFactoryPostProcessors(beanFactory);
				// 6、注册所有的后置处理器
				registerBeanPostProcessors(beanFactory);
				// 7、初始化国际化组件
				initMessageSource();
				// 8、初始化事件多播器（用来广播事件）
				initApplicationEventMulticaster();
				// 9、子类实现，扩展其他bean
				onRefresh();
				// 10、注册监听器
				registerListeners();
				// 11、实例化，初始化所有的非懒加载的单例bean
				finishBeanFactoryInitialization(beanFactory);
				// 12、最后刷新，发布相应事件
				finishRefresh();
			}
			catch (BeansException ex) {
				...
			}
		}
	}

	// 发布事件到所有监听器。如果事件多播器尚未初始化，将事件存储以供后续处理
	// ApplicationEventPublisher接口的实现
	@Override
	public void publishEvent(ApplicationEvent event) {
		...
	}

	// 注册 JVM 关闭钩子，确保上下文在 JVM 关闭时也能被正确关闭
	@Override
	public void registerShutdownHook() {
		...
	}
	
	// 关闭上下文，销毁所有单例 Bean，并发布关闭事件
	@Override
	public void close() {
		...
	}

}

16、BeanDefinitionRegistry（Bean定义注册接口）

  BeanDefinitionRegistry是Spring容器中用于管理Bean定义的核心接口，支持动态注册、移除、查询和别名管理，常用于扩展和动态操作容器内的 Bean 定义。

// 此接口是 Bean 定义注册的核心，用于动态管理 Bean 定义（注册、移除、查询等）
public interface BeanDefinitionRegistry extends AliasRegistry {

	// 向注册表中注册一个新的 BeanDefinition
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	// 移除给定名称的 BeanDefinition
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 返回给定名称的 BeanDefinition
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 检查此注册表是否包含具有给定名称的 BeanDefinition。
	boolean containsBeanDefinition(String beanName);

	// 返回此注册表中定义的所有 Bean 的名称
	String[] getBeanDefinitionNames();
	
	//  返回注册表中定义的 Bean 的数量。
	int getBeanDefinitionCount();

	 // 确定给定的 Bean 名称是否已经在此注册表中使用（即是否有本地 Bean 或别名注册了此名称）
	boolean isBeanNameInUse(String beanName);
}


/**
 * 管理别名的通用接口（提供了注册、删除、查询别名的方法）
 *
 * 别名是一种机制，用于为已有的名称提供额外的标识，
 * 通常用于配置中增加灵活性，例如为同一个 Bean 定义多个名称
 */
public interface AliasRegistry {

	// 为给定的名称注册一个别名
	void registerAlias(String name, String alias);

	// 从注册表中删除指定的别名
	void removeAlias(String alias);

	// 确定给定的名称是否被定义为别名（而不是实际注册的组件名称）
	boolean isAlias(String name);

	// 返回给定名称的所有别名（如果定义了别名）
	String[] getAliases(String name);
}

17、GenericApplicationContext（通用应用上下文）

  GenericApplicationContext是一个通用的Spring应用上下文容器，支持以编程方式注册Bean和灵活配置应用上下文

  DefaultListableBeanFactory内部组件较为复杂，下篇文章将单独对其内部组件进行详细解析。

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	... // 内容很多，这里只介绍下核心内容

	// 用于注册、管理和创建 Bean 定义，支持依赖注入和动态 Bean 管理
	private final DefaultListableBeanFactory beanFactory;
	
	// 用于统一加载文件、类路径、URL 等各种类型的资源
	@Nullable
	private ResourceLoader resourceLoader;
	
	// 根据给定路径加载单个资源，支持自定义协议解析和默认资源加载器
	@Override
	public Resource getResource(String location) {
		...
	}
	// 根据路径模式加载多个资源，优先使用资源加载器的路径解析能力
	@Override
	public Resource[] getResources(String locationPattern) throws IOException {
		...
	}
	
	
	@Override
	// 向底层 Bean 工厂注册一个新的 Bean 定义
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
	        throws BeanDefinitionStoreException {
	    this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}
	@Override
	// 从底层 Bean 工厂中移除指定名称的 Bean 定义
	public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
	    this.beanFactory.removeBeanDefinition(beanName);
	}
	@Override
	// 获取指定名称的 Bean 定义
	public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
	    return this.beanFactory.getBeanDefinition(beanName);
	}
	
	// registerBean 方法封装了 Bean 注册的逻辑
	// 允许通过 Class 类型、可选的实例供应器和自定义器动态注册 Bean
	// 极大简化了 Bean 定义和注册的过程
	public <T> void registerBean(@Nullable String beanName, Class<T> beanClass,
			@Nullable Supplier<T> supplier, BeanDefinitionCustomizer... customizers) {
		...
	}

}

18、GenericWebApplicationContext（web通用应用上下文）

  GenericWebApplicationContext是一个通用的Spring Web应用上下文，结合动态Bean注册功能与Web特定特性（如ServletContext），用于轻量化配置和管理 Web 应用环境

public class GenericWebApplicationContext extends GenericApplicationContext
		implements ConfigurableWebApplicationContext, ThemeSource {
	
	// ServletContext 是 Web 应用的全局上下文
	// 用于共享数据、加载资源、解析路径和访问应用及容器的配置信息
	@Nullable
	private ServletContext servletContext;
	
	...
}

19、ServletWebServerApplicationContext（web服务通用上下文）

  ServletWebServerApplicationContext是SpringBoot用于启动和管理内嵌Servlet Web服务器（如 Tomcat）的应用上下文，实现Web服务器与Spring容器的无缝集成。

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
		implements ConfigurableWebServerApplicationContext {
		
	// 表示一个Web服务器（例如 Tomcat、Jetty 或 Netty）
	private volatile WebServer webServer;
	
	// ServletConfig 是 Servlet 规范中的接口
	// 用于向 Servlet 提供初始化参数和上下文信息
	private ServletConfig servletConfig;

	// 创建和初始化内嵌 Web 服务器
	private void createWebServer() {
		...
	}
}

20、AnnotationConfigRegistry（注解配置注册器）

  AnnotationConfigRegistry是一个接口，提供通过注册注解配置类或扫描包路径来管理Spring组件的功能。

// 主要功能是提供通过注解方式注册组件类或扫描包的能力
public interface AnnotationConfigRegistry {
	// 注册一个或多个组件类
	// 对register方法的调用是幂等的；多次添加相同的组件类不会产生额外的效果
	void register(Class<?>... componentClasses);

	// 扫描指定的基础包以查找组件类
	void scan(String... basePackages);
}

21、AnnotationConfigServletWebServerApplicationContext（注解驱动web服务应用上下文）

  AnnotationConfigServletWebServerApplicationContext是一个基于注解配置的 Spring 应用上下文，继承自 ServletWebServerApplicationContext，并支持通过注解注册组件类和包扫描来配置 Web 应用。

// 一个专门用于基于注解配置的 Servlet Web 服务器应用上下文
public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
        implements AnnotationConfigRegistry {

    // 存储已注册的注解配置类的集合，这些类通常标注有@Configuration注解
    private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();

    // 存储要扫描的基础包路径数组，通过包路径扫描，可以发现并注册 Spring 组件
    private String[] basePackages;

	...
}

总结

• SpringBoot的上下文架构基于Spring的扩展，核心是以ApplicationContext 为中心的组件体系
  • 通过BeanFactory提供Bean的注册、管理和依赖注入功能
  • 通过ApplicationContext为应用提供高级功能支持，包括国际化消息、访问环境变量、事件发布、资源访问等
  • 通过WebApplicationContext集成ServletContext，管理Web环境中的Bean和特定作用域（如request和session）
  • 通过WebServerApplicationContext管理嵌入式Web服务器（如 Tomcat、Jetty）的启动、停止和生命周期