Springboot 启动时Bean的创建与注入（一）-面试热点-springboot源码解读-xunznux

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方法开始看起。
Springboot 启动时Bean的创建与注入（二）-面试热点-springboot源码解读-xunznux
Springboot 的Bean生命周期五步、七步、十步详解以及框架源码解读

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 和 ApplicationRunner bean。

这个简单的 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的状态，为整个应用提供了一个完整且一致的运行时环境。

注：由于内容过长，剩余的核心方法解释放在下一篇文章中。
Springboot 启动时Bean的创建与注入（二）-面试热点-springboot源码解读-xunznux
Springboot 的Bean生命周期五步、七步、十步详解以及框架源码解读