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 机制去扫描 META-INF/spring.factories ，加载 ApplicationContextInitializer 接口的实例，这个类当springboot上下文Context初始化完成后会调用
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //同上,这个 ApplicationListener 类当springboot启动时事件change后都会触发
    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以后，运行时间就以纳秒进行跟踪了)
    StopWatch stopWatch = new StopWatch();
    //计时器启动
    stopWatch.start();
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    //设置环境变量
    configureHeadlessProperty();
    //获取事件监听器SpringApplicationRunListener类型
    SpringApplicationRunListeners listeners = getRunListeners(args);
    //入参是上下文对象和前边new SpringApplication最后那个堆栈跟踪的返回值，这里就启动了监听器
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
      //然后把参数封装成提供运行SpringApplication 的参数的访问的这个接口对象，通过这个接口的默认实现类进行的
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //然后把环境和上下文以及上边它刚刚封装好的那个参数访问对象绑定
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      //对环境的值判断，以及设置
      configureIgnoreBeanInfo(environment);
      //然后打印 banner （就是那个启动后的控制台比较大的那个spring boot）（终于直到那个图形哪里来的了）
      Banner printedBanner = printBanner(environment);
      //创建上下文，根据项目类型创建上下文，这个创建的方法里是要用到new 时候那个 WebApplicationType
      context = createApplicationContext();
      //保存使用ApplicationStartup来标记应用程序启动期间的步骤，以及记录一些收集到的执行上下文或其处理时间的数据
      context.setApplicationStartup(this.applicationStartup);
      //准备上下文，将前边的几个变量全丢进这个方法的参数里
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
      //这个就是非常重要的东西了，是spring 的启动代码，这里边扫描并初始化 bean 了，然后 spring boot 内嵌的web 容器也在这里边被启动，需要进去细看了。
      refreshContext(context);
      //进去看了以下发现啥也没干
      afterRefresh(context, applicationArguments);
      //停止计时器
      stopWatch.stop();
      if (this.logStartupInfo) {
        //启动时记录程序的信息，并打印日志
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      //执行ApplicationRunListeners中的started()方法
      listeners.started(context);
      //执行两个Runner（ApplicationRunner和CommandLineRunner）
      callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
      //处理运行失败
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
    }

    try {
      //执行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();
      }
    }
  }