Springboot 启动时Bean的创建与注入，以及对应的源码解读
文章目录
-
- Springboot 启动时Bean的创建与注入，以及对应的源码解读
- 构建Web项目流程图：
- 堆栈信息：
- 堆栈信息简介
- 堆栈信息源码详解
-
- 1、`main:10, DemoApplication (com.xun.demo)`
- 2、`run:1352, SpringApplication (org.springframework.boot)`
- 3、run:1363, SpringApplication (org.springframework.boot)
- 4、run:335, SpringApplication (org.springframework.boot)
- 5、refreshContext:456, SpringApplication (org.springframework.boot)
- 6、refresh:754, SpringApplication (org.springframework.boot)
- 7、refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
- 8、refresh:624, AbstractApplicationContext (org.springframework.context.support)
- 9、finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
- 10、preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
- 其他内容
出于研究springboot启动时bean的创建到注入中发生的函数调用的这个目的，搭建一个最简单的springboot应用，只有一个controller bean，没有再手动指定任何其他bean。
先展示一下如何在idea中快速构建一个springboot web demo项目：
构建Web项目流程图：
在这里推荐一个插件，可以在插件市场中搜索 Maven Search安装，用于寻找依赖：
为了得到堆栈调用信息，需要找到InjectionMetadata 类中的 inject 方法打断点调试：
堆栈信息：
inject:142, InjectionMetadata (org.springframework.beans.factory.annotation)
postProcessProperties:508, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
populateBean:1421, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:599, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:522, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
lambda$doGetBean$0:337, AbstractBeanFactory (org.springframework.beans.factory.support)
getObject:-1, AbstractBeanFactory$$Lambda$330/0x0000020b811ebab8 (org.springframework.beans.factory.support)
getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:335, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:200, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
refresh:624, AbstractApplicationContext (org.springframework.context.support)
refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
refresh:754, SpringApplication (org.springframework.boot)
refreshContext:456, SpringApplication (org.springframework.boot)
run:335, SpringApplication (org.springframework.boot)
run:1363, SpringApplication (org.springframework.boot)
run:1352, SpringApplication (org.springframework.boot)
main:10, DemoApplication (com.xun.demo)
堆栈信息简介
这个堆栈信息展示了 Spring Boot 在启动过程中如何创建和注入 bean 的详细过程。下面是对每个函数调用的简单解释，详细代码解释在后面进行：
inject:142, InjectionMetadata (org.springframework.beans.factory.annotation)
InjectionMetadata是一个 Spring 类，用于处理注入点元数据。inject方法负责实际的注入操作，根据注解（如@Autowired）将依赖注入到目标 bean 中。postProcessProperties:508, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
AutowiredAnnotationBeanPostProcessor是一个 BeanPostProcessor，负责处理@Autowired和@Value注解。postProcessProperties方法在 Spring 容器实例化 bean 之后但在它们的依赖项被注入之前被调用，用于处理依赖注入。populateBean:1421, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
populateBean方法用于填充给定 bean 实例的属性。这包括对@Autowired、@Value等注解的处理，并将相应的依赖注入到 bean 中。doCreateBean:599, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean方法负责实际创建一个新的 bean 实例，包括调用其构造函数、应用工厂后处理器、自动装配和初始化。createBean:522, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean方法是doCreateBean的高层次包装器，负责创建并初始化一个新的 bean 实例。lambda$doGetBean$0:337, AbstractBeanFactory (org.springframework.beans.factory.support)
这是一个 lambda 表达式，作为回调传递给getSingleton方法，负责返回一个单例 bean 实例。getObject:-1, AbstractBeanFactory$$Lambda$330/0x0000020b811ebab8 (org.springframework.beans.factory.support)
这是 lambda 表达式的实际实现，用于从单例注册表中获取或创建一个单例 bean。getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
getSingleton方法从单例缓存中获取 bean 实例，如果 bean 不存在，则创建并缓存它。doGetBean:335, AbstractBeanFactory (org.springframework.beans.factory.support)
doGetBean方法负责实际获取一个 bean 实例，包括处理依赖注入和初始化。getBean:200, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean方法是doGetBean的高层次包装器，用于获取一个 bean 实例。preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons方法负责提前实例化所有非延迟加载的单例 bean，确保它们在应用启动时就被创建和初始化。finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
finishBeanFactoryInitialization方法在 Spring 容器刷新期间被调用，完成 bean 工厂的初始化，包括实例化所有剩余的单例 bean。refresh:624, AbstractApplicationContext (org.springframework.context.support)
refresh方法是 Spring 应用上下文刷新逻辑的入口点，负责重新加载 bean 定义、初始化 Spring 环境和 bean 工厂。refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
这是ServletWebServerApplicationContext类中refresh方法的实现，用于刷新 Web 应用上下文。refresh:754, SpringApplication (org.springframework.boot)
refresh方法是 Spring Boot 应用启动过程中刷新应用上下文的关键步骤。refreshContext:456, SpringApplication (org.springframework.boot)
refreshContext方法用于刷新 Spring 应用上下文，确保所有 bean 定义和依赖关系都被正确加载和初始化。run:335, SpringApplication (org.springframework.boot)
run方法是 Spring Boot 应用的主要入口点，负责启动 Spring 应用上下文。run:1363, SpringApplication (org.springframework.boot)
这是run方法的一种签名，通常用于启动 Spring Boot 应用。run:1352, SpringApplication (org.springframework.boot)
这是run方法的一种签名，通常用于启动 Spring Boot 应用。main:10, DemoApplication (com.xun.demo)
这是应用的主类DemoApplication的main方法，是 Spring Boot 应用的入口点。
通过这些方法调用，Spring Boot 应用在启动过程中创建和注入 bean，确保所有依赖关系都被正确解析和注入。
堆栈信息源码详解
先从栈底部的main方法开始看起。
1、main:10, DemoApplication (com.xun.demo)
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
这个代码是一个典型的 Spring Boot 应用程序的入口类，下面是对每个部分的详细解释：
@SpringBootApplication
这个注解是一个组合注解，它结合了以下三个常用的 Spring 注解：
@SpringBootConfiguration: 表示这是一个 Spring Boot 配置类，等同于 Spring 的@Configuration注解。@EnableAutoConfiguration: 这个注解告诉 Spring Boot 根据添加的依赖自动配置 Spring 应用程序。@ComponentScan: 这个注解启用组件扫描，让 Spring 找到并注册带有@Component、@Service、@Repository和@Controller等注解的类。
public class DemoApplication
这是 Spring Boot 应用的主类，命名为DemoApplication。按照惯例，Spring Boot 应用的主类通常位于源码目录的根包下，以便能够扫描到该包及其子包中的所有组件。public static void main(String[] args)
这是 Java 应用程序的入口点。main方法是应用程序启动时第一个执行的方法。SpringApplication.run(DemoApplication.class, args)
这个静态方法启动了 Spring Boot 应用程序。以下是一些关键点：
SpringApplication.run方法负责启动 Spring 应用上下文，启动内嵌的服务器（例如 Tomcat），并初始化 Spring 环境。DemoApplication.class是应用的主类，它包含@SpringBootApplication注解，使其成为 Spring Boot 应用的配置类。args是传递给应用的命令行参数。
当 SpringApplication.run 被调用时，Spring Boot 会执行以下步骤：
- 创建并启动
SpringApplication实例。 - 准备
SpringApplication实例（例如，读取并解析命令行参数）。 - 创建并刷新应用上下文（包括创建所有单例 bean）。
- 启动嵌入式服务器（例如 Tomcat）。
- 执行所有
CommandLineRunner和ApplicationRunnerbean。
这个简单的 Spring Boot 应用程序入口类通过 @SpringBootApplication 注解和 SpringApplication.run 方法启动了一个完整的 Spring Boot 应用，包含自动配置和内嵌服务器，简化了 Spring 应用的开发和部署。
2、run:1352, SpringApplication (org.springframework.boot)
/**
* Static helper that can be used to run a {@link SpringApplication} from the
* specified source using default settings.
* @param primarySource the primary source to load
* @param args the application arguments (usually passed from a Java main method)
* @return the running {@link ApplicationContext}
*/
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
- 这是一个静态辅助方法，可以使用默认设置从指定的源运行一个 SpringApplication。
- 参数 primarySource 是要加载的主要源，通常是一个带有 @SpringBootApplication 注解的主类。
- 参数 args 是应用程序的参数，通常是从 Java 主方法传递的命令行参数。
- 返回正在运行的 ApplicationContext，这是 Spring 应用程序上下文的表示。
这个静态 run 方法是启动 Spring Boot 应用程序的便捷方法。它接受一个主要源类和应用程序参数，将主要源类包装成一个数组，然后调用另一个 run 方法来启动应用程序。最终返回一个 ConfigurableApplicationContext，表示应用程序的运行上下文。
3、run:1363, SpringApplication (org.springframework.boot)
/**
* Static helper that can be used to run a {@link SpringApplication} from the
* specified sources using default settings and user supplied arguments.
* @param primarySources the primary sources to load
* @param args the application arguments (usually passed from a Java main method)
* @return the running {@link ApplicationContext}
*/
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return new SpringApplication(primarySources).run(args);
}
这个静态 run 方法是启动 Spring Boot 应用程序的便捷方法。它接受一个主要源类数组和应用程序参数，创建一个 SpringApplication 实例，并调用它的 run 方法来启动应用程序。最终返回一个 ConfigurableApplicationContext，表示应用程序的运行上下文。
4、run:335, SpringApplication (org.springframework.boot)
/**
* Run the Spring application, creating and refreshing a new {@link ApplicationContext}.
* @param args the application arguments (usually passed from a Java main method)
* @return a running {@link ApplicationContext}
*/
public ConfigurableApplicationContext run(String... args) {
// 创建一个用于记录启动时间和事件的 Startup 实例
Startup startup = Startup.create();
// 如果启用了 registerShutdownHook，注册一个 JVM 关闭钩子
if (this.registerShutdownHook) {
SpringApplication.shutdownHook.enableShutdownHookAddition();
}
// 创建一个 DefaultBootstrapContext 实例，用于引导应用程序上下文的初始化
DefaultBootstrapContext bootstrapContext = createBootstrapContext();
// 声明一个 ConfigurableApplicationContext 变量
ConfigurableApplicationContext context = null;
// 配置 headless 属性，防止某些图形环境相关的问题
configureHeadlessProperty();
// 获取应用程序运行的监听器，用于在不同阶段触发事件
SpringApplicationRunListeners listeners = getRunListeners(args);
// 通知监听器应用程序正在启动
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
// 创建一个 ApplicationArguments 实例，解析命令行参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 准备并配置环境变量
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
// 打印启动横幅
Banner printedBanner = printBanner(environment);
// 创建应用程序上下文
context = createApplicationContext();
// 设置应用程序启动器
context.setApplicationStartup(this.applicationStartup);
// 准备应用程序上下文，配置相关属性和资源
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// 刷新应用程序上下文，加载所有 Bean 定义并启动应用程序
refreshContext(context);
// 在上下文刷新后进行后续操作
afterRefresh(context, applicationArguments);
// 记录启动时间
startup.started();
// 如果 logStartupInfo 为 true，记录启动信息
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), startup);
}
// 通知监听器应用程序已启动
listeners.started(context, startup.timeTakenToStarted());
// 调用所有 CommandLineRunner 和 ApplicationRunner 实现类
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
// 捕获异常并处理启动失败的情况
throw handleRunFailure(context, ex, listeners);
}
try {
// 如果上下文正在运行，通知监听器应用程序已就绪
if (context.isRunning()) {
listeners.ready(context, startup.ready());
}
}
catch (Throwable ex) {
// 捕获异常并处理启动失败的情况
throw handleRunFailure(context, ex, null);
}
// 返回运行中的 ConfigurableApplicationContext 实例
return context;
}
这个 run 方法执行了 Spring Boot 应用程序的完整启动过程，从准备环境、创建应用程序上下文到通知监听器和调用运行器。通过多个步骤，确保应用程序在启动过程中正确配置和初始化。最终返回一个正在运行的 ApplicationContext 实例。
该方法运行一个 Spring 应用程序，创建并刷新一个新的 ApplicationContext 实例。ApplicationContext 是 Spring 框架中的核心接口之一，代表了 Spring 的 IoC 容器，用于管理 Spring 应用中的 beans。
以下是 run 方法的主要流程和作用：
创建启动记录实例: 创建一个
Startup实例，用于记录应用启动的时间和事件。注册 JVM 关闭钩子: 如果配置了
registerShutdownHook，则注册一个 JVM 关闭钩子，以确保在 JVM 关闭时能正确地进行清理工作。创建引导上下文: 创建一个
DefaultBootstrapContext实例，用于在应用上下文初始化期间保存引导信息。配置
headless属性: 配置headless属性，以防止在没有显示器环境中运行时的一些问题。获取运行监听器: 获取
SpringApplicationRunListeners实例，用于在不同的应用启动阶段触发事件。通知监听器应用程序正在启动: 通知监听器应用程序启动的开始。
解析命令行参数: 创建
ApplicationArguments实例，解析传入的命令行参数。准备并配置环境: 准备并配置 Spring 的环境对象。
打印启动横幅: 根据环境配置打印应用启动横幅。
创建应用上下文: 创建
ApplicationContext实例，用于管理 Spring beans。设置应用启动器: 将应用启动器设置到上下文中。
准备应用上下文: 准备应用上下文，包括加载 bean 定义等。
刷新应用上下文: 刷新应用上下文，实际启动 Spring 容器。
执行刷新后操作: 在上下文刷新后执行一些必要的操作。
记录启动时间: 记录应用程序启动的时间。
记录启动信息: 如果启用了启动信息日志，则记录启动信息。
通知监听器应用程序已启动: 通知监听器应用程序已经启动完成。
调用命令行运行器: 调用所有实现
CommandLineRunner和ApplicationRunner接口的类。处理启动失败: 捕获并处理启动过程中出现的异常。
通知监听器应用程序已就绪: 通知监听器应用程序已经准备就绪，可以处理请求。
返回应用上下文: 返回运行中的
ConfigurableApplicationContext实例。
5、refreshContext:456, SpringApplication (org.springframework.boot)
private void refreshContext(ConfigurableApplicationContext context) {
if (this.registerShutdownHook) {
shutdownHook.registerApplicationContext(context);
}
refresh(context);
}
- 注册关闭钩子：如果配置了 registerShutdownHook，则调用 shutdownHook 的 registerApplicationContext 方法，注册应用上下文以便在 JVM 关闭时执行清理操作。
- 刷新应用上下文：调用 refresh(context) 方法，这个方法是 AbstractApplicationContext 中定义的抽象方法，用于刷新应用上下文，包括初始化所有单例 beans。
这个过程确保应用上下文在启动时被正确初始化和配置，并且所有必要的单例 beans 被实例化和装配。
6、refresh:754, SpringApplication (org.springframework.boot)
/**
* Refresh the underlying {@link ApplicationContext}.
* @param applicationContext the application context to refresh
*/
protected void refresh(ConfigurableApplicationContext applicationContext) {
// 调用 ApplicationContext 的 refresh() 方法来执行刷新操作
applicationContext.refresh();
}
方法用于执行给定应用上下文的刷新操作，确保所有的配置和 beans 都是最新的。
7、refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
/**
* 覆盖父类的 refresh() 方法，执行应用上下文的刷新操作。
* @throws BeansException 如果 bean 创建或初始化过程中出现问题
* @throws IllegalStateException 如果应用上下文已经刷新过或处于不合法状态
*/
@Override
public final void refresh() throws BeansException, IllegalStateException {
try {
// 调用父类的 refresh() 方法，执行应用上下文的刷新操作
super.refresh();
}
catch (RuntimeException ex) {
// 如果在刷新过程中出现运行时异常，则捕获异常并处理
WebServer webServer = this.webServer;
if (webServer != null) {
// 如果存在 WebServer，停止并销毁它
webServer.stop();
webServer.destroy();
}
// 抛出捕获到的运行时异常，向上层传递异常信息
throw ex;
}
}
这段代码中的 refresh() 方法是 ApplicationContext 接口的实现方法，在 Spring 应用上下文初始化后被调用，用于执行上下文的刷新操作。
8、refresh:624, AbstractApplicationContext (org.springframework.context.support)
/**
* 加载或刷新配置的持久表示，该配置可能来自基于Java的配置、XML文件、属性文件、
* 关系数据库模式或其他某种格式。
* <p>
* 由于这是一个启动方法，如果失败，它应该销毁已创建的单例，
* 以避免悬挂资源。换句话说，在调用此方法之后，要么所有单例都被实例化，
* 要么根本没有单例被实例化。
*
* @throws BeansException 如果bean工厂无法初始化
* @throws IllegalStateException 如果已经初始化并且不支持多次刷新尝试
*/
@Override
public void refresh() throws BeansException, IllegalStateException {
// 获取锁以确保刷新过程的线程安全
this.startupShutdownLock.lock();
try {
// 记录当前线程作为执行刷新操作的线程
this.startupShutdownThread = Thread.currentThread();
// 开始一个启动步骤，用于上下文刷新过程
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// 准备刷新过程
prepareRefresh();
// 通知子类刷新内部bean工厂
// 获得一个新的bean工厂实例
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 为这个上下文准备bean工厂
prepareBeanFactory(beanFactory);
try {
// 允许上下文子类对bean工厂进行后处理
postProcessBeanFactory(beanFactory);
// 开始一个启动步骤，用于bean后处理
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 调用注册在上下文中的bean工厂后处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册拦截bean创建的bean后处理器
registerBeanPostProcessors(beanFactory);
// 结束bean后处理的启动步骤
beanPostProcess.end();
// 初始化消息源
initMessageSource();
// 初始化事件多播器
initApplicationEventMulticaster();
// 在特定的上下文子类中初始化其他特殊bean
onRefresh();
// 检查监听器bean并注册它们
registerListeners();
// 实例化所有剩余（非懒加载初始化）的单例
finishBeanFactoryInitialization(beanFactory);
// 完成刷新过程
finishRefresh();
}
// 捕获任何运行时异常或错误
catch (RuntimeException | Error ex) {
// 如果警告日志启用，记录异常并取消刷新尝试
if (logger.isWarnEnabled()) {
logger.warn("在上下文初始化过程中遇到异常 - 取消刷新尝试: " + ex);
}
// 销毁已创建的单例以避免资源泄露（如果失败，应该销毁已创建的单例）
destroyBeans();
// 重置'活动'标志
cancelRefresh(ex);
// 将异常传播给调用者
throw ex;
}
// 确保结束上下文刷新的启动步骤
finally {
contextRefresh.end();
}
}
// 无论刷新成功还是失败，都释放锁
finally {
this.startupShutdownThread = null;
this.startupShutdownLock.unlock();
}
}
该方法是 AbstractApplicationContext 类中的 refresh() 方法的实现，用于刷新 Spring 应用上下文的整个流程。以下是其详细流程总结：
- 获取启动和关闭锁: 获取
startupShutdownLock锁，确保在应用上下文刷新期间不会被其他线程中断。 - 设置当前线程为启动/关闭线程: 将当前线程设置为
startupShutdownThread，以便在需要时能够进行相应处理。 - 应用启动步骤记录: 使用
applicationStartup记录应用启动步骤，标记为 “spring.context.refresh”。用于记录上下文刷新过程的性能指标。 - 准备刷新操作: 调用
prepareRefresh()方法，为刷新操作做准备。包括设置必要的环境属性和初始化一些状态。 - 获取新的 Bean 工厂: 调用
obtainFreshBeanFactory()方法获取一个新的ConfigurableListableBeanFactory实例。通常是通过重新加载Bean定义来实现的。 - 为使用准备 Bean 工厂: 调用
prepareBeanFactory(beanFactory)方法，为当前上下文的使用准备 Bean 工厂。包括设置类加载器、注册默认的环境Bean等。 - 后处理 Bean 工厂: 调用
postProcessBeanFactory(beanFactory)方法，允许子类对 Bean 工厂进行后处理。 - 调用 Bean 工厂后处理器: 调用
invokeBeanFactoryPostProcessors(beanFactory)方法，执行注册在上下文中的 Bean 工厂后处理器。 - 注册 Bean 后处理器: 调用
registerBeanPostProcessors(beanFactory)方法，注册拦截 Bean 创建的 Bean 后处理器。 - 初始化消息源: 调用
initMessageSource()方法，初始化该上下文的消息源。 - 初始化应用事件广播器: 调用
initApplicationEventMulticaster()方法，初始化该上下文的应用事件广播器。用于发布和监听应用事件。 - 特定上下文子类的初始化: 调用
onRefresh()方法，初始化特定于该上下文子类的其他特殊 Bean。 - 注册监听器: 调用
registerListeners()方法，检查并注册监听器 Bean。 - 完成 Bean 工厂的初始化: 调用
finishBeanFactoryInitialization(beanFactory)方法，实例化所有剩余的非延迟初始化单例 Bean。 - 完成刷新操作: 调用
finishRefresh()方法，完成应用上下文的刷新。 - 处理异常: 在执行上述步骤的任何过程中，如果捕获到
RuntimeException或Error，则进入异常处理块。
- 记录警告日志，取消刷新尝试。
- 销毁已创建的单例 Bean，避免资源泄漏。
- 设置
active标志为 false。 - 向上层抛出捕获到的异常。
- 结束应用启动步骤记录: 无论是否发生异常，都会调用
contextRefresh.end()结束应用启动步骤记录。 - 释放启动和关闭锁: 最后在
finally块中释放startupShutdownThread，解锁startupShutdownLock，确保安全地结束刷新过程。
这个方法的主要目的是确保 Spring 应用上下文能够在启动时进行正确的初始化和配置，包括加载配置、注册 Bean、初始化消息源和事件广播器等重要步骤，最终保证应用程序能够正常运行。
9、finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
/**
* 完成本上下文的bean工厂初始化，初始化所有剩余的单例bean。
* <p>
* 此方法执行以下操作：
* 1. 初始化此上下文的转换服务，如果存在名为CONVERSION_SERVICE_BEAN_NAME的bean且类型为ConversionService。
* 2. 如果没有BeanFactoryPostProcessor注册过内嵌的值解析器，则注册一个默认的环境占位符解析器。
* 3. 早期初始化LoadTimeWeaverAware类型的beans，以便于尽早注册它们的transformer。
* 4. 停止使用临时类加载器进行类型匹配。
* 5. 冻结bean定义元数据，不再期望进一步的变化。
* 6. 实例化所有剩余的（非懒加载初始化）单例。
*
* @param beanFactory 当前的可配置列表bean工厂
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 如果存在转换服务bean，初始化转换服务（为此上下文初始化转换服务）
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
// 设置bean工厂的转换服务
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 如果没有任何 BeanFactoryPostProcessor（例如 PropertySourcesPlaceholderConfigurer bean）
// 之前注册过嵌入值解析器，则注册一个默认的嵌入值解析器：
// 此时，主要用于解析注解属性值中的占位符。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 提前初始化 LoadTimeWeaverAware beans，以便及早注册它们的转换器 transformer。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
}
// 停止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
// 冻结配置，允许缓存所有的Bean定义元数据，不再期望有进一步的更改。
beanFactory.freezeConfiguration();
// 实例化所有剩余的（非懒加载初始化）单例 Bean
beanFactory.preInstantiateSingletons();
}
这个方法的主要作用是完成Spring应用上下文中Bean工厂的初始化过程，特别是初始化所有剩余的单例Bean。具体来说，它执行了一系列步骤来确保Bean工厂的配置和Bean实例的准备工作都已完成。以下是每个步骤的详细解释：
- 初始化转换服务：检查是否存在名为CONVERSION_SERVICE_BEAN_NAME的Bean，并且该Bean的类型匹配ConversionService。如果存在，则将其设置为Bean工厂的转换服务。这一步确保了在Bean属性转换时使用正确的转换服务。
- 注册默认嵌入值解析器：如果没有嵌入值解析器，则添加一个默认的解析器，用于解析注解属性值中的占位符。这一步确保了注解中的占位符能够被正确解析。
- 提前初始化LoadTimeWeaverAware bean：获取所有实现了LoadTimeWeaverAware接口的Bean名称，并提前初始化这些Bean，以便及早注册它们的类加载时转换器。这一步确保了类加载时的增强功能能够正确注册。
- 停止使用临时ClassLoader：停止使用临时的ClassLoader进行类型匹配。这一步通常是在Bean定义解析和类型匹配完成后进行的清理工作。
- 冻结Bean定义元数据：冻结Bean定义元数据，表示不再期望有进一步的更改。这一步确保了Bean定义的稳定性和一致性。
- 实例化所有剩余的单例Bean：实例化所有剩余的（非懒加载的）单例Bean。这一步确保了所有需要立即初始化的单例Bean都已创建并准备就绪。
总结：这个方法的整体作用是**确保Spring应用上下文中的Bean工厂已经完全初始化，并且所有需要的单例Bean都已实例化。**它通过一系列步骤来配置转换服务、解析占位符、注册类加载时转换器、清理临时资源、冻结配置并最终实例化所有单例Bean，从而确保应用上下文的稳定性和一致性。
10、preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
/**
* 确保所有非懒加载的单例Bean都被实例化，同时考虑{@link org.springframework.beans.factory.FactoryBean FactoryBeans}。
* 通常在工厂设置结束时调用（如果需要）。
* @throws BeansException 如果某个单例Bean无法创建。
* 注意：这可能会导致工厂中已经初始化了一些Bean！
* 在这种情况下，请调用{@link #destroySingletons()}进行完全清理。
* @see #destroySingletons()
*/
@Override
public void preInstantiateSingletons() throws BeansException {
// 如果日志级别为TRACE，则记录预实例化单例Bean的操作。
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 迭代一个Bean定义名称的副本，以允许在初始化方法中注册新的Bean定义。
// 虽然这可能不是常规工厂引导的一部分，但在其他情况下工作正常。
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有非懒加载单例Bean的初始化...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 检查Bean定义是否不是抽象的、是单例的并且不是懒加载的。
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果是FactoryBean，则获取FactoryBean实例。
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 如果是SmartFactoryBean并且需要急切初始化，则获取Bean实例。
if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
getBean(beanName);
}
}
else {
// 否则，直接获取Bean实例。
getBean(beanName);
}
}
}
// 触发所有适用Bean的后初始化回调...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
// 如果Bean实例是SmartInitializingSingleton，则调用其afterSingletonsInstantiated方法。
if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
smartSingleton.afterSingletonsInstantiated();
smartInitialize.end();
}
}
}
这段代码是 DefaultListableBeanFactory 类中的 preInstantiateSingletons 方法，用于预实例化所有非延迟初始化的单例 Beans，同时考虑到 FactoryBean。主要作用是预实例化Spring应用上下文中的所有非懒加载单例Bean，并在所有单例Bean实例化后触发相应的回调方法。通过预实例化，可以确保所有必要的Bean在应用启动时已经准备就绪，从而提高应用的响应速度和稳定性。
以下是方法的流程总结：
日志记录：
- 如果日志级别为 trace，则记录日志，指示正在预实例化单例 Beans。
复制 Bean 名称列表：
- 创建一个
beanNames列表，复制当前 Bean 工厂中所有的 Bean 名称。这样做是为了允许在初始化方法期间可能注册新的 Bean 定义。（可以安全地在初始化过程中注册新的bean定义）
- 创建一个
实例化所有非延迟初始化的单例 Beans：
- 遍历
beanNames列表中的每个 Bean 名称。 - 获取与当前 Bean 名称关联的合并的 RootBeanDefinition。
- 检查该 Bean 定义是否为非抽象、单例且非延迟初始化。
- 如果是工厂Bean
FactoryBean，则首先获取其对应的 FactoryBean 实例，如果是SmartFactoryBean并且设置为 eagerInit（需要急切初始化），则立即获取其实例。 - 否则，直接通过
getBean(beanName)方法获取该 Bean 的实例。
- 遍历
触发所有适用 Bean 的后初始化回调：
- 再次遍历
beanNames列表中的每个 Bean 名称。 - 获取每个 Bean 名称对应的单例实例。
- 如果该实例实现了
SmartInitializingSingleton接口，调用其afterSingletonsInstantiated()方法，执行后初始化逻辑。这是一个回调方法，用于在所有单例Bean实例化后执行一些自定义逻辑。
- 再次遍历
preInstantiateSingletons方法的**主要作用是确保所有非懒加载的单例beans在应用上下文完全启动之前已经被实例化和初始化。**这一步骤对于依赖于这些beans的其他组件来说至关重要，因为它保证了这些beans的可用性。同时，它还提供了对那些希望在所有单例beans实例化后执行某些操作的beans的支持，通过调用SmartInitializingSingleton接口的afterSingletonsInstantiated方法。
总之，preInstantiateSingletons方法是Spring框架上下文启动流程中的一个关键环节，它负责最终确定所有非懒加载单例beans的状态，为整个应用提供了一个完整且一致的运行时环境。
注：由于内容过长，剩余的核心方法解释放在下一篇文章中。
其他内容
如果对 Golang 实现的Raft共识算法、Golang实现的负载均衡或者 Golang web 项目的demo实现感兴趣的可以看看我的主页，各个部分都带有详细的代码解释，也可以通过代码仓库获取源码，直接运行。
gitee链接
![C#知识|账号管理系统-账号信息管理界面[2]:提交查询按钮事件的编写](https://i-blog.csdnimg.cn/direct/cbf2b8890a7c4b738eecab069f555e3b.png)
