本文主要是记录自己学习的过程，主要参考了下面所附三篇文档的内容，总结了一下。

1 概述

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(AppServer.class);
        application.run(args);
    }
}

Spring的启动过程可以分成三个部分：
第一部分进行SpringApplication的初始化模块
配置一些基本的环境变量、资源、构造器、监听器。
第二部分实现了应用具体的启动方案
包括启动流程的监听模块、加载配置环境模块、及核心的创建上下文环境模块
第三部分是自动化配置模块
该模块作为springboot自动配置核心

Copy的别人的一个启动结构图：

image.png

2 初始化模块

SpringApplication的构造函数实例化了 初始化上下文的各种接口--ApplicationContextInitializer以及监听器--ApplicationListener。
这里的实例化，不像平时的Spring Components一样通过注解和扫包完成，而是通过一种不依赖Spring上下文的加载方法，这样才能在Spring完成启动前做各种配置。
Spring的解决方法是以接口的全限定名作为key，实现类的全限定名作为value记录在项目的META-INF/spring.factories文件中，然后通过SpringFactoriesLoader工具类提供静态方法进行类加载并缓存下来，spring.factories是Spring Boot的核心配置文件。
有意思的是两个deduce方法，Spring Boot项目主要的目标之一就是自动化配置，通过这两个deduce方法可以看出，Spring Boot的判断方法之一是检查系统中是否存在的核心类。

1. 判断了当前类型是否web
2. 加载所有的初始化器
3. 加载所有的监听器
4. 设置程序运行的主类

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //通过核心类判断是否开启、开启什么web容器
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    //实例化初始器
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //实例化监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   //设置程序运行的主类
    this.mainApplicationClass = deduceMainApplicationClass();
}

3 启动流程详解

Springboot启动的流程，可以将其划分为18步。具体如下：

1.创建并启动计时监控类
org.springframework.util下的StopWatch类
此计时器是为了监控并记录 Spring Boot 应用启动的时间的，它会记录当前任务的名称，然后开启计时器。

2.声明应用上下文对象和异常报告集合

此过程声明了应用上下文对象。
同时声明了异常报告集合用于收集错误信息，用于向用户报告错误原因。

3.设置系统属性 headless 的值
4.创建所有 Spring 运行监听器并发布应用启动事件

此过程用于获取配置的监听器名称并实例化所有的类。

5.初始化默认应用的参数类

也就是说声明并创建一个应用参数对象。

6.准备环境

创建配置并且绑定环境（通过 property sources 和 profiles 等配置文件）。

7.创建 Banner 的打印类

Spring Boot 启动时会打印 Banner 图片

此 banner 信息是在 SpringBootBanner 类中定义的，我们可以通过实现 Banner 接口来自定义 banner 信息，然后通过代码 setBanner() 方法设置 Spring Boot 项目使用自己自定义 Banner 信息，或者是在 resources 下添加一个 banner.txt，把 banner 信息添加到此文件中，就可以实现自定义 banner 的功能了。

8.创建应用上下文

根据不同的应用类型来创建不同的 ApplicationContext 上下文对象。

9.实例化异常报告器

它调用的是 getSpringFactoriesInstances() 方法来获取配置异常类的名称，并实例化所有的异常处理类。

10.准备应用上下文

此方法的主要作用是把上面已经创建好的对象，传递给 prepareContext 来准备上下文，例如将环境变量 environment 对象绑定到上下文中、配置 bean 生成器以及资源加载器、记录启动日志等操作。

11.刷新应用上下文

此方法用于解析配置文件，加载 bean 对象，并且启动内置的 web 容器等操作。

12.应用上下文刷新之后的事件处理

13.停止计时监控类

停止此过程第一步中的程序计时器，并统计任务的执行信息。

14.输出日志信息

把相关的记录信息，如类名、时间等信息进行控制台输出。

15.发布应用上下文启动完成事件

触发所有 SpringApplicationRunListener 监听器的 started 事件方法。

16.执行所有 Runner 运行器

执行所有的 ApplicationRunner 和 CommandLineRunner 运行器。

17.发布应用上下文就绪事件

触发所有的 SpringApplicationRunListener 监听器的 running 事件。

18.返回应用上下文对象

public ConfigurableApplicationContext run(String... args){
   // 1. 创建并启动计时监控类
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // 2. 声明应用上下文对象和异常报告集合
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
    // 3. 设置系统属性 headless 的值
    this.configureHeadlessProperty();
    // 4. 创建所有 Spring 运行监听器并发布应用启动事件
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    listeners.starting();
    Collection exceptionReporters;
    try {
        // 5. 处理 args 参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 6. 准备环境
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        //7. 创建 Banner 的打印类
        Banner printedBanner = this.printBanner(environment);
        // 8. 创建应用上下文
        context = this.createApplicationContext();
        // 9. 实例化异常报告器
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        // 10. 准备应用上下文
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 11. 刷新应用上下文
        this.refreshContext(context);
        // 12. 应用上下文刷新之后的事件的处理
        this.afterRefresh(context, applicationArguments);
        // 13. 停止计时监控类
        stopWatch.stop();
        // 14. 输出日志记录执行主类名、时间信息
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }
        // 15. 发布应用上下文启动完成事件
        listeners.started(context);
        // 16. 执行所有 Runner 运行器
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }
    try {
        // 17. 发布应用上下文就绪事件
        listeners.running(context);
        // 18. 返回应用上下文对象
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}

4 自动化配置

第11步的刷新应用上下文<refreshContext(context)>方法是实现spring-boot-starter-*(mybatis、redis等)自动化配置的关键，包括spring.factories的加载，bean的实例化等核心工作。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //记录启动时间、状态，web容器初始化其property，复制listener
        prepareRefresh();
        //这里返回的是context的BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        //beanFactory注入一些标准组件，例如ApplicationContextAwareProcessor，ClassLoader等
        prepareBeanFactory(beanFactory);
        try {
            //给实现类留的一个钩子，例如注入BeanPostProcessors，这里是个空方法
            postProcessBeanFactory(beanFactory);

            // 调用切面方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册切面bean
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            initMessageSource();

            // bean工厂注册一个key为applicationEventMulticaster的广播器
            initApplicationEventMulticaster();

            // 给实现类留的一钩子，可以执行其他refresh的工作，这里是个空方法
            onRefresh();

            // 将listener注册到广播器中
            registerListeners();

            // 实例化未实例化的bean
            finishBeanFactoryInitialization(beanFactory);

            // 清理缓存，注入DefaultLifecycleProcessor，发布ContextRefreshedEvent
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

从上面的应用初始化和启动过程中可以看到，都调用了SpringBoot自动配置模块.

image.png

上面配置模块使用到了SpringFactoriesLoader，即Spring工厂加载器，该对象提供了loadFactoryNames方法，入参为factoryClass和classLoader，即需要传入上图中的工厂类名称和对应的类加载器，方法会根据指定的classLoader，加载该类加器搜索路径下的指定文件，即spring.factories文件，传入的工厂类为接口，而文件中对应的类则是接口的实现类，或最终作为实现类，所以文件中一般为如下图这种一对多的类名集合，获取到这些实现类的类名后，loadFactoryNames方法返回类名集合，方法调用方得到这些集合后，再通过反射获取这些类的类对象、构造方法，最终生成实例。

image.png

参考：
Spring Boot启动过程分析
Creating a Custom Starter with Spring Boot
SpringBoot启动流程解析