9千字长文带你了解SpringBoot启动过程--史上最详细 SpringBoot启动流程-图文并茂_spring boot的运行流程

进入run方法后，会 new 一个SpringApplication 对象，创建这个对象的构造函数做了一些准备工作，编号第2~5步就是构造函数里面所做的事情

1. /**
2. * Static helper that can be used to run a {@link SpringApplication} from the
3. * specified sources using default settings and user supplied arguments.
4. * @param primarySources the primary sources to load
5. * @param args the application arguments (usually passed from a Java main method)
6. * @return the running {@link ApplicationContext}
7. */
8. public static ConfigurableApplicationContext run (Class<?>[] primarySources,
9. String[] args) {
10. return new SpringApplication(primarySources).run(args);
11. }

另外在说明一下，springboot启动有三种方式，其他的启动方式可参照我的另一个帖子： SpringBoot的三种启动方式

2、确定应用程序类型

在SpringApplication的构造方法内，首先会通过 WebApplicationType.deduceFromClasspath()； 方法判断当前应用程序的容器，默认使用的是Servlet 容器，除了servlet之外，还有NONE  和 REACTIVE （响应式编程）；

3、加载所有的初始化器

这里加载的初始化器是springboot自带初始化器，从从 META-INF/spring.factories 配置文件中加载的，那么这个文件在哪呢？自带有2个，分别在源码的jar包的  spring-boot-autoconfigure 项目 和 spring-boot 项目里面各有一个

spring.factories文件里面，看到开头是  org.springframework.context.ApplicationContextInitializer 接口就是初始化器了 ，

当然，我们也可以自己实现一个自定义的初始化器：实现  ApplicationContextInitializer接口既可

MyApplicationContextInitializer.java

1. package com.spring.application;
3. import org.springframework.context.ApplicationContextInitializer;
4. import org.springframework.context.ConfigurableApplicationContext;
5. /**
6. * 自定义的初始化器
7. */
8. public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
9. @Override
10. public void initialize (ConfigurableApplicationContext configurableApplicationContext) {
11. System.out.println( "我是初始化的 MyApplicationContextInitializer...");
12. }
13. }

在resources目录下添加 META-INF/spring.factories 配置文件，内容如下，将自定义的初始化器注册进去；

1. org.springframework.context.ApplicationContextInitializer=\
2. com.spring.application.MyApplicationContextInitializer

启动springboot后，就可以看到控制台打印的内容了，在这里我们可以很直观的看到它的执行顺序，是在打印banner的后面执行的；

 4、加载所有的监听器

加载监听器也是从 META-INF/spring.factories 配置文件中加载的，与初始化不同的是，监听器加载的是实现了 ApplicationListener 接口的类

自定义监听器也跟初始化器一样，依葫芦画瓢就可以了，这里不在举例；

5、设置程序运行的主类

deduceMainApplicationClass();  这个方法仅仅是找到main方法所在的类，为后面的扫包作准备，deduce是推断的意思，所以准确地说，这个方法作用是推断出主方法所在的类；

6、开启计时器

程序运行到这里，就已经进入了run方法的主体了，第一步调用的run方法是静态方法，那个时候还没实例化SpringApplication对象，现在调用的run方法是非静态的，是需要实例化后才可以调用的，进来后首先会开启计时器，这个计时器有什么作用呢？顾名思义就使用来计时的嘛，计算springboot启动花了多长时间；关键代码如下：

1. // 实例化计时器
2. StopWatch stopWatch = new StopWatch();
3. // 开始计时
4. stopWatch.start();

 run方法代码段截图

 

7、将java.awt.headless设置为true

这里将java.awt.headless设置为true，表示运行在服务器端，在没有显示器器和鼠标键盘的模式下照样可以工作，模拟输入输出设备功能。

做了这样的操作后,SpringBoot想干什么呢?其实是想设置该应用程序,即使没有检测到显示器,也允许其启动.对于服务器来说,是不需要显示器的,所以要这样设置.

方法主体如下：

1. private void configureHeadlessProperty () {
2. System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
3. SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString( this.headless)));
4. }

通过方法可以看到，setProperty()方法里面又有个getProperty()；这不多此一举吗？其实getProperty()方法里面有2个参数， 第一个key值，第二个是默认值，意思是通过key值查找属性值，如果属性值为空，则返回默认值 true；保证了一定有值的情况；

8、获取并启用监听器

这一步 通过监听器来实现初始化的的基本操作，这一步做了2件事情

1. 创建所有 Spring 运行监听器并发布应用启动事件
2. 启用监听器

9、设置应用程序参数

将执行run方法时传入的参数封装成一个对象

 仅仅是将参数封装成对象，没啥好说的，对象的构造函数如下

1. public DefaultApplicationArguments (String[] args) {
2. Assert.notNull(args, "Args must not be null");
3. this.source = new Source(args);
4. this.args = args;
5. }

那么问题来了，这个参数是从哪来的呢？其实就是main方法里面执行静态run方法传入的参数，

10、准备环境变量

准备环境变量，包含系统属性和用户配置的属性，执行的代码块在  prepareEnvironment 方法内

打了断点之后可以看到，它将maven和系统的环境变量都加载进来了

11、忽略bean信息

 这个方法configureIgnoreBeanInfo() 这个方法是将 spring.beaninfo.ignore 的默认值值设为true，意思是跳过beanInfo的搜索，其设置默认值的原理和第7步一样；

1. private void configureIgnoreBeanInfo (ConfigurableEnvironment environment) {
2. if (System.getProperty(
3. CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {
4. Boolean ignore = environment.getProperty( "spring.beaninfo.ignore",
5. Boolean.class, Boolean.TRUE);
6. System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,
7. ignore.toString());
8. }
9. }

当然也可以在配置文件中添加以下配置来设为false

spring.beaninfo.ignore = false

目前还不知道这个配置的具体作用，待作者查明后在补上

12、打印 banner 信息

显而易见，这个流程就是用来打印控制台那个很大的spring的banner的，就是下面这个东东

那他在哪里打印的呢？他在 SpringBootBanner.java 里面打印的，这个类实现了Banner 接口，

而且banner信息是直接在代码里面写死的；

有些公司喜欢自定义banner信息，如果想要改成自己喜欢的图标该怎么办呢，其实很简单,只需要在resources目录下添加一个 banner.txt 的文件即可，txt文件内容如下

1. _ _
2. (_) | |
3. _ _ _____ ___ _ __ __| | ___ _ __ __ _
4. | | | |/ _ \ \/ / | '_ \ / _` |/ _ \| '_ \ / _` |
5. | |_| | __/> <| | | | | (_| | (_) | | | | (_| |
6. \__, |\___/_/\_\_|_| |_|\__,_|\___/|_| |_|\__, |
7. __/ | __/ |
8. |___/ |___/
9. :: yexindong::

一定要添加到resources目录下，别加错了

只需要加一个文件即可，其他什么都不用做，然后直接启动springboot，就可以看到效果了

13、创建应用程序的上下文

实例化应用程序的上下文， 调用 createApplicationContext() 方法，这里就是用反射创建对象，没什么好说的；

14、实例化异常报告器

异常报告器是用来捕捉全局异常使用的，当springboot应用程序在发生异常时，异常报告器会将其捕捉并做相应处理，在spring.factories 文件里配置了默认的异常报告器，

需要注意的是，这个异常报告器只会捕获启动过程抛出的异常，如果是在启动完成后，在用户请求时报错，异常报告器不会捕获请求中出现的异常，

了解原理了，接下来我们自己配置一个异常报告器来玩玩；

MyExceptionReporter.java 继承 SpringBootExceptionReporter 接口

1. package com.spring.application;
3. import org.springframework.boot.SpringBootExceptionReporter;
4. import org.springframework.context.ConfigurableApplicationContext;
6. public class MyExceptionReporter implements SpringBootExceptionReporter {
9. private ConfigurableApplicationContext context;
10. // 必须要有一个有参的构造函数，否则启动会报错
11. MyExceptionReporter(ConfigurableApplicationContext context) {
12. this.context = context;
13. }
15. @Override
16. public boolean reportException (Throwable failure) {
17. System.out.println( "进入异常报告器");
18. failure.printStackTrace();
19. // 返回false会打印详细springboot错误信息，返回true则只打印异常信息
20. return false;
21. }
22. }

在  spring.factories 文件中注册异常报告器

1. # Error Reporters 异常报告器
2. org.springframework.boot.SpringBootExceptionReporter =\
3. com.spring.application.MyExceptionReporter

接着我们在application.yml 中 把端口号设置为一个很大的值，这样肯定会报错，

 
 

   
   

    
    

   
   
   
   

    
    

     
     server:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
       port: 
     
     80828888
    
    
   
   
 
 

启动后，控制台打印如下图

15、准备上下文环境 

这里准备的上下文环境是为了下一步刷新做准备的，里面还做了一些额外的事情；

15.1、实例化单例的beanName生成器

在  postProcessApplicationContext(context); 方法里面。使用单例模式创建 了BeanNameGenerator 对象，其实就是beanName生成器，用来生成bean对象的名称

15.2、执行初始化方法

初始化方法有哪些呢？还记得第3步里面加载的初始化器嘛？其实是执行第3步加载出来的所有初始化器，实现了ApplicationContextInitializer 接口的类

15.3、将启动参数注册到容器中

这里将启动参数以单例的模式注册到容器中，是为了以后方便拿来使用，参数的beanName 为 ：springApplicationArguments

16、刷新上下文

刷新上下文已经是spring的范畴了，自动装配和启动 tomcat就是在这个方法里面完成的，还有其他的spring自带的机制在这里就不一一细说了，

17、刷新上下文后置处理

afterRefresh 方法是启动后的一些处理，留给用户扩展使用，目前这个方法里面是空的，

• /**
• * Called after the context has been refreshed.
• * @param context the application context
• * @param args the application arguments
• */
• protected void afterRefresh (ConfigurableApplicationContext context,
• ApplicationArguments args) {
• }
• 18、结束计时器

  到这一步，springboot其实就已经完成了，计时器会打印启动springboot的时长

  

  在控制台看到启动还是挺快的，不到2秒就启动完成了；

  

  19、发布上下文准备就绪事件

  告诉应用程序，我已经准备好了，可以开始工作了

  

  20、执行自定义的run方法

   这是一个扩展功能，callRunners(context, applicationArguments) 可以在启动完成后执行自定义的run方法；有2中方式可以实现：

  1. 实现 ApplicationRunner 接口
  2. 实现 CommandLineRunner 接口

  接下来我们验证一把，为了方便代码可读性，我把这2种方式都放在同一个类里面

  1. package com.spring.init;
  3. import org.springframework.boot.ApplicationArguments;
  4. import org.springframework.boot.ApplicationRunner;
  5. import org.springframework.boot.CommandLineRunner;
  6. import org.springframework.stereotype.Component;
  8. /**
  9. * 自定义run方法的2种方式
  10. */
  11. @Component
  12. public class MyRunner implements ApplicationRunner, CommandLineRunner {
  14. @Override
  15. public void run (ApplicationArguments args) throws Exception {
  16. System.out.println( " 我是自定义的run方法1，实现 ApplicationRunner 接口既可运行" );
  17. }
  19. @Override
  20. public void run (String... args) throws Exception {
  21. System.out.println( " 我是自定义的run方法2，实现 CommandLineRunner 接口既可运行" );
  22. }
  23. }
  

  启动springboot后就可以看到控制台打印的信息了

  

  完

      其实了解springboot启动原理对开发人员还是有好处的，至少你知道哪些东西是可以扩展的，以及怎么扩展，它的内部原理是怎么做的，我相信了解这些思路之后，让你自己写一个springboot出来也是可以的； 但是这里只是列出了启动过程，并不涉及到全部，源码是很负杂，记得一个大牛说过：“我们看源码的时候，只能通过联想或猜测作者是怎么想的，并且小心验证，就像我们小时候学古诗一样，也只能去猜测古人的想法，拿道德经来说，每个人读完后都有不同的看法，这就需要见仁见智了”；