从零开始解剖Spring Boot启动流程：一个Java小白的奇幻冒险之旅

大家好呀！今天我们要一起探索一个神奇的话题——Spring Boot的启动流程。我知道很多小伙伴一听到"启动流程"四个字就开始头疼，别担心！我会用最通俗易懂的方式，带你从main()方法开始，一步步揭开Spring Boot的神秘面纱，直到内嵌Tomcat欢快地跑起来~ ‍♂️

准备好了吗？让我们开始这段奇妙的旅程吧！

第一章：一切的开始——main()方法

1.1 那个我们熟悉的入口

每个Spring Boot项目都有一个main()方法，它就像是我们家的前门钥匙，没有它，我们连门都进不去！

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

看到这个@SpringBootApplication注解了吗？它其实是个"套娃"注解，里面包含了三个重要注解：

• @SpringBootConfiguration：标识这是个配置类
• @EnableAutoConfiguration：开启自动配置魔法 ✨
• @ComponentScan：告诉Spring去哪里找组件

1.2 SpringApplication.run() 做了什么？

当我们调用SpringApplication.run()时，背后发生了很多事情：

1. 创建SpringApplication实例：就像组装一台新电脑
2. 运行SpringApplication：按下开机键！

// 伪代码简化版
public static ConfigurableApplicationContext run(Class primarySource, String... args) {
    // 1. 创建SpringApplication实例
    SpringApplication application = new SpringApplication(primarySource);
    
    // 2. 运行！
    return application.run(args);
}

第二章：SpringApplication的构造过程 �

2.1 确定应用类型

Spring Boot会先判断我们是什么类型的应用：

• Web应用（Servlet）：比如用Tomcat
• Reactive Web应用：比如用Netty
• 非Web应用：普通的Java应用

// 判断逻辑大致是这样的
private WebApplicationType deduceWebApplicationType() {
    if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", null) {
        return WebApplicationType.REACTIVE;
    }
    if (ClassUtils.isPresent("javax.servlet.Servlet", null)) {
        return WebApplicationType.SERVLET;
    }
    return WebApplicationType.NONE;
}

2.2 加载初始化器(Initializers)

初始化器就像是Spring Boot的"小助手"们，它们会在应用启动的不同阶段帮忙做一些准备工作。Spring Boot会从META-INF/spring.factories文件中加载这些初始化器。

# 示例 spring.factories 内容
org.springframework.context.ApplicationContextInitializer=\
com.example.MyInitializer,\
com.example.AnotherInitializer

2.3 加载监听器(Listeners)

监听器就像是一群"小耳朵"，它们会监听Spring Boot启动过程中的各种事件，比如：

• ApplicationStartingEvent：应用刚开始启动
• ApplicationEnvironmentPreparedEvent：环境准备好了
• ApplicationPreparedEvent：应用上下文准备好了
• ApplicationStartedEvent：应用启动完成
• ApplicationReadyEvent：应用准备就绪

第三章：run()方法的奇幻旅程

现在，我们来到了最精彩的部分——run()方法的执行过程！让我们一步步来看：

3.1 第一步：启动计时器 ⏱️

Spring Boot一启动就会打开秒表，记录启动耗时：

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

3.2 第二步：准备环境

Spring Boot会准备运行环境，这包括：

1. 创建环境对象（根据应用类型不同创建不同的环境）
2. 配置环境（读取配置文件，如application.properties/yml）
3. 发布ApplicationEnvironmentPreparedEvent事件

ConfigurableEnvironment environment = prepareEnvironment(...);

3.3 第三步：创建应用上下文 ️

根据应用类型创建不同的应用上下文：

• Web应用：AnnotationConfigServletWebServerApplicationContext
• Reactive Web应用：AnnotationConfigReactiveWebServerApplicationContext
• 非Web应用：AnnotationConfigApplicationContext

context = createApplicationContext();

3.4 第四步：准备上下文 �

这一步会做很多重要工作：

1. 准备环境
2. 后置处理Bean定义
3. 应用所有初始化器
4. 发布ApplicationContextInitializedEvent事件
5. 注册Spring Bean

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

3.5 第五步：刷新上下文

这是整个启动过程中最复杂的一步！refresh()方法做了很多事情：

refreshContext(context);

让我们深入看看refresh()方法都做了什么：

3.5.1 准备刷新

• 记录启动时间
• 初始化占位符解析器
• 验证必要的属性

3.5.2 获取BeanFactory

• 创建DefaultListableBeanFactory
• 加载Bean定义

3.5.3 准备BeanFactory

• 设置类加载器
• 添加Bean后置处理器
• 注册环境Bean

3.5.4 执行BeanFactory后置处理器

• 执行BeanFactoryPostProcessor的实现类
• 这里会处理自动配置类（@EnableAutoConfiguration的核心）

3.5.5 注册Bean后置处理器

• 注册各种BeanPostProcessor
• 这些处理器会在Bean创建前后执行一些逻辑

3.5.6 初始化消息源

• 国际化相关

3.5.7 初始化事件广播器

• 用于发布应用事件

3.5.8 初始化其他特殊Bean

• 比如Tomcat、Jetty等Web服务器

3.5.9 完成BeanFactory初始化

• 初始化所有剩余的单例Bean

3.5.10 完成刷新

• 发布ContextRefreshedEvent事件
• 启动Web服务器（比如Tomcat）

3.6 第六步：收尾工作

启动完成后：

1. 停止计时器
2. 发布ApplicationStartedEvent和ApplicationReadyEvent事件
3. 返回应用上下文

afterRefresh(context, applicationArguments);
stopWatch.stop();

第四章：内嵌Tomcat的启动奥秘

现在，让我们重点看看内嵌Tomcat是如何启动的！这是很多小伙伴最感兴趣的部分~

4.1 Tomcat在哪里被创建？

在refresh()方法的"初始化其他特殊Bean"阶段，Spring Boot会创建Web服务器。对于Tomcat来说，关键类是这个：

org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory

4.2 Tomcat启动流程

1. 创建Tomcat实例：

   Tomcat tomcat = new Tomcat();
   

2. 配置基础信息：

   • 设置端口（默认8080）
   • 设置上下文路径（默认"/"）
   • 配置连接器等

3. 创建Web应用上下文：

   Context context = tomcat.addContext("", docBase);
   

4. 配置Servlet容器：

   • 添加DispatcherServlet
   • 配置过滤器等

5. 启动Tomcat：

   tomcat.start();
   

4.3 内嵌Tomcat vs 传统Tomcat

特点	内嵌Tomcat	传统Tomcat
启动方式	通过Java代码启动	通过startup.sh/bat脚本启动
部署方式	打包成可执行JAR	打包成WAR部署到webapps目录
配置方式	通过application.properties配置	通过server.xml配置
类加载器	使用应用的类加载器	使用Tomcat的类加载器
版本控制	由Spring Boot管理版本	需要单独安装和管理

4.4 为什么选择内嵌服务器？

1. 简化部署：只需要一个JAR文件，不需要额外安装Tomcat
2. 版本统一：Spring Boot管理Tomcat版本，避免冲突
3. 快速启动：内嵌服务器启动更快
4. 微服务友好：适合云原生和容器化部署
5. 配置简单：通过配置文件即可完成大部分配置

第五章：自动配置的魔法 ✨

Spring Boot最强大的特性之一就是自动配置，让我们看看它是如何工作的！

5.1 @EnableAutoConfiguration 的秘密

这个注解会导入AutoConfigurationImportSelector，它会从META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中加载自动配置类。

5.2 条件注解的妙用

自动配置类通常使用各种条件注解来决定是否生效：

• @ConditionalOnClass：当类路径下有指定类时生效
• @ConditionalOnMissingBean：当容器中没有指定Bean时生效
• @ConditionalOnProperty：当配置属性满足条件时生效

例如，Tomcat的自动配置类：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
public class EmbeddedTomcatAutoConfiguration {
    // 配置代码
}

5.3 自动配置的执行顺序

1. 加载所有自动配置类
2. 过滤掉不满足条件的配置类
3. 按特定顺序应用剩余配置类
4. 创建和配置各种Bean

第六章：Spring Boot启动流程图解 ️

为了帮助大家更好地理解，我画了一个简化的启动流程图：

main()
  │
  ├─ 创建SpringApplication实例
  │   ├─ 确定应用类型
  │   ├─ 加载初始化器
  │   └─ 加载监听器
  │
  └─ 执行run()方法
      ├─ 启动计时器
      ├─ 准备环境
      ├─ 创建应用上下文
      ├─ 准备上下文
      ├─ 刷新上下文 (核心！)
      │   ├─ 准备刷新
      │   ├─ 获取BeanFactory
      │   ├─ 准备BeanFactory
      │   ├─ 执行BeanFactory后置处理器
      │   ├─ 注册Bean后置处理器
      │   ├─ 初始化消息源
      │   ├─ 初始化事件广播器
      │   ├─ 初始化特殊Bean (如Tomcat)
      │   ├─ 完成BeanFactory初始化
      │   └─ 完成刷新
      ├─ 收尾工作
      └─ 返回应用上下文

第七章：常见问题解答 ❓

7.1 为什么我的Spring Boot应用启动很慢？

可能原因：

1. 类路径下JAR太多
2. 自动配置类太多
3. 数据库连接等初始化耗时
4. 大量Bean需要初始化

解决方案：

• 使用@Lazy延迟初始化
• 排除不必要的自动配置
• 减少启动时扫描的包路径

7.2 如何自定义内嵌Tomcat配置？

在application.properties中：

server.port=9090
server.tomcat.max-threads=200
server.tomcat.connection-timeout=5000

或者通过代码：

@Bean
public WebServerFactoryCustomizer tomcatCustomizer() {
    return factory -> factory.addConnectorCustomizers(connector -> {
        connector.setPort(9090);
        connector.setProperty("maxThreads", "200");
    });
}

7.3 如何查看自动配置的过程？

启动时添加debug参数：

java -jar myapp.jar --debug

或者在application.properties中：

debug=true

第八章：启动优化小技巧 ⚡

8.1 组件扫描优化

默认情况下，Spring Boot会扫描主类所在包及其子包。如果项目很大，可以明确指定扫描路径：

@ComponentScan("com.myapp.package1", "com.myapp.package2")

8.2 延迟初始化

Spring Boot 2.2+支持全局延迟初始化：

spring.main.lazy-initialization=true

8.3 排除自动配置

如果知道某些自动配置不需要，可以排除它们：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

8.4 使用Spring Boot DevTools

在开发环境中，添加DevTools可以加快重启速度：

    org.springframework.boot
    spring-boot-devtools
    runtime

第九章：总结与展望

哇！我们终于走完了Spring Boot的整个启动流程！让我们回顾一下重点：

1. main()方法是入口，调用SpringApplication.run()
2. SpringApplication初始化时会确定应用类型、加载初始化和监听器
3. run()方法是核心，完成了环境准备、上下文创建和刷新
4. 刷新上下文是最复杂的部分，完成了Bean工厂准备、自动配置、Bean注册等
5. 内嵌Tomcat在刷新阶段被创建和启动
6. 自动配置通过条件注解智能地配置应用

Spring Boot的启动过程就像是一个精密的瑞士手表⌚，各个部件协同工作，最终让我们的应用顺利运行。理解这个过程不仅能帮助我们更好地使用Spring Boot，还能在遇到问题时快速定位原因。

希望这篇文章能帮助你理解Spring Boot的启动机制！如果觉得有用，别忘了点赞收藏哦~

下次见！

推荐阅读文章

• 由 Spring 静态注入引发的一个线上T0级别事故（真的以后得避坑）

• 如何理解 HTTP 是无状态的，以及它与 Cookie 和 Session 之间的联系

• HTTP、HTTPS、Cookie 和 Session 之间的关系

• 什么是 Cookie？简单介绍与使用方法

• 什么是 Session？如何应用？

• 使用 Spring 框架构建 MVC 应用程序：初学者教程

• 有缺陷的 Java 代码：Java 开发人员最常犯的 10 大错误

• 如何理解应用 Java 多线程与并发编程？

• 把握Java泛型的艺术：协变、逆变与不可变性一网打尽

• Java Spring 中常用的 @PostConstruct 注解使用总结

• 如何理解线程安全这个概念？

• 理解 Java 桥接方法

• Spring 整合嵌入式 Tomcat 容器

• Tomcat 如何加载 SpringMVC 组件

• “在什么情况下类需要实现 Serializable，什么情况下又不需要（一）？”

• “避免序列化灾难：掌握实现 Serializable 的真相！（二）”

• 如何自定义一个自己的 Spring Boot Starter 组件（从入门到实践）

• 解密 Redis：如何通过 IO 多路复用征服高并发挑战！

• 线程 vs 虚拟线程：深入理解及区别

• 深度解读 JDK 8、JDK 11、JDK 17 和 JDK 21 的区别

• 10大程序员提升代码优雅度的必杀技，瞬间让你成为团队宠儿！

• “打破重复代码的魔咒：使用 Function 接口在 Java 8 中实现优雅重构！”

• Java 中消除 If-else 技巧总结

• 线程池的核心参数配置(仅供参考)

• 【人工智能】聊聊Transformer，深度学习的一股清流(13)

• Java 枚举的几个常用技巧，你可以试着用用

• 由 Spring 静态注入引发的一个线上T0级别事故（真的以后得避坑）

• 如何理解 HTTP 是无状态的，以及它与 Cookie 和 Session 之间的联系

• HTTP、HTTPS、Cookie 和 Session 之间的关系

• 使用 Spring 框架构建 MVC 应用程序：初学者教程

• 有缺陷的 Java 代码：Java 开发人员最常犯的 10 大错误

• Java Spring 中常用的 @PostConstruct 注解使用总结

• 线程 vs 虚拟线程：深入理解及区别

• 深度解读 JDK 8、JDK 11、JDK 17 和 JDK 21 的区别

• 10大程序员提升代码优雅度的必杀技，瞬间让你成为团队宠儿！

• 探索 Lombok 的 @Builder 和 @SuperBuilder：避坑指南（一）

• 为什么用了 @Builder 反而报错？深入理解 Lombok 的“暗坑”与解决方案（二）