SpringBoot 系列 #01：SpringBoot 启动流程源码分析

基于 SpringBoot 2.4.4 源码 + 真实运行日志验证。整体分 5 个阶段：构造 → 启动准备 → 准备 ApplicationContext → 刷新 → 启动完成。每阶段标注扩展点（🔌）和日志验证（✅）。

缩写速查：Spring 术语与缩写速查 · 相关笔记：Spring 容器启动流程源码分析 · Spring 三级缓存与循环依赖

目录

流程总览

SpringApplication.run(primarySources, args)
  │
  ├─ 阶段一：new SpringApplication
  │     推断 WebType → 加载 Bootstrapper / Initializer / Listener
  │
  ├─ 阶段二：instance.run(args)
  │     BootstrapContext → starting 事件 → prepareEnvironment → Banner
  │
  ├─ 阶段三：prepareContext
  │     createApplicationContext → applyInitializers → load BeanDefinition
  │
  ├─ 阶段四：refreshContext
  │     ShutdownHook → Spring refresh（BFPP → BPP → Bean 实例化 → Tomcat 启动）
  │
  └─ 阶段五：启动完成
        afterRefresh → started 事件 → Runners → ready 事件

阶段一：构造 SpringApplication

入口等同于 new SpringApplication(primarySources).run(args)，构造阶段完成 4 件事：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

    // 1. 推断 WebApplicationType（检测类路径）
    this.webApplicationType = WebApplicationType.deduceFromClasspath();

    // 2-4. 通过 spring.factories 加载三大组件
    this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection)   getSpringFactoriesInstances(ApplicationListener.class));

    // 5. 堆栈回溯找到 main() 所在类
    this.mainApplicationClass = deduceMainApplicationClass();
}

1.1 WebApplicationType 推断

1.2 Bootstrapper

作用：refresh 前的轻量辅助容器，用于注册创建代价高或需要早期共享的实例。以 Class 为 key，每类型只能存一个。

生命周期：prepareContext 阶段调用 bootstrapContext.close(context) 后关闭，非用户扩展 API。

1.3 ApplicationContextInitializer 🔌

作用：在 refresh() 前回调，典型用途是注册额外的 PropertySource 或激活 Profile。

默认加载的 5 个实现（spring.factories）：

自定义注册方式：① spring.factories 写入；② context.initializer.classes 属性配置。

1.4 ApplicationListener 🔌

作用：观察者模式，监听生命周期事件。默认加载 8 个监听器：

阶段二：run() 启动准备

2.1 基础准备

StopWatch stopWatch = new StopWatch();
stopWatch.start();

DefaultBootstrapContext bootstrapContext = createBootstrapContext(); // 初始化 Bootstrapper
configureHeadlessProperty();  // java.awt.headless=true，服务器无图形界面

2.2 发布 ApplicationStartingEvent

SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);
// → LoggingApplicationListener 响应：初始化 LoggingSystem
// → LiquibaseServiceLocatorApplicationListener 响应

2.3 prepareEnvironment（配置加载核心）✅ 日志验证

调用链（日志验证顺序）：

listeners.environmentPrepared()
  → EnvironmentPostProcessorApplicationListener
  → RandomValuePropertySource 加入 ✅
  → ConfigDataEnvironmentPostProcessor ✅
     → ConfigDataEnvironment（构建属性源贡献者）✅
        → 扫描配置文件位置（见下表）
        → 加载 application.yaml ✅

StandardServletEnvironment 默认属性源（✅ 日志验证）：

配置文件扫描位置（优先级从高到低，file 系列高于 classpath）✅ 日志验证：

① file:./config/*/
② file:./config/
③ file:./
④ classpath:/config/
⑤ classpath:/          ← application.yaml 从此处加载 ✅

扩展点：自定义 EnvironmentPostProcessor 🔌

// spring.factories 注册
org.springframework.boot.env.EnvironmentPostProcessor=com.example.MyEnvPostProcessor

public class MyEnvPostProcessor implements EnvironmentPostProcessor {
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app) {
        // 可新增/修改属性源，优先级高于 application.properties
        env.getPropertySources().addFirst(new MapPropertySource("custom", Map.of("key", "value")));
    }
}

阶段三：准备 ApplicationContext

3.1 createApplicationContext ✅ 日志验证

// 按 WebType 创建对应实现（✅ 日志：Refreshing AnnotationConfigServletWebServerApplicationContext）
switch (webApplicationType) {
case SERVLET:   return new AnnotationConfigServletWebServerApplicationContext();
case REACTIVE:  return new AnnotationConfigReactiveWebServerApplicationContext();
default:        return new AnnotationConfigApplicationContext();
}

3.2 prepareContext 执行顺序

context.setEnvironment(environment);          // 将 Environment 注入上下文
postProcessApplicationContext(context);        // 注册 ConversionService / ResourceLoader
applyInitializers(context);                    // 🔌 回调所有 ApplicationContextInitializer
listeners.contextPrepared(context);            // 发布 ContextPreparedEvent
bootstrapContext.close(context);               // 辅助容器关闭
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
load(context, sources.toArray(...));           // 🔌 加载 BeanDefinition（自动装配入口）
listeners.contextLoaded(context);              // 发布 ContextLoadedEvent

3.3 自动装配入口（load 阶段）🔌

load(启动类)
  → 解析 @SpringBootApplication
  → @EnableAutoConfiguration
  → AutoConfigurationImportSelector
  → spring.factories: org.springframework.boot.autoconfigure.EnableAutoConfiguration
  → 按 @Conditional 条件筛选后注册 BeanDefinition

阶段四：刷新 ApplicationContext

4.1 注册 ShutdownHook

context.registerShutdownHook();  // 进程退出时触发 context.close()，Bean 优雅销毁
refresh((ApplicationContext) context);

4.2 AbstractApplicationContext#refresh() ✅ 日志验证

SpringBoot 委托给 Spring Core 的标准刷新流程，6 个关键步骤：

关键顺序：Tomcat 在 onRefresh() 启动，晚于 Bean 实例化（④），保证所有 Bean 就绪后才开放端口。✅ 日志验证：Root WebApplicationContext: initialization completed → Tomcat started on port(s): 9999

阶段五：启动完成

afterRefresh(context, applicationArguments);  // 🔌 空实现，可覆写
stopWatch.stop();

listeners.started(context);                   // 发布 ApplicationStartedEvent
callRunners(context, applicationArguments);   // 🔌 回调 Runner
listeners.running(context);                   // 发布 ApplicationReadyEvent（服务就绪）

Runner 执行顺序 🔌

// 两类 Runner 按 @Order 混合排序后依次执行
// ApplicationRunner：封装了 ApplicationArguments（支持 --key=value 解析）
// CommandLineRunner：直接传原始 String[] args
@Component
@Order(1)
public class MyRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        // 上下文已完全就绪，可安全使用所有 Bean
        // 典型用途：数据预热、缓存初始化、健康检查
    }
}

扩展点汇总

BeanFactory 创建时机与 BeanDefinition 两步加载

BeanFactory 在哪里创建

BeanFactory 在 prepareContext 之前就已构建完毕，创建时机是 createApplicationContext()：

// SpringApplication#run()
context = createApplicationContext();              // ① BeanFactory 在此创建（空）
prepareContext(..., context, ...);                 // ② 往 BeanFactory 注册"种子" BeanDefinition
refreshContext(context);                           // ③ refresh() 展开所有 BeanDefinition

createApplicationContext() 根据 WebApplicationType 选择实现类，其构造器里：

// AnnotationConfigServletWebServerApplicationContext 构造器
public AnnotationConfigServletWebServerApplicationContext() {
    this.reader  = new AnnotatedBeanDefinitionReader(this);  // 注册注解处理器 BD
    this.scanner = new ClassPathBeanDefinitionScanner(this); // 准备组件扫描器
    // 父类 GenericApplicationContext 构造器：
    // this.beanFactory = new DefaultListableBeanFactory(); ← 空 BeanFactory 就绪
}

BeanDefinition 两步加载

Spring Boot 的 BeanDefinition 加载分两步完成，核心桥梁是 ConfigurationClassPostProcessor：

第一步（prepareContext → load()）：注册"种子"

BeanDefinitionLoader 将 sources 注册为 BeanDefinition，sources 来源包括：

此阶段只把 Application.class 注册为一个 BD，其上的 @ComponentScan / @Import 尚未展开。

第二步（refreshContext → invokeBeanFactoryPostProcessors）：展开所有 BD

ConfigurationClassPostProcessor（实现 BeanDefinitionRegistryPostProcessor）拿到第一步的种子 BD，递归解析：

ConfigurationClassPostProcessor#processConfigBeanDefinitions()
  └── 解析 @SpringBootApplication
        ├── @ComponentScan → 扫描所有 @Component/@Service/@Repository
        ├── @EnableAutoConfiguration
        │     └── AutoConfigurationImportSelector
        │           └── spring.factories → 按 @Conditional 筛选 → 注册 AutoConfig BD
        └── @Bean 方法 → 注册方法级 BeanDefinition

完整时序：

createApplicationContext()          BeanFactory 创建（空）
  ↓
prepareContext → load(sources)      注册 Application.class BD（1个种子）
  ↓
refresh → invokeBFPP
  └── ConfigurationClassPostProcessor  展开 @ComponentScan / @Import / @Bean
                                        BeanFactory 中 N 个 BD 全部就绪
  ↓
finishBeanFactoryInitialization()   实例化所有非懒加载 Bean

关键结论：prepareContext 阶段 BeanFactory 已存在，但只有"种子"；真正的业务 Bean、AutoConfiguration Bean 全部由 ConfigurationClassPostProcessor 在 refresh() 内完成注册。这就是 Spring Boot 自动装配与 Spring 容器 refresh 流程的衔接点。

参考资料

• Spring Boot 官方文档 — Application Events and Listeners
• Spring Framework — AbstractApplicationContext#refresh
• 运行日志验证环境：SpringBoot 2.4.4 + Java 17，-Dlogging.level.org.springframework.boot=TRACE