springboot启动流程

q1871901600 发布于 2024-12-19 79 次阅读

Spring Boot启动流程详解

Spring Boot的启动过程包含多个关键步骤，下面为您详细介绍：

1. 创建DefaultBootstrapContext对象

首先，会创建一个DefaultBootstrapContext对象，用于后续的初始化操作。

2. 利用BootstrapRegistryInitializer初始化DefaultBootstrapContext对象

通过BootstrapRegistryInitializer对DefaultBootstrapContext对象进行初始化，为后续流程做准备。

private DefaultBootstrapContext createBootstrapContext() { 
    DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext(); 
    this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext)); 
    return bootstrapContext; 
}

3. 获取SpringApplicationRunListeners

这一步会获取SpringApplicationRunListeners，用于监听Spring Boot应用的启动过程。

private SpringApplicationRunListeners getRunListeners(String[] args) { 
    Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class }; 
    return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args), this.applicationStartup); 
}

这三个步骤是启动流程的前期准备，为后续的核心操作奠定基础。

5. 触发SpringApplicationRunListener的starting()

默认情况下，Spring Boot提供了一个EventPublishingRunListener，它实现了SpringApplicationRunListener接口。在这一步，会利用EventPublishingRunListener发布一个ApplicationContextInitializedEvent事件，程序员可以通过定义ApplicationListener来消费这个事件。

void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) { 
    doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext), (step) -> { 
        if (mainApplicationClass != null) { 
            step.tag("mainApplicationClass", mainApplicationClass.getName()); 
        } 
    }); 
}

6. 创建Environment对象

Environment对象表示环境变量，该对象内部主要包含了当前操作系统的环境变量、JVM的一些配置信息以及 -D方式所配置的JVM环境变量。

private ConfigurableEnvironment getOrCreateEnvironment() { 
    if (this.environment != null) { 
        return this.environment; 
    } 
    ConfigurableEnvironment environment = this.applicationContextFactory.createEnvironment(this.webApplicationType); 
    if (environment == null && this.applicationContextFactory != ApplicationContextFactory.DEFAULT) { 
        environment = ApplicationContextFactory.DEFAULT.createEnvironment(this.webApplicationType); 
    } 
    return (environment != null) ? environment : new ApplicationEnvironment(); 
}

7. 触发SpringApplicationRunListener的environmentPrepared()

默认情况下，会利用EventPublishingRunListener发布一个ApplicationEnvironmentPreparedEvent事件。程序员可以通过定义ApplicationListener来消费这个事件，比如默认情况下会有一个EnvironmentPostProcessorApplicationListener来消费这个事件，而这个ApplicationListener接收到这个事件之后，就会解析application.properties、application.yml文件，并添加到Environment对象中去。

@Override 
public void contextLoaded(ConfigurableApplicationContext context) { 
    for (ApplicationListener<?> listener : this.application.getListeners()) { 
        if (listener instanceof ApplicationContextAware) { 
            ((ApplicationContextAware) listener).setApplicationContext(context); 
        } 
        context.addApplicationListener(listener); 
    } 
    this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context)); 
}

8. 打印Banner

这一步会打印Spring Boot的Banner，一般没有特殊操作。

if (printedBanner != null) { 
    beanFactory.registerSingleton("springBootBanner", printedBanner); 
}

9. 创建Spring容器对象（ApplicationContext）

会利用ApplicationContextFactory.DEFAULT，根据应用类型创建对应的Spring容器。

ApplicationContextFactory.DEFAULT为：

所以：

  • 应用类型为SERVLET，则对应AnnotationConfigServletWebServerApplicationContext
  • 应用类型为REACTIVE，则对应AnnotationConfigReactiveWebServerApplicationContext
  • 应用类型为普通类型，则对应AnnotationConfigApplicationContext
public ConfigurableApplicationContext create(WebApplicationType webApplicationType) { 
    try { 
        return getFromSpringFactories(webApplicationType, ApplicationContextFactory::create, AnnotationConfigApplicationContext::new); 
    } catch (Exception ex) { 
        throw new IllegalStateException("Unable create a default ApplicationContext instance, " + "you may need a custom ApplicationContextFactory", ex); 
    } 
}

10. 利用ApplicationContextInitializer初始化Spring容器对象

默认情况下，Spring Boot提供了多个ApplicationContextInitializer，其中比较重要的有ConditionEvaluationReportLoggingListener。虽然它的名字叫XXXListener，但它确实是实现了ApplicationContextInitializer接口的。

在它的initialize()方法中会：

  • 将Spring容器赋值给它的applicationContext属性
  • 并且往Spring容器中添加一个ConditionEvaluationReportListener（ConditionEvaluationReportLoggingListener的内部类），它是一个ApplicationListener
  • 并生成一个ConditionEvaluationReport对象赋值给它的report属性

ConditionEvaluationReportListener会负责接收ContextRefreshedEvent事件，也就是Spring容器一旦启动完毕就会触发ContextRefreshedEvent，ConditionEvaluationReportListener就会打印自动配置类的条件评估报告。

@Override 
public void initialize(ConfigurableApplicationContext applicationContext) { 
    this.applicationContext = applicationContext; 
    applicationContext.addApplicationListener(new ConditionEvaluationReportListener()); 
    if (applicationContext instanceof GenericApplicationContext) { 
        // Get the report early in case the context fails to load 
        this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory()); 
    } 
}

11. 触发SpringApplicationRunListener的contextPrepared()

默认情况下，会利用EventPublishingRunListener发布一个ApplicationContextInitializedEvent事件，默认情况下暂时没有ApplicationListener消费了这个事件。

@Override 
public void contextPrepared(ConfigurableApplicationContext context) { 
    this.initialMulticaster.multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context)); 
}

12. 调用DefaultBootstrapContext对象的close()

这一步会调用DefaultBootstrapContext对象的close()方法，完成相关资源的清理。

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) { 
    context.setEnvironment(environment); 
    postProcessApplicationContext(context); 
    applyInitializers(context); 
    listeners.contextPrepared(context); 
    bootstrapContext.close(context); 
    if (this.logStartupInfo) { 
        logStartupInfo(context.getParent() == null); 
        logStartupProfileInfo(context); 
    } 
}

13. 将启动类作为配置类注册到Spring容器中（load()方法）

将SpringApplication.run(MyApplication.class);中传入进来的类，比如MyApplication.class，作为Spring容器的配置类。

14. 触发SpringApplicationRunListener的contextLoaded()

默认情况下，会利用EventPublishingRunListener发布一个ApplicationPreparedEvent事件。

public void contextLoaded(ConfigurableApplicationContext context) { 
    for (ApplicationListener<?> listener : this.application.getListeners()) { 
        if (listener instanceof ApplicationContextAware) { 
            ((ApplicationContextAware) listener).setApplicationContext(context); 
        } 
        context.addApplicationListener(listener); 
    } 
    this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context)); 
}

15. 刷新Spring容器

调用Spring容器的refresh()方法，结合第9、13步，相当于执行了这样一个流程：

  • AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  • applicationContext.register(MyApplication.class)
  • applicationContext.refresh()

16. 触发SpringApplicationRunListener的started()

发布ApplicationStartedEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为LivenessState.CORRECT。

LivenessState枚举有两个值：

  • CORRECT：表示当前应用正常运行中
  • BROKEN：表示当前应用还在运行，但是内部出现问题，暂时还没发现哪里用到了
void started(ConfigurableApplicationContext context, Duration timeTaken) { 
    doWithListeners("spring.boot.application.started", (listener) -> listener.started(context, timeTaken)); 
}

17. 调用ApplicationRunner和CommandLineRunner

  • 获取Spring容器中的ApplicationRunner类型的Bean
  • 获取Spring容器中的CommandLineRunner类型的Bean
  • 执行它们的run()
private void callRunners(ApplicationContext context, ApplicationArguments args) { 
    List<Object> runners = new ArrayList<>(); 
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values()); 
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values()); 
    AnnotationAwareOrderComparator.sort(runners); 
    for (Object runner : new LinkedHashSet<>(runners)) { 
        if (runner instanceof ApplicationRunner) { 
            callRunner((ApplicationRunner) runner, args); 
        } 
        if (runner instanceof CommandLineRunner) { 
            callRunner((CommandLineRunner) runner, args); 
        } 
    } 
}

18. 触发SpringApplicationRunListener的ready()

发布ApplicationReadyEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为ReadinessState.ACCEPTING_TRAFFIC。

ReadinessState枚举有两个值：

  • ACCEPTING_TRAFFIC：表示当前应用准备接收请求
  • REFUSING_TRAFFIC：表示当前应用拒绝接收请求，比如Tomcat关闭时，就会发布AvailabilityChangeEvent事件，并且状态为REFUSING_TRAFFIC
@Override 
public void starting(ConfigurableBootstrapContext bootstrapContext) { 
    this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args)); 
}

19. 上述过程抛异常了就触发SpringApplicationRunListener的failed()

发布ApplicationFailedEvent事件。

参考文章;

9千字长文带你了解SpringBoot启动过程--史上最详细 SpringBoot启动流程-图文并茂-CSDN博客

一个会写python的Java工程师
最后更新于 2025-08-29