springboot初始化

启动SpringbootInitApplication应用，开始执行run 方法，828行new SpringApplication对象

构造器中初始化初始化一些属性

执行run方法

configureHeadlessProperty ：设置Headless 模式，Headless 模式通常用于没有图形用户界面 (GUI) 的应用程序，例如后端服务或一些命令行工具。在这种模式下，应用程序不需要图形窗口或用户界面，因此可以更轻便和高效。

    public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
        //创建 Bootstrap 上下文
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        this.configureHeadlessProperty();
        //从 /classpatch下的/META-INF/spring.factories下找到SpringApplicationRunListener，并开启
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //准备基础的环境信息
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
           //打印标识 
          
            Banner printedBanner = this.printBanner(environment);
           //创建应用上下文
            context = this.createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            //准备应用上下文
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            ////刷新应用上下文
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
            }

            listeners.started(context, timeTakenToStartup);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var12) {
            if (var12 instanceof AbandonedRunException) {
                throw var12;
            }

            this.handleRunFailure(context, var12, listeners);
            throw new IllegalStateException(var12);
        }

        try {
            if (context.isRunning()) {
                Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
                listeners.ready(context, timeTakenToReady);
            }

            return context;
        } catch (Throwable var11) {
            if (var11 instanceof AbandonedRunException) {
                throw var11;
            } else {
                this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
                throw new IllegalStateException(var11);
            }
        }
    }

创建应用上下文

如果没有配置spring.aot.enabled ，aot 是新功能指的是AOT,Ahead Of Time 指的是运行前编译，预先编译。然后创建创建不同的AnnotaionContext

prepareContext

设置应用程序上下文的环境:
- context.setEnvironment(environment)：这一步将应用程序的环境（environment）设置到应用程序上下文（context）中。环境包括了应用程序的配置属性，它决定了应用程序如何配置自身。
应用程序上下文的后处理:
- this.postProcessApplicationContext(context)：这一步执行应用程序上下文的后处理，允许对应用程序上下文进行自定义配置和修改。
添加 AOT 生成的初始化器（如果需要）:
- this.addAotGeneratedInitializerIfNecessary(this.initializers)：如果应用程序需要使用AOT（Ahead of Time）生成的初始化器，这一步将它们添加到初始化器列表中。AOT生成的初始化器通常用于优化应用程序的启动性能。
应用初始化器:
- this.applyInitializers(context)：在这一步中，应用程序的初始化器（initializers）被应用到应用程序上下文。初始化器通常用于执行应用程序的配置和准备工作。
触发 contextPrepared 事件:
- listeners.contextPrepared(context)：在这一步触发一个 contextPrepared 事件，通知所有注册的监听器，应用程序上下文已经准备好。详细看springboot-application-event
关闭 Bootstrap 上下文:
- bootstrapContext.close(context)：Bootstrap 上下文被关闭。Bootstrap 上下文是在应用程序启动时创建的，用于管理应用程序生命周期。一旦应用程序上下文准备就绪，Bootstrap 上下文可以关闭。
记录启动信息:
- this.logStartupInfo(context.getParent() == null)：如果启用了启动信息日志，这一步记录启动信息。这包括了应用程序的启动时间和其他信息。这个信息通常用于性能分析和诊断。
注册 Spring Bean:
- 这一步注册一些 Spring Bean 到应用程序上下文中。这包括了应用程序参数（springApplicationArguments）和启动横幅（springBootBanner），它们可以在应用程序中使用。
允许循环引用:
- 如果应用程序上下文的 beanFactory 支持，这一步设置是否允许循环引用。默认情况下，Spring 框架允许循环引用，但可以进行配置以禁用它。
懒加载:
- 如果启用了懒加载（lazyInitialization），这一步将一个懒加载的 BeanFactory 后处理器添加到应用程序上下文中。懒加载允许在需要时才初始化 Bean，从而提高性能。
添加 BeanFactory 后处理器:
- 在这个步骤中，添加了一些 BeanFactory 后处理器，用于定制应用程序上下文的行为。例如，LazyInitializationBeanFactoryPostProcessor 用于处理懒加载。
加载应用程序资源:
- 如果不使用AOT生成的构件（artifacts），这一步将加载应用程序的资源，例如配置文件和其他资源。这些资源通常用于配置和初始化应用程序。
触发 contextLoaded 事件:
- listeners.contextLoaded(context)：最后，触发一个 contextLoaded 事件，通知所有注册的监听器，应用程序上下文已经加载并准备好。

refreshContext

准备刷新:
- this.prepareRefresh()：在刷新应用程序上下文之前，执行一些准备工作。这包括设置启动步骤和其他必要的初始化。
获取新的 Bean 工厂:
- ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory()：在这一步，获取一个新的 Bean 工厂，用于管理应用程序中的所有 Bean。这个工厂将替代之前的工厂，以确保应用程序是最新的。
准备 Bean 工厂:
- this.prepareBeanFactory(beanFactory)：对新的 Bean 工厂进行准备工作，包括设置类加载器、属性编辑器和 BeanPostProcessor 等。
后处理 Bean 工厂:
- this.postProcessBeanFactory(beanFactory)：在这一步，对 Bean 工厂进行后处理。包括注册自定义属性编辑器或 BeanPostProcessor。
执行 Bean 工厂后处理器:
- this.invokeBeanFactoryPostProcessors(beanFactory)：在这一步，调用 Bean 工厂后处理器。这些后处理器可以对应用程序上下文进行进一步的配置和初始化。
注册 Bean 后处理器:
- this.registerBeanPostProcessors(beanFactory)：注册 Bean 后处理器，这些后处理器将应用于应用程序上下文中的 Bean。Bean 后处理器可以执行自定义的操作，例如代理或包装 Bean。
初始化消息源:
- this.initMessageSource()：在这一步，初始化应用程序的消息源，它通常用于处理国际化和本地化的消息。
初始化应用程序事件多播器:
- this.initApplicationEventMulticaster()：初始化应用程序事件多播器，用于发布和监听应用程序事件。
在刷新之后执行特定操作:
- this.onRefresh()：在刷新之后，执行一些特定于应用程序上下文的操作。这是一个扩展点，允许你在应用程序上下文准备好之后执行自定义操作。
注册监听器:
- this.registerListeners()：注册应用程序上下文中的事件监听器，以便它们可以监听并响应应用程序事件。
完成 Bean 工厂初始化:
- this.finishBeanFactoryInitialization(beanFactory)：在这一步，完成 Bean 工厂的初始化，包括实例化和初始化所有非懒加载的单例 Bean
完成刷新:
- this.finishRefresh()：完成应用程序上下文的刷新。这包括发布 ContextRefreshedEvent 事件，通知应用程序上下文已经准备好。
处理异常:
- 如果在刷新过程中出现异常，会在 catch 块中处理异常。如果异常发生，它会取消刷新尝试，销毁已经创建的 Bean，然后抛出异常以指示刷新失败。
重置常见缓存:
- this.resetCommonCaches()：最后，在 finally 块中，重置一些常见的缓存，以确保下一次刷新可以正常进行。