可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）

 @SpringBootApplication(
     scanBasePackages = {"com.javaedge.base"}
 )
 public class BaseApplication {
     public BaseApplication() {
     }
 ​
     public static void main(String[] args) {
         SpringApplication.run(BaseApplication.class, args);
     }
 }

 public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
   return run(new Class<?>[] { primarySource }, args);
 } public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   return new SpringApplication(primarySources).run(args);
 }

   public SpringApplication(Class<?>... primarySources) {
     this(null, primarySources);
   }   @SuppressWarnings({ "unchecked", "rawtypes" })
   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程序：
     // jakarta.servlet.Servlet
     // org.springframework.web.context.ConfigurableWebApplicationContext
     // 须都在类加载器中存在，并设置到webEnvironment属性
     this.webApplicationType = WebApplicationType.deduceFromClasspath();
 ​
     // 从 META-INF/spring.factories 中找K=ApplicationContextInitializer的类并实例化后
     // 设置到SpringApplication的initializers属性。即找出所有的应用程序初始化器
     this.bootstrapRegistryInitializers = new ArrayList<>(
         getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
     
     setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
 ​
     // 从spring.factories文件中找出key为ApplicationListener的类并实例化后
     // 设置到SpringApplication的listeners属性。即找出所有的应用程序事件监听器
     setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
     // 找出main类，这里是 BaseApplication 类
     this.mainApplicationClass = deduceMainApplicationClass();
   }

 @FunctionalInterface
 public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
 ​
   /**
    * Initialize the given application context.
    * @param applicationContext the application to configure
    */
   void initialize(C applicationContext);
 ​
 }

 @FunctionalInterface
 public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
 ​
   void onApplicationEvent(E event);
 ​
   static <T> ApplicationListener<PayloadApplicationEvent<T>> forPayload(Consumer<T> consumer) {
     return event -> consumer.accept(event.getPayload());
   }
 ​
 }

 class SpringApplicationRunListeners {
 ​
   // Log日志类
   private final Log log;
 ​
   // 持有SpringApplicationRunListener集合
   private final List<SpringApplicationRunListener> listeners;
 ​
   private final ApplicationStartup applicationStartup;
 ​
   // run方法执行时立马执行；对应事件类型ApplicationStartingEvent
   void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
     doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
         (step) -> {
           if (mainApplicationClass != null) {
             step.tag("mainApplicationClass", mainApplicationClass.getName());
           }
         });
   }
 ​
   // ApplicationContext创建之前并且环境信息准备好的时候调用；对应事件类型ApplicationEnvironmentPreparedEvent
   void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
     doWithListeners("spring.boot.application.environment-prepared",
         (listener) -> listener.environmentPrepared(bootstrapContext, environment));
   }
 ​
   // ApplicationContext创建好并且在source加载之前调用一次；没有具体的对应事件
   void contextPrepared(ConfigurableApplicationContext context) {
     doWithListeners("spring.boot.application.context-prepared", (listener) -> listener.contextPrepared(context));
   }
 ​
   // ApplicationContext创建并加载之后，并在refresh之前调用
   // 对应事件类型ApplicationPreparedEvent
   void contextLoaded(ConfigurableApplicationContext context) {
     doWithListeners("spring.boot.application.context-loaded", (listener) -> listener.contextLoaded(context));
   }
 ​
 ​
   void started(ConfigurableApplicationContext context, Duration timeTaken) {
     doWithListeners("spring.boot.application.started", (listener) -> listener.started(context, timeTaken));
   }
 ​
   void ready(ConfigurableApplicationContext context, Duration timeTaken) {
     doWithListeners("spring.boot.application.ready", (listener) -> listener.ready(context, timeTaken));
   }
 ​
   void failed(ConfigurableApplicationContext context, Throwable exception) {
     doWithListeners("spring.boot.application.failed",
         (listener) -> callFailedListener(listener, context, exception), (step) -> {
           step.tag("exception", exception.getClass().toString());
           step.tag("message", exception.getMessage());
         });
   }
 ​
   private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
       Throwable exception) {
     try {
       listener.failed(context, exception);
     }
     catch (Throwable ex) {
       if (exception == null) {
         ReflectionUtils.rethrowRuntimeException(ex);
       }
       if (this.log.isDebugEnabled()) {
         this.log.error("Error handling failed", ex);
       }
       else {
         String message = ex.getMessage();
         message = (message != null) ? message : "no error message";
         this.log.warn("Error handling failed (" + message + ")");
       }
     }
   }
 ​
   private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
     doWithListeners(stepName, listenerAction, null);
   }
 ​
   private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
       Consumer<StartupStep> stepAction) {
     StartupStep step = this.applicationStartup.start(stepName);
     this.listeners.forEach(listenerAction);
     if (stepAction != null) {
       stepAction.accept(step);
     }
     step.end();
   }
 ​
 }

 /**
  * SpringApplicationRunListener to publish SpringApplicationEvents.
  * Uses an internal ApplicationEventMulticaster for the events that are fired
  * before the context is actually refreshed.
  */
 class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
 ​
   private final SpringApplication application;
 ​
   private final String[] args;
 ​
   private final SimpleApplicationEventMulticaster initialMulticaster;
 ​
   @Override
   public void starting(ConfigurableBootstrapContext bootstrapContext) {
     multicastInitialEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
   }
 ​
   @Override
   public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
       ConfigurableEnvironment environment) {
     multicastInitialEvent(
         new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
   }
 ​
   @Override
   public void contextPrepared(ConfigurableApplicationContext context) {
     multicastInitialEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
   }
 ​
   @Override
   public void contextLoaded(ConfigurableApplicationContext context) {
     for (ApplicationListener<?> listener : this.application.getListeners()) {
       if (listener instanceof ApplicationContextAware contextAware) {
         contextAware.setApplicationContext(context);
       }
       context.addApplicationListener(listener);
     }
     multicastInitialEvent(new ApplicationPreparedEvent(this.application, this.args, context));
   }
 ​
   @Override
   public void started(ConfigurableApplicationContext context, Duration timeTaken) {
     context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
     AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
   }
 ​
   @Override
   public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
     context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context, timeTaken));
     AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
   }
 ​
   @Override
   public void failed(ConfigurableApplicationContext context, Throwable exception) {
     ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
     if (context != null && context.isActive()) {
       // Listeners have been registered to the application context so we should
       // use it at this point if we can
       context.publishEvent(event);
     }
     else {
       // An inactive context may not have a multicaster so we use our multicaster to
       // call all the context's listeners instead
       if (context instanceof AbstractApplicationContext abstractApplicationContext) {
         for (ApplicationListener<?> listener : abstractApplicationContext.getApplicationListeners()) {
           this.initialMulticaster.addApplicationListener(listener);
         }
       }
       this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
       this.initialMulticaster.multicastEvent(event);
     }
   }
 ​
   // 广播事件出去
   private void multicastInitialEvent(ApplicationEvent event) {
     refreshApplicationListeners();
     this.initialMulticaster.multicastEvent(event);
   }
 ​
   private void refreshApplicationListeners() {
     this.application.getListeners().forEach(this.initialMulticaster::addApplicationListener);
   }
 ​
   private static class LoggingErrorHandler implements ErrorHandler {
 ​
     private static final Log logger = LogFactory.getLog(EventPublishingRunListener.class);
 ​
     @Override
     public void handleError(Throwable throwable) {
       logger.warn("Error calling ApplicationEventListener", throwable);
     }
 ​
   }
 ​
 }
 ​

   public ConfigurableApplicationContext run(String... args) {
     // 开始执行，记录开始时间
     long startTime = System.nanoTime();
     DefaultBootstrapContext bootstrapContext = createBootstrapContext();
     ConfigurableApplicationContext context = null;
     // 设置系统属性 java.awt.headless 的值，默认为true
     configureHeadlessProperty();
     
     // 获取SpringApplicationRunListeners，内部只有一个EventPublishingRunListener
     // 创建所有 Spring 运行监听器并发布应用启动事件
     SpringApplicationRunListeners listeners = getRunListeners(args);
     
     // 会封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
     // 这里接受ApplicationStartedEvent事件的listener会执行相应操作
     listeners.starting(bootstrapContext, this.mainApplicationClass);
     try {
       // 初始化默认应用参数类
       ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
       
       // 根据运行监听器和应用参数来准备 Spring 环境
       ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
       Banner printedBanner = printBanner(environment);
       
       // 创建Spring容器，即创建应用上下文
       context = createApplicationContext();
       context.setApplicationStartup(this.applicationStartup);
      // 准备应用上下文
       prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
       refreshContext(context);
       
       // 容器创建完成之后执行额外一些操作
       afterRefresh(context, applicationArguments);
       Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
       if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
       }
       // 广播出ApplicationReadyEvent事件给相应的监听器执行
       // 发布应用上下文启动完成事件
       listeners.started(context, timeTakenToStartup);
       callRunners(context, applicationArguments);
     }
     catch (Throwable ex) {
       if (ex instanceof AbandonedRunException) {
         throw ex;
       }
       handleRunFailure(context, ex, listeners);
       throw new IllegalStateException(ex);
     }
     try {
       if (context.isRunning()) {
         Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
         // 发布应用上下文就绪事件
         listeners.ready(context, timeTakenToReady);
       }
     }
     catch (Throwable ex) {
       if (ex instanceof AbandonedRunException) {
         throw ex;
       }
       // 过程报错的话会执行一些异常操作
       // 然后广播出ApplicationFailedEvent事件给相应的监听器执行
       handleRunFailure(context, ex, null);
       throw new IllegalStateException(ex);
     }
     // 返回Spring容器
     return context;
   }

 private void configureHeadlessProperty() {
   System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
       System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
 }