SpringBoot的启动--源码学习

启动

spring boot启动代码如下：

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

代码显示，main方法中执行SpringApplication的静态方法run()，run方法中会构造一个SpringApplication实例，然后执行。

SpringApplication的构造过程

首先SpringApplication会执行构造函数:

    public SpringApplication(Object... sources) {
        initialize(sources);
    }

debug会发现source值为：

sources.png

sources目前是一个Application的class对象
构造函数中会执行initialize()方法：

image.png

debug类deduceWebEnvironment：
这个方法中，首先deduceWebEnvironment检验网络环境。具体方法是检查默认类加载器是否加载过Servlet和ConfigurableWebApplicationContext这两个类。如果加载过，那么即为Web应用。

image.png image.png

initialize方法中:
从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化后设置到SpringApplication的initializers属性中。这个过程也就是找出所有的应用程序初始化器；第二步，getSpringFactoriesInstances方法接受ApplicationContextInitializer作为参数。然后一直调用到getSpringFactoriesInstances方法。

      setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

此时ApplicationContextInitializer接口，应用程序初始化器，做一些初始化的工作：

ApplicationContextInitializer.png

接口实现如下图：

image.png

分析getSpringFactoriesInstances

getSpringFactoriesInstances.png

上面的SpringFactoriesLoader.loadFactoryNames方法看这里

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

loadFactoryNames.png
可以查看下spring.factories文件,spring-boot-autoconfigure和 spring-boot的jar包中都有
image.png

当SpringApplication创建,初始化了上述的 Application Context和Application Listeners

image

通过spring.factories文件拿到一系列的Context和Listener之后 执行run方法
run方法会从spring.factories文件中获取到run listener,然后在spirng boot 执行到各个阶段时执行Listener事件和Context事件
所以，所谓的SpringApplicationRunListeners实际上就是在SpringApplication对象的run方法执行的不同阶段，去执行一些操作，并且这些操作是可配置的。

SpringApplication的run方法代码如下：

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch(); // 构造一个任务执行观察器
        stopWatch.start(); // 开始执行，记录开始时间
        ConfigurableApplicationContext context = null;
        configureHeadlessProperty();
        // 获取SpringApplicationRunListeners，内部只有一个EventPublishingRunListener
        SpringApplicationRunListeners listeners = getRunListeners(args);
         // 上面分析过，会封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
        // 这里接受ApplicationStartedEvent事件的listener会执行相应的操作
        listeners.started();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args); // 构造一个应用程序参数持有类
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments); //应用程序的环境信息准备
            Banner printedBanner = printBanner(environment); // 是否在控制台上打印自定义的banner
            context = createApplicationContext();  // 创建Spring容器
            analyzers = new FailureAnalyzers(context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);  //准备容器
            refreshContext(context);
            afterRefresh(context, applicationArguments);   // 容器创建完成之后执行额外一些操作
            listeners.finished(context, null);// 广播出ApplicationReadyEvent事件给相应的监听器执行
            stopWatch.stop(); // 执行结束，记录执行时间
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            return context; // 返回Spring容器
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }

下面看其中的部分方法：

prepareEnvironment

    private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
        // 创建应用程序的环境信息。如果是web程序，创建StandardServletEnvironment；否则，创建StandardEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment(); 
          // 配置一些环境信息。比如profile，命令行参数
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        listeners.environmentPrepared(environment);// 广播出ApplicationEnvironmentPreparedEvent事件给相应的监听器执行
        if (isWebEnvironment(environment) && !this.webEnvironment) {   // 环境信息的校对
            environment = convertToStandardEnvironment(environment);
        }
        return environment;
    }

Spring容器的创建createApplicationContext方法如下：

protected ConfigurableApplicationContext createApplicationContext() {
      Class<?> contextClass = this.applicationContextClass;
      if (contextClass == null) {
        try {
          // 如果是web程序，那么构造org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext容器
          // 否则构造org.springframework.context.annotation.AnnotationConfigApplicationContext容器
          contextClass = Class.forName(this.webEnvironment
              ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
        }
        catch (ClassNotFoundException ex) {
          throw new IllegalStateException(
              "Unable create a default ApplicationContext, "
                  + "please specify an ApplicationContextClass",
              ex);
        }
      }
      return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
    }

prepareContext 准备容器的方法

private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment); // 设置Spring容器的环境信息
        postProcessApplicationContext(context); // 回调方法，Spring容器创建之后做一些额外的事
        applyInitializers(context); // SpringApplication的的初始化器开始工作
        listeners.contextPrepared(context); // 遍历调用SpringApplicationRunListener的contextPrepared方法。目前只是将这个事件广播器注册到Spring容器中
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans  
        // 把应用程序参数持有类注册到Spring容器中，并且是一个单例
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources  
        Set<Object> sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[sources.size()]));
        listeners.contextLoaded(context);  // 广播出ApplicationPreparedEvent事件给相应的监听器执行
    }

refreshContext 刷新容器：

Spring容器的刷新refresh方法内部会做很多很多的事情：比如BeanFactory的设置，BeanFactoryPostProcessor接口的执行、BeanPostProcessor接口的执行、自动化配置类的解析、条件注解的解析、国际化的初始化等等。

    private void refreshContext(ConfigurableApplicationContext context) {
        refresh(context);        // Spring容器的刷新
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }

afterRefresh

run方法中的Spring容器创建完成之后会调用afterRefresh方法，代码如下：

    protected void afterRefresh(ConfigurableApplicationContext context,
            ApplicationArguments args) {
        callRunners(context, args);/ 调用Spring容器中的ApplicationRunner和CommandLineRunner接口的实现类
    }

    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<Object>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values()); // 找出Spring容器中ApplicationRunner接口的实现类
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());// 找出Spring容器中CommandLineRunner接口的实现类
        AnnotationAwareOrderComparator.sort(runners); // 对runners进行排序
        for (Object runner : new LinkedHashSet<Object>(runners)) { // 遍历runners依次执行
            if (runner instanceof ApplicationRunner) {  // 如果是ApplicationRunner，进行ApplicationRunner的run方法调用
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) { // 如果是CommandLineRunner，进行CommandLineRunner的run方法调用
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

这样run方法执行完成之后。Spring容器也已经初始化完成，各种监听器和初始化器也做了相应的工作。

总结

SpringBoot启动的时候，不论调用什么方法，都会构造一个SpringApplication的实例，然后调用这个实例的run方法，这样就表示启动SpringBoot。

在run方法调用之前，也就是构造SpringApplication的时候会进行初始化的工作，初始化的时候会做以下几件事：

1 把参数sources设置到SpringApplication属性中，这个sources可以是任何类型的参数。本文的例子中这个sources就是Application的class对象
2 判断是否是web程序，并设置到webEnvironment这个boolean属性中
3 找出所有的初始化器，默认有5个，设置到initializers属性中
4 找出所有的应用程序监听器，默认有9个，设置到listeners属性中
5 找出运行的主类(main class)

SpringApplication构造完成之后调用run方法，启动SpringApplication，run方法执行的时候会做以下几件事：

1 构造一个StopWatch，观察SpringApplication的执行
2 找出所有的SpringApplicationRunListener并封装到SpringApplicationRunListeners中，用于监听run方法的执行。监听的过程中会封装成事件并广播出去让初始化过程中产生的应用程序监听器进行监听
3 构造Spring容器(ApplicationContext)，并返回
     3.1 创建Spring容器的判断是否是web环境，是的话构造
       AnnotationConfigEmbeddedWebApplicationContext，否则构造
       AnnotationConfigApplicationContext
     3.2 初始化过程中产生的初始化器在这个时候开始工作
     3.3 Spring容器的刷新(完成bean的解析、各种processor接口的执行、条件注解的解析等等)
4 从Spring容器中找出ApplicationRunner和CommandLineRunner接口的实现类并排序后依次执行