SpringBoot 启动流程

一、SpringBoot 启动流程

Spring Boot 实现了从启动到运行的完整流程，极大地简化了 Spring 应用的开发和部署。不过其启动流程是一个复杂的过程，涉及多个步骤和组件。以下是Spring Boot 启动步骤的简要流程图：

+-------------------+
|   Main Class      |
|  (with main())    |
+-------------------+
          |
          v
+-------------------+
| SpringApplication |
+-------------------+
          |
          v
+-------------------+
|  Prepare Env      |
+-------------------+
          |
          v
+-------------------+
| Create Context    |
+-------------------+
          |
          v
+-------------------+
| Refresh Context   |
+-------------------+
          |
          v
+-------------------+
| Start Web Server  |
+-------------------+
          |
          v
+-------------------+
| Run Runners       |
+-------------------+
          |
          v
+-------------------+
|   Application     |
|     Running       |
+-------------------+

1. 启动类执行：
   • 当 SpringBoot 项目启动时，会在当前工作目录下寻找有@SpringBootApplication注解标识的类，并把这个类作为应用程序的入口点，在这个启动类中会包含一个 main() 方法。如果找不到这样的启动类，则会打印错误信息并退出。
2. SpringApplication 实例化：
   • 在 main 方法中，创建一个 SpringApplication 对象。这个对象负责引导和启动 Spring Boot 应用。
3. 设置应用程序参数：
   • SpringApplication 可以通过方法链设置一些参数，比如是否需要显示 banner，是否需要以 web 环境启动等。
4. 运行 SpringApplication：
   • 调用 SpringApplication.run() 方法启动应用程序。这个方法会触发一系列的启动步骤。
5. 准备环境：
   • SpringApplication 准备 Environment，包括解析配置文件（如 application.properties 或 application.yml），设置系统属性和环境变量。
6. 创建并刷新应用上下文：
   • 根据应用类型（如 AnnotationConfigApplicationContext 或 AnnotationConfigServletWebServerApplicationContext）创建合适的 ApplicationContext。
   • 注册所有的 Bean，包括自动配置的 Bean。
7. 应用启动监听器和初始化器：
   • 执行所有的 ApplicationListener 和 ApplicationContextInitializer。这些组件可以在应用启动过程中执行一些自定义逻辑。
8. 自动配置：
   • Spring Boot 的自动配置机制根据类路径中的库和自定义的配置属性，自动配置 Spring 应用程序。
9. 启动内嵌服务器：
   • 如果是 web 应用，Spring Boot 会启动一个内嵌的 web 服务器（如 Tomcat、Jetty 或 Undertow）。
10. 执行 CommandLineRunner 和 ApplicationRunner：
    • 在应用启动完成后，Spring Boot 会调用所有实现了 CommandLineRunner 和 ApplicationRunner 接口的 Bean，以便在应用启动后执行一些特定的代码。
11. 应用启动完成：
    • 一旦所有的步骤都完成，Spring Boot 应用就会处于运行状态，准备好接受请求

二、SpringBoot 启动源码分析

（1）首先是启动类源码

启动类必须使用 @SpringBootApplication 注解标记该类。在启动类的main()方法中，调用了SpringApplication.run() 方法来启动 Spring Boot 应用程序。该方法接受两个参数，第一个参数是启动类的类对象，第二个参数是主方法的参数。

（2）SpringApplication.run()方法源码


最终通过创建一个SpringApplication对象，并调用其run()方法来执行项目启动的后续操作。

	public ConfigurableApplicationContext run(String... args) {
		// 创建一个SpringApplication对象的启动器（Startup），并返回一个Startup对象。
		// 启动器是一个非常重要的概念，它可以帮助我们快速地启动应用程序，并进行一些基本的配置和初始化操作。
        Startup startup = SpringApplication.Startup.create();
        
        // 判断当前应用程序是否需要注册一个系统级别的关闭钩子，如果需要，则调用enableShutdownHookAddition方法来注册该钩子。
        // 关闭钩子是一个非常重要的概念，它可以帮助我们在应用程序退出时执行一些清理操作，例如关闭数据库连接池、释放网络资源等等。
        if (this.registerShutdownHook) {
            shutdownHook.enableShutdownHookAddition();
        }
		
		// 创建一个应用程序上下文，并将其传递给DefaultBootstrapContext对象，以便在应用程序启动时进行一些初始化工作。
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        
        // 配置系统属性的方法，用于指示当前应用程序是否没有图形界面。为"true"时，表示当前应用程序没有图形界面，因此无法进行一些与图形界面相关的操作。
        this.configureHeadlessProperty();
        
        // 获取RunListeners对象，它包含了应用程序在启动和运行过程中的监听器，以便应用程序能够正确地监听和处理各种事件和通知。
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        // 用于启动应用程序的监听器的方法，触发应用程序启动时的一些监听器，并让它们在应用程序启动时执行一些操作。
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
        	// 创建一个DefaultApplicationArguments对象，并将传入的命令行参数赋值给它。
        	// 这个对象可以用于后续的代码中，以便在应用程序启动时获取命令行参数。
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
           
            // 创建一个ConfigurableEnvironment对象，并将它赋值给环境变量。这个对象可以用于后续的代码中，以便在应用程序启动时获取环境属性。
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            
            // 生成一个Banner对象，并将它打印到控制台中，以便用户能够了解应用程序的版本号、作者信息等。
            Banner printedBanner = this.printBanner(environment);

			// 创建一个ApplicationContext对象，并将它赋值给ApplicationContext变量,以便在应用程序启动时获取ApplicationContext属性和方法。
            context = this.createApplicationContext();

			// 将传入的ApplicationStartup对象赋值给ApplicationContext的ApplicationStartup属性。
            context.setApplicationStartup(this.applicationStartup);

			// 根据传入的参数，创建一个ApplicationContext对象，并对其进行一些初始化操作，以便在应用程序启动时能够正常运行。
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

			// 刷新ApplicationContext对象，启动tomcat服务器
            this.refreshContext(context);

			// 在ApplicationContext刷新完成后执行一些操作。
            this.afterRefresh(context, applicationArguments);
            
            // 启动应用程序。
            startup.started();
	
			// 是否记录应用程序启动信息
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), startup);
            }
			
			// 通知所有启动监听器应用程序已经启动
            listeners.started(context, startup.timeTakenToStarted());
            
            // 遍历所有的运行器，并调用它们的run方法，将应用程序运行起来
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            if (var10 instanceof AbandonedRunException) {
                throw var10;
            }
			// 遍历所有的监听器，并通知它们应用程序启动失败的情况
            this.handleRunFailure(context, var10, listeners);
            // 抛出一个IllegalStateException异常，表示应用程序无法继续启动
            throw new IllegalStateException(var10);
        }

        try {
        	// 判断ApplicationContext是否已经开始运行
            if (context.isRunning()) {
            	// 如果是，则调用ready方法通知所有就绪监听器应用程序已经就绪
                listeners.ready(context, startup.ready());
            }
			
			// 返回ConfigurableApplicationContext对象
            return context;
        } catch (Throwable var9) {
            if (var9 instanceof AbandonedRunException) {
                throw var9;
            } else {
                this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null);
                throw new IllegalStateException(var9);
            }
        }
    }

三、总结

总的来说，Spring Boot的启动过程是一个复杂的流程，从启动类的Main方法中调用SpringApplication.run(DemoApplication.class, args)方法开始，然后在SpringApplication对象的run方法中做了一系列操作来完成项目启动所需的初始化Spring容器、启动内置tomcat、启动应用程序以及通知监听者等步骤。其中关键组件和概念如下：

• @SpringBootApplication：这是一个组合注解，简化了配置。
• SpringApplication：核心类，负责启动和引导 Spring Boot 应用。
• 自动配置：通过 @EnableAutoConfiguration 实现，根据类路径中的依赖自动配置 Spring 应用。
• 内嵌服务器：Spring Boot 提供内嵌的 web 服务器，简化了 web 应用的部署。