Spring boot 2.5.x 啟動流程源碼分析

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    //用LinkedHashSet將主類給保存了起來
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //對項目的類型做一個判斷，WebApplicationType枚舉類中有三種，后邊這個方法就是一個判斷方法
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    //這里將對象注冊表初始化，然后保存起來
    this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
    //這個是要通過 SPI 機(jī)制去掃描 META-INF/spring.factories ，加載 ApplicationContextInitializer 接口的實例，這個類當(dāng)springboot上下文Context初始化完成后會調(diào)用
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //同上,這個 ApplicationListener 類當(dāng)springboot啟動時事件change后都會觸發(fā)
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //堆棧跟蹤判斷方法是否是 main 
    this.mainApplicationClass = deduceMainApplicationClass();
  }

org.springframework.context.ApplicationContextInitializer=\
hasaki_w_c.demo.listener.MyApplicationContextInitializer

org.springframework.context.ApplicationListener=\
hasaki_w_c.demo.listener.MyApplicationListener

public ConfigurableApplicationContext run(String... args) {
    //啟動一個 StopWatch 計時器(spring 5.2以后，運行時間就以納秒進(jìn)行跟蹤了)
    StopWatch stopWatch = new StopWatch();
    //計時器啟動
    stopWatch.start();
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    //設(shè)置環(huán)境變量
    configureHeadlessProperty();
    //獲取事件監(jiān)聽器SpringApplicationRunListener類型
    SpringApplicationRunListeners listeners = getRunListeners(args);
    //入?yún)⑹巧舷挛膶ο蠛颓斑卬ew SpringApplication最后那個堆棧跟蹤的返回值，這里就啟動了監(jiān)聽器
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
      //然后把參數(shù)封裝成提供運行SpringApplication 的參數(shù)的訪問的這個接口對象，通過這個接口的默認(rèn)實現(xiàn)類進(jìn)行的
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //然后把環(huán)境和上下文以及上邊它剛剛封裝好的那個參數(shù)訪問對象綁定
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      //對環(huán)境的值判斷，以及設(shè)置
      configureIgnoreBeanInfo(environment);
      //然后打印 banner （就是那個啟動后的控制臺比較大的那個spring boot）（終于直到那個圖形哪里來的了）
      Banner printedBanner = printBanner(environment);
      //創(chuàng)建上下文，根據(jù)項目類型創(chuàng)建上下文，這個創(chuàng)建的方法里是要用到new 時候那個 WebApplicationType
      context = createApplicationContext();
      //保存使用ApplicationStartup來標(biāo)記應(yīng)用程序啟動期間的步驟，以及記錄一些收集到的執(zhí)行上下文或其處理時間的數(shù)據(jù)
      context.setApplicationStartup(this.applicationStartup);
      //準(zhǔn)備上下文，將前邊的幾個變量全丟進(jìn)這個方法的參數(shù)里
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
      //這個就是非常重要的東西了，是spring 的啟動代碼，這里邊掃描并初始化 bean 了，然后 spring boot 內(nèi)嵌的web 容器也在這里邊被啟動，需要進(jìn)去細(xì)看了。
      refreshContext(context);
      //進(jìn)去看了以下發(fā)現(xiàn)啥也沒干
      afterRefresh(context, applicationArguments);
      //停止計時器
      stopWatch.stop();
      if (this.logStartupInfo) {
        //啟動時記錄程序的信息，并打印日志
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      //執(zhí)行ApplicationRunListeners中的started()方法
      listeners.started(context);
      //執(zhí)行兩個Runner（ApplicationRunner和CommandLineRunner）
      callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
      //處理運行失敗
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
    }

    try {
      //執(zhí)行ApplicationRunListeners中的started()方法
      listeners.running(context);
    }
    catch (Throwable ex) {
      //處理運行失敗
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
    }
    return context;
  }

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
      StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
        // Allows post-processing of the bean factory in context subclasses.
        postProcessBeanFactory(beanFactory);

        StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
        // Invoke factory processors registered as beans in the context.
        invokeBeanFactoryPostProcessors(beanFactory);

        // Register bean processors that intercept bean creation.
        registerBeanPostProcessors(beanFactory);
        beanPostProcess.end();

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

        // Initialize event multicaster for this context.
        initApplicationEventMulticaster();

        // Initialize other special beans in specific context subclasses.
        //這個重點看一下
        onRefresh();

        // Check for listener beans and register them.
        registerListeners();

        // Instantiate all remaining (non-lazy-init) singletons.
        finishBeanFactoryInitialization(beanFactory);

        // Last step: publish corresponding event.
        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();
        contextRefresh.end();
      }
    }
  }