【springboot系列】springboot启动过程源码分析，【最全源码源码，手把手教】

基于2.6.1版本

分析的话，一般从启动类，标注着 @SpringBootApplication 注解并且有
着 main() 方法的类：

源码如何切分？
SpringApplication 中的静态 run() 方法并不是一步完成的，最终执行的源码如下：

如何创建SpringApplication？

创建即是 new 对象了，debug 跟进代码，最终执行的 SpringApplication 构造方法如下图：

如上图中标注的注释，创建过程重用的其实分为 2、3、4 这三个阶段，下面将会一一介绍每个阶段做了什么事。

设置应用类型

这个过程非常重要，直接决定了项目的类型，应用类型分为三种，都在 WebApplicationType 这个枚举类中，如下：
1. NONE ：顾名思义，什么都没有，正常流程走，不额外的启动 web容器，比如 Tomcat 。
2. SERVLET ：基于 servlet 的web程序，需要启动内嵌的 servlet web容器，比如 Tomcat 。
3. REACTIVE ：基于 reactive 的web程序，需要启动内嵌 reactive web容器。

判断的依据很简单，就是加载对应的类，比如加载了 DispatcherServlet 等则会判断是 Servlet 的web程序。源码如下：

这里我引入了 spring-boot-starter-web ,肯定是 Servlet 的web程序。

设置初始化器(Initializer)

初始化器 ApplicationContextInitializer ，用于 IOC 容器刷新之前初始化一些组件，比如
ServletContextApplicationContextInitializer 。
那么如何获取初始化器呢？跟着上图中的代码进入，在 SpringApplication 中的如下图中的方法：

相对重要的就是第一步获取初始化器的名称了，这个肯定是全类名了，详细源码肯定在
loadFactoryNames() 方法中了，跟着源码进入，最终调用的是
#SpringFactoriesLoader.loadSpringFactories() 方法。
loadSpringFactories() 方法就不再详细解释了，其实就是从类路径 META-INF/spring.factories 中加载ApplicationContextInitializer 的值。
在 spring-boot-autoconfigure 的 spring.factories 文件中的值如下图：

上图中的只是一部分初始化器，因为 spring.factories 文件不止一个。

下图中是项目中注入的初始化器，现实项目中并不止这些。

这也告诉我们自定义一个 ApplicationContextInitializer 只需要实现接口，在 spring.factories 文
件中设置即可。

设置监听器(Listener)

监听器（ ApplicationListener ）这个概念在 Spring 中就已经存在，主要用于监听特定的事件
( ApplicationEvent )，比如IOC容器刷新、容器关闭等。
Spring Boot 扩展了 ApplicationEvent 构建了 SpringApplicationEvent 这个抽象类，主要用于 SpringBoot 启动过程中触发的事件，比如程序启动中、程序启动完成等。如下图：

监听器如何获取？从源码中知道其实和初始化器( ApplicationContextInitializer )执行的是同一个方
法，同样是从 META-INF/spring.factories 文件中获取。
在 spring-boot-autoconfigure 的 spring.factories 文件中的值如下图：

spring.factories 文件不止一个，同样监听器也不止以上这些。

项目中注入的一些监听器如下图：

总结：

SpringApplication 的构建都是为了 run() 方法启动做铺垫，构造方法中总共就有几行代码，最重要的部
分就是设置应用类型、设置初始化器、设置监听器。
注意：初始化器和这里的监听器都要放置在 spring.factories 文件中才能在这一步骤加载，否则
不会生效，因此此时 IOC容器还未创建，即使将其注入到 IOC容器中也是不会生效的。

下图是执行流程图：

执行run()方法

上面分析了 SpringApplication 的构建过程，现在到了启动的过程了。
根据源码启动过程分为了8步：

1. 获取、启动运行过程监听器

SpringApplicationRunListener 这个监听器和 ApplicationListener 不同，它是用来监听应用程序启动过程的，接口的各个方法含义如下：

如何获取运行监听器？

在 SpringApplication#run() 方法中，源码如下：

跟进 getRunListeners() 方法，其实还是调用了 loadFactoryNames() 方法从 spring.factories 文件中获取值，如下：

org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

最终注入的是 EventPublishingRunListener 这个实现类，创建实例过程肯定是通过反射了，因此我们看看它的构造方法，如下图：

这个运行监听器内部有一个事件广播器( SimpleApplicationEventMulticaster )，主要用来广播特定的事件
( SpringApplicationEvent )来触发特定的监听器 ApplicationListener 。
EventPublishingRunListener 中的每个方法用来触发 SpringApplicationEvent 中的不同子类。

如何启动运行监听器？

在 SpringApplication#run() 方法中，源码如下：

//执行starting()方法
listeners.starting(bootstrapContext, this.mainApplicationClass);

执行 SpringApplicationRunListeners 的 starting() 方法，跟进去其实很简单，遍历执行上面获取的运行监听器，这里只有一个 EventPublishingRunListener 。因此执行的是它的 starting() 方法，源码如下图：

上述源码中，其实只是执行了 multicastEvent() 方法，广播了 ApplicationStartingEvent 事件。至于 multicastEvent() 内部方法，其实就是遍历 ApplicationListener 的实现类，找到监听 ApplicationStartingEvent 这个事件的监听器，执行 onApplicationEvent() 方法。

总结

这一步其实就是广播了 ApplicationStartingEvent 事件来触发监听这个事件的 ApplicationListener 。

因此如果自定义了 ApplicationListener 并且监听了 ApplicationStartingEvent （应用程序开始启
动）事件，则这个监听器将会被触发。

2. 环境构建

这一步主要用于加载系统配置以及用户的自定义配置( application.properties )，源码如下，在 run() 方法中：

ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext,
applicationArguments);

prepareEnvironment 方法内部广播了 ApplicationEnvironmentPreparedEvent 事件，源码如下图：

环境构建这一步加载了系统环境配置、用户自定义配置并且广播了
ApplicationEnvironmentPreparedEvent 事件，触发监听器。

3. 创建IOC容器

源码在 run() 方法中，如下：

context = this.createApplicationContext();

跟进代码，真正执行的是 ApplicationContextFactory 方法，如下图：

根据 webApplicationType 决定创建的类型，很显然，这里是 servlet ，因此创建的是
AnnotationConfigServletWebServerApplicationContext 。

这一步仅仅是创建了 IOC容器，未有其他操作。

4. IOC容器的前置处理

这一步是精华，在刷新容器之前做准备，其中有一个非常关键的操作：将启动类注入容器，为后续的自动化配置奠定基础。源码如下：

prepareContext() 源码解析如下图：

上图可以看出步骤很多，下面将详细介绍几个重点的内容。

调用初始化器

在 SpringApplication 构建过程中设置的初始化器，从 spring.factories 取值的。执行的流程很简单，遍历执行，源码如下图：

将自定义的 ApplicationContextInitializer 放在 META-INF/spring.factories 中，在此时也是会被
调用。

加载启动类，注入容器

这一步是将主启动类加载到 IOC容器中，作为后续自动配置的入口。
在 SpringApplication 构建过程中将主启动类放置在 primarySources 这个集合中，此时的
getAllSources() 即是从其中取值，如下图：

这里取出的就是主启动类，当然你的项目中可能不止一个，接下来就是将其加载到IOC容器中了，源码如下：

跟着代码进去，其实主要逻辑都在 BeanDefinitionLoader.load() 方法，如下图：

将主启动类加载到 beanDefinitionMap ，后续该启动类将作为开启自动配置化的入口。

两次广播事件

这一步涉及到了两次事件广播，分别是 ApplicationContextInitializedEvent 和
ApplicationPreparedEvent ，对应的源码如下：

5. 刷新容器

刷新容器完全是 Spring 的功能了，比如初始化资源，初始化上下文广播器等。

protected void refresh(ApplicationContext applicationContext) {
  Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
  //调用创建的容器applicationContext中的refresh()方法
 ((AbstractApplicationContext)applicationContext).refresh();
}
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    /**
    * 刷新上下文环境
    */
    prepareRefresh();
    /**
    * 初始化BeanFactory，解析XML，相当于之前的XmlBeanFactory的操作，
    */
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    /**
    * 为上下文准备BeanFactory，即对BeanFactory的各种功能进行填充，如常用的注解@Autowired
@Qualifier等
    * 添加ApplicationContextAwareProcessor处理器
    * 在依赖注入忽略实现*Aware的接口，如EnvironmentAware、ApplicationEventPublisherAware等
    * 注册依赖，如一个bean的属性中含有ApplicationEventPublisher(beanFactory)，则会将beanFactory
的实例注入进去
    */
    prepareBeanFactory(beanFactory);
    try {
      /**
      * 提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess
      */
      postProcessBeanFactory(beanFactory);
      /**
      * 激活各种BeanFactory处理器,包括BeanDefinitionRegistryBeanFactoryPostProcessor和普通
的BeanFactoryPostProcessor
      * 执行对应的postProcessBeanDefinitionRegistry方法 和 postProcessBeanFactory方法
      */
      invokeBeanFactoryPostProcessors(beanFactory);
      /**
      * 注册拦截Bean创建的Bean处理器，即注册BeanPostProcessor，不是
BeanFactoryPostProcessor，注意两者的区别
      * 注意，这里仅仅是注册，并不会执行对应的方法，将在bean的实例化时执行对应的方法
      */
      registerBeanPostProcessors(beanFactory);
      /**
      * 初始化上下文中的资源文件，如国际化文件的处理等
      */
      initMessageSource();
      /**
      * 初始化上下文事件广播器，并放入applicatioEventMulticaster,如
ApplicationEventPublisher
      */
      initApplicationEventMulticaster();
      /**
      * 给子类扩展初始化其他Bean
      */
      onRefresh();
      /**
      * 在所有bean中查找listener bean，然后注册到广播器中
      */
      registerListeners();
      /**
      * 设置转换器
      * 注册一个默认的属性值解析器
      * 冻结所有的bean定义，说明注册的bean定义将不能被修改或进一步的处理
      * 初始化剩余的非惰性的bean，即初始化非延迟加载的bean
      */
      finishBeanFactoryInitialization(beanFactory);
      /**
      * 通过spring的事件发布机制发布ContextRefreshedEvent事件，以保证对应的监听器做进一步的
处理
      * 即对那种在spring启动后需要处理的一些类，这些类实现了
ApplicationListener<ContextRefreshedEvent>，
      * 这里就是要触发这些类的执行(执行onApplicationEvent方法)
      * 另外，spring的内置Event有ContextClosedEvent、ContextRefreshedEvent、
ContextStartedEvent、ContextStoppedEvent、RequestHandleEvent
      * 完成初始化，通知生命周期处理器lifeCycleProcessor刷新过程，同时发出
ContextRefreshEvent通知其他人
      */
      finishRefresh();
   }
finally {
 
      resetCommonCaches();
   }
 }
}

6. IOC容器的后置处理

一个扩展方法，源码如下：

默认为空，如果有自定义需求可以重写，比如打印一些启动结束日志等。

7. 发出结束执行的事件

同样是 EventPublishingRunListener 这个监听器，广播 ApplicationStartedEvent 事件。

但是这里广播事件和前几次不同，并不是广播给 SpringApplication 中的监听器（在构建过程中从
spring.factories 文件获取的监听器）。因此在 IOC容器 中注入的监听器（使用 @Component 等方
式注入的）也能够生效。前面几个事件只有在 spring.factories 文件中设置的监听器才会生效。

跟着代码进入，可以看到 started() 方法源码如下：