SpringBoot启动流程分析

参考：

https://www.jianshu.com/p/d51e1896a5f7
http://412887952-qq-com.iteye.com/blog/2345379

1.程序入口代码：

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

2.进入之后会进入到SpringApplication.java类中：

    public static ConfigurableApplicationContext run(Object source, String... args) {
       return run(new Object[] { source }, args);
    }

3.进入重构run()方法：

    public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
       return new SpringApplication(sources).run(args);
    }

4.这里new了一个SpringApplication对象出来，然后调用其run方法，我们先看看这个new SpringApplication的过程：

public SpringApplication(Object... sources) {
       initialize(sources);  // sources目前是一个MyApplication的class对象
    }

5.看下具体的initialize（）方法：

private void initialize(Object[] sources) {
      if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources)); // 把sources设置到SpringApplication的sources属性中，目前只是一个MyApplication类对象
      }
      this.webEnvironment = deduceWebEnvironment(); // 判断是否是web程序(javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext都必须在类加载器中存在)，并设置到webEnvironment属性中
      // 从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化后设置到SpringApplication的initializers属性中。这个过程也就是找出所有的应用程序初始化器
      setInitializers((Collection) getSpringFactoriesInstances(
          ApplicationContextInitializer.class));
      // 从spring.factories文件中找出key为ApplicationListener的类并实例化后设置到SpringApplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器
      setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
      // 找出main类，这里是MyApplication类
      this.mainApplicationClass = deduceMainApplicationClass();
    }

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

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
        void initialize(C applicationContext);
    }

ApplicationListener，应用程序事件(ApplicationEvent)监听器：

 public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
        void onApplicationEvent(E event);
 }

注意：此处的ApplicationListener有别于下面的SpringApplicationRunListener
这里的应用程序事件(ApplicationEvent)有应用程序启动事件(ApplicationStartedEvent)，失败事件(ApplicationFailedEvent)，准备事件(ApplicationPreparedEvent)等。

应用程序事件监听器跟监听事件是绑定的。比如ConfigServerBootstrapApplicationListener只跟ApplicationEnvironmentPreparedEvent事件绑定，LiquibaseServiceLocatorApplicationListener只跟ApplicationStartedEvent事件绑定，LoggingApplicationListener跟所有事件绑定等。

默认情况下，initialize方法从spring.factories文件中找出的key为ApplicationContextInitializer的类有：
org.springframework.boot.context.config.DelegatingApplicationContextInitializer
org.springframework.boot.context.ContextIdApplicationContextInitializer
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
org.springframework.boot.context.web.ServerPortInfoApplicationContextInitializer
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

key为ApplicationListener的有：
org.springframework.boot.context.config.ConfigFileApplicationListener
org.springframework.boot.context.config.AnsiOutputApplicationListener
org.springframework.boot.logging.LoggingApplicationListener
org.springframework.boot.logging.ClasspathLoggingApplicationListener
org.springframework.boot.autoconfigure.BackgroundPreinitializer
org.springframework.boot.context.config.DelegatingApplicationListener
org.springframework.boot.builder.ParentContextCloserApplicationListener
org.springframework.boot.context.FileEncodingApplicationListener
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

从上面的代码我们看到初始化做了以下几件事情：

5.1 this.webEnvironment = deduceWebEnvironment();

这一个方法决定创建的是一个WEB应用还是一个SPRING的标准Standalone应用。如果入方法可以看到其是怎么判断的：

private boolean deduceWebEnvironment() {
       for (String className : WEB_ENVIRONMENT_CLASSES) {
           if (!ClassUtils.isPresent(className, null)) {
              return false;
           }
       }
       return true;
    }

其中WEB_ENVIRONMENT_CLASSES是一个静态常量数组：

private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
         "org.springframework.web.context.ConfigurableWebApplicationContext" };

可以看到是根据org.springframework.util.ClassUtils的静态方法去判断classpath里面是否有WEB_ENVIRONMENT_CLASSES包含的类，如果有都包含则返回true则表示启动一个WEB应用，否则返回false启动一个标准Spring的应用。

是否启动一个WEB应用就是取决于classpath下是否有javax.servlet.Servlet和
org.springframework.web.context.ConfigurableWebApplicationContext。

5.2 进入下一个阶段：

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

这个方法则是初始化classpath下的所有的可用的ApplicationContextInitializer

5.3 下一步：

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

这个方法则是初使化classpath下的所有的可用的ApplicationListener

5.4 下一步：

this.mainApplicationClass = deduceMainApplicationClass();

我们找到对应的deduceMainApplicationClass()方法：

   private Class<?> deduceMainApplicationClass() {
       try {
           StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
           for (StackTraceElement stackTraceElement : stackTrace) {
              if ("main".equals(stackTraceElement.getMethodName())) {
                  return Class.forName(stackTraceElement.getClassName());
              }
           }
       }
       catch (ClassNotFoundException ex) {
           // Swallow and continue
       }
       return null;
    }
}

最后找出main方法的全类名并返回其实例并设置到SpringApplication的this.mainApplicationClass完成初始化。然后调用SpringApplication实例的run方法来启动应用

SpringApplication的执行

分析run方法之前，先看一下SpringApplication中的一些事件和监听器概念。

首先是SpringApplicationRunListeners类和SpringApplicationRunListener类的介绍。

SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。

SpringApplicationRunListener看名字也知道用于监听SpringApplication的run方法的执行。

它定义了5个步骤：

  • started(run方法执行的时候立马执行；对应事件的类型是ApplicationStartedEvent)
  • environmentPrepared(ApplicationContext创建之前并且环境信息准备好的时候调用；对应事件的类型是ApplicationEnvironmentPreparedEvent)
  • contextPrepared(ApplicationContext创建好并且在source加载之前调用一次；没有具体的对应事件)
  • contextLoaded(ApplicationContext创建并加载之后并在refresh之前调用；对应事件的类型是ApplicationPreparedEvent)
  • finished(run方法结束之前调用；对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent)

SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener，它把监听的过程封装成了SpringApplicationEvent事件并让内部属性(属性名为multicaster)ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去，广播出去的事件对象会被SpringApplication中的listeners属性进行处理。

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

所以说SpringApplicationRunListener和ApplicationListener之间的关系是通过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系起来的。


image

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);
        // 创建Spring容器
        context = createAndRefreshContext(listeners, applicationArguments);
        // 容器创建完成之后执行额外一些操作
        afterRefresh(context, applicationArguments);
        // 广播出ApplicationReadyEvent事件给相应的监听器执行
        listeners.finished(context, null);
        stopWatch.stop(); // 执行结束，记录执行时间
        if (this.logStartupInfo) {
          new StartupInfoLogger(this.mainApplicationClass)
              .logStarted(getApplicationLog(), stopWatch);
        }
        return context; // 返回Spring容器
      }
      catch (Throwable ex) {
        handleRunFailure(context, listeners, ex); // 这个过程报错的话会执行一些异常操作、然后广播出ApplicationFailedEvent事件给相应的监听器执行
        throw new IllegalStateException(ex);
      }
    }

创建容器的方法createAndRefreshContext如下：

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

      if (this.bannerMode != Banner.Mode.OFF) { // 是否在控制台上打印自定义的banner
        printBanner(environment);
      }

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

      // 把应用程序参数持有类注册到Spring容器中，并且是一个单例
      context.getBeanFactory().registerSingleton("springApplicationArguments",
          applicationArguments);

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

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

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);
    }

Spring容器创建之后有个回调方法postProcessApplicationContext：

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        if (this.webEnvironment) { // 如果是web程序
            if (context instanceof ConfigurableWebApplicationContext) { // 并且也是Spring Web容器
                ConfigurableWebApplicationContext configurableContext = (ConfigurableWebApplicationContext) context;
                if (this.beanNameGenerator != null) { // 如果SpringApplication设置了是实例命名生成器，注册到Spring容器中
                    configurableContext.getBeanFactory().registerSingleton(
                            AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                            this.beanNameGenerator);
                }
            }
        }
        if (this.resourceLoader != null) { // 如果SpringApplication设置了资源加载器，设置到Spring容器中
            if (context instanceof GenericApplicationContext) {
                ((GenericApplicationContext) context)
                        .setResourceLoader(this.resourceLoader);
            }
            if (context instanceof DefaultResourceLoader) {
                ((DefaultResourceLoader) context)
                        .setClassLoader(this.resourceLoader.getClassLoader());
            }
        }
    }

初始化器做的工作

比如ContextIdApplicationContextInitializer会设置应用程序的id；AutoConfigurationReportLoggingInitializer会给应用程序添加一个条件注解解析器报告等：

protected void applyInitializers(ConfigurableApplicationContext context) {
      // 遍历每个初始化器，对调用对应的initialize方法
      for (ApplicationContextInitializer initializer : getInitializers()) {
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
            initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
      }
    }

Spring容器的刷新refresh方法内部会做很多很多的事情：

比如BeanFactory的设置，BeanFactoryPostProcessor接口的执行、BeanPostProcessor接口的执行、自动化配置类的解析、条件注解的解析、国际化的初始化等等。这部分内容会在之后的文章中进行讲解。

run方法中的Spring容器创建完成之后会调用afterRefresh方法

代码如下：

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

    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<Object>();
      // 找出Spring容器中ApplicationRunner接口的实现类
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
      // 找出Spring容器中CommandLineRunner接口的实现类
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
      // 对runners进行排序
        AnnotationAwareOrderComparator.sort(runners);
      // 遍历runners依次执行
        for (Object runner : new LinkedHashSet<Object>(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就是MyApplication的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接口的实现类并排序后依次执行
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,716评论 4赞 364
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,558评论 1赞 294
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,431评论 0赞 244
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,127评论 0赞 209
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,511评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,692评论 1赞 222
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,915评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,664评论 0赞 202
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,412评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,616评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,105评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,424评论 2赞 254
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,098评论 3赞 238
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,096评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,869评论 0赞 197
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,748评论 2赞 276
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,641评论 2赞 271

推荐阅读更多精彩内容