请添加图片描述

SpringBoot源码主线分析

??我们要分析一个框架的源码不可能通过一篇文章就搞定的，本文我们就来分析下SpringBoot源码中的主线流程。先掌握SpringBoot项目启动的核心操作，然后我们再深入每一个具体的实现细节，注：本系列源码都以SpringBoot2.2.5.RELEASE版本来讲解

1.SpringBoot启动的入口

??当我们启动一个SpringBoot项目的时候，入口程序就是main方法，而在main方法中就执行了一个run方法。

1@SpringBootApplication
2public class StartApp {
3
4    public static void main(String[] args) {
5        SpringApplication.run(StartApp.class);
6    }
7}

2.run方法

??然后我们进入run()方法中看。代码比较简单

??调用了重载的一个run()方法，将我们传递进来的类对象封装为了一个数组，仅此而已。我们再进入run()方法。

1    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
2        // 创建了一个SpringApplication对象，并调用其run方法
3        // 1.先看下构造方法中的逻辑
4        // 2.然后再看run方法的逻辑
5        return new SpringApplication(primarySources).run(args);
6    }

??在该方法中创建了一个SpringApplication对象。同时调用了SpringApplication对象的run方法。这里的逻辑有分支，先看下SpringApplication的构造方法中的逻辑

3.SpringApplication构造器

??我们进入SpringApplication的构造方法，看的核心代码为

 1    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
 2        // 传递的resourceLoader为null
 3        this.resourceLoader = resourceLoader;
 4        Assert.notNull(primarySources, "PrimarySources must not be null");
 5        // 记录主方法的配置类名称
 6        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
 7        // 记录当前项目的类型
 8        this.webApplicationType = WebApplicationType.deduceFromClasspath();
 9        // 加载配置在spring.factories文件中的ApplicationContextInitializer对应的类型并实例化
10        // 并将加载的数据存储在了 initializers 成员变量中。
11        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
12        // 初始化监听器 并将加载的监听器实例对象存储在了listeners成员变量中
13        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
14        // 反推main方法所在的Class对象 并记录在了mainApplicationClass对象中
15        this.mainApplicationClass = deduceMainApplicationClass();
16    }

??在本方法中完成了几个核心操作

1. 推断当前项目的类型
2. 加载配置在spring.factories文件中的ApplicationContextInitializer中的类型并实例化后存储在了initializers中。
3. 和2的步骤差不多，完成监听器的初始化操作，并将实例化的监听器对象存储在了listeners成员变量中
4. 通过StackTrace反推main方法所在的Class对象

??上面的核心操作具体的实现细节我们在后面的详细文章会给大家剖析

4.run方法

??接下来我们在回到SpringApplication.run()方法中。

 1    public ConfigurableApplicationContext run(String... args) {
 2        // 创建一个任务执行观察器
 3        StopWatch stopWatch = new StopWatch();
 4        // 开始执行记录执行时间
 5        stopWatch.start();
 6        // 声明 ConfigurableApplicationContext 对象
 7        ConfigurableApplicationContext context = null;
 8        // 声明集合容器用来存储 SpringBootExceptionReporter 启动错误的回调接口
 9        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
10        // 设置了一个名为java.awt.headless的系统属性
11        // 其实是想设置该应用程序,即使没有检测到显示器,也允许其启动.
12        //对于服务器来说,是不需要显示器的,所以要这样设置.
13        configureHeadlessProperty();
14        // 获取 SpringApplicationRunListener 加载的是 EventPublishingRunListener
15        // 获取启动时到监听器
16        SpringApplicationRunListeners listeners = getRunListeners(args);
17        // 触发启动事件
18        listeners.starting();
19        try {
20            // 构造一个应用程序的参数持有类
21            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
22            // 创建并配置环境
23            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
24            // 配置需要忽略的BeanInfo信息
25            configureIgnoreBeanInfo(environment);
26            // 输出的Banner信息
27            Banner printedBanner = printBanner(environment);
28            // 创建应用上下文对象
29            context = createApplicationContext();
30            // 加载配置的启动异常处理器
31            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
32                    new Class[] { ConfigurableApplicationContext.class }, context);
33            // 刷新前操作
34            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
35            // 刷新应用上下文 完成Spring容器的初始化
36            refreshContext(context);
37            // 刷新后操作
38            afterRefresh(context, applicationArguments);
39            // 结束记录启动时间
40            stopWatch.stop();
41            if (this.logStartupInfo) {
42                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
43            }
44            // 事件广播 启动完成了
45            listeners.started(context);
46            callRunners(context, applicationArguments);
47        }
48        catch (Throwable ex) {
49            // 事件广播启动出错了
50            handleRunFailure(context, ex, exceptionReporters, listeners);
51            throw new IllegalStateException(ex);
52        }
53        try {
54            // 监听器运行中
55            listeners.running(context);
56        }
57        catch (Throwable ex) {
58            handleRunFailure(context, ex, exceptionReporters, null);
59            throw new IllegalStateException(ex);
60        }
61        // 返回上下文对象--> Spring容器对象
62        return context;
63    }

??在这个方法中完成了SpringBoot项目启动的很多核心的操作，我们来总结下上面的步骤

1. 创建了一个任务执行的观察器，统计启动的时间
2. 声明ConfigurableApplicationContext对象
3. 声明集合容器来存储SpringBootExceptionReporter即启动错误的回调接口
4. 设置java.awt.headless的系统属性
5. 获取我们之间初始化的监听器(EventPublishingRunListener),并触发starting事件
6. 创建ApplicationArguments这是一个应用程序的参数持有类
7. 创建ConfigurableEnvironment这时一个配置环境的对象
8. 配置需要忽略的BeanInfo信息
9. 配置Banner信息对象
10. 创建对象的上下文对象
11. 加载配置的启动异常的回调异常处理器
12. 刷新应用上下文，本质就是完成Spring容器的初始化操作
13. 启动结束记录启动耗时
14. 完成对应的事件广播
15. 返回应用上下文对象。

??到此SpringBoot项目的启动初始化的代码的主要流程就介绍完成了。细节部分后面详细讲解。

请添加图片描述