Spring系列八股20 - SpringBoot3 (Spring Boot 启动原理)

@SpringBootApplication
public class Demo1Application {
    public static void main(String[] args) {
        SpringApplication.run(Demo1Application.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((ResourceLoader)null, primarySources);
}

public SpringApplication(@Nullable ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.addCommandLineProperties = true;
    this.addConversionService = true;
    this.headless = true;
    this.initializers = new ArrayList();
    this.listeners = new ArrayList();
    this.additionalProfiles = Collections.emptySet();
    this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
    this.applicationStartup = ApplicationStartup.DEFAULT;
    this.properties = new ApplicationProperties();
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "'primarySources' must not be null");
    this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    this.properties.setWebApplicationType(WebApplicationType.deduce());
    this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

public interface ApplicationContextFactory {
    ApplicationContextFactory DEFAULT = new DefaultApplicationContextFactory();
    ...
}

this.properties.setWebApplicationType(WebApplicationType.deduce());`

// 伪代码：
StackTraceElement[] stack = new RuntimeException().getStackTrace();
for (StackTraceElement element : stack) {
    if ("main".equals(element.getMethodName())) {
        return Class.forName(element.getClassName());  // 找到了
    }
}

public ConfigurableApplicationContext run(String... args) {
  // 记录启动时间（用于最后算启动耗时）
  // 还会看有没有 CoRC 快照
  Startup startup = SpringApplication.Startup.create();

  // 注册 JVM 关闭钩子，确保应用关闭时能优雅释放资源（关闭数据库连接池等）
  if (this.properties.isRegisterShutdownHook()) {
      shutdownHook.enableShutdownHookAddition();
  }

  // 创建引导上下文（给 Bootstrapper 扩展用，一般用不到）
  DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();

  // 注册了上下文
  ConfigurableApplicationContext context = null;

  // 设置 headless 模式（服务器环境没有显示器，告诉 JVM 不需要图形界面）
  this.configureHeadlessProperty();

  // 获取所有 SpringApplicationRunListener，准备广播启动事件
  SpringApplicationRunListeners listeners = this.getRunListeners(args);
  listeners.starting(bootstrapContext, this.mainApplicationClass);

  try {
      // 包装命令行参数（就是 main 方法的 args）
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

      // 准备环境：读取 application.properties / application.yml，处理 profile 等
      ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);

      // 打印 Banner
      Banner printedBanner = this.printBanner(environment);

      // 创建一个空的 ApplicationContext 容器（只是 new 出来，还什么都没有）
      // 这里便会注册对应的 PostProcessBeanFactory
      context = this.createApplicationContext();

      // 把环境、Banner 等信息塞进容器，完成容器的预备工作
      context.setApplicationStartup(this.applicationStartup);
      this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

      // 上面是初始化工作
      this.refreshContext(context);

      // 扩展点，目前是空实现，留给子类重写用
      this.afterRefresh(context, applicationArguments);
      // 记录启动耗时
      Duration timeTakenToStarted = startup.started();

      // 打印启动日志，就是你控制台看到的那行：
      // Started MyApplication in 2.345 seconds (JVM running for 3.012)
      if (this.properties.isLogStartupInfo()) {
          (new StartupInfoLogger(this.mainApplicationClass, environment)).logStarted(this.getApplicationLog(), startup);
      }

      // 通知所有监听器"容器已启动"
      listeners.started(context, timeTakenToStarted);
      // 调用你自定义的 Runner
      this.callRunners(context, applicationArguments);
  } catch (Throwable ex) {
      throw this.handleRunFailure(context, ex, listeners);
  }

  try {
      if (context.isRunning()) {
          listeners.ready(context, startup.ready());
      }

      return context;
  } catch (Throwable ex) {
      throw this.handleRunFailure(context, ex, (SpringApplicationRunListeners)null);
  }
}

ConfigurableApplicationContext context = null;

context = this.createApplicationContext();
...
protected ConfigurableApplicationContext createApplicationContext() {
    ConfigurableApplicationContext context = this.applicationContextFactory.create(this.properties.getWebApplicationType());
    Assert.state(context != null, "ApplicationContextFactory created null context");
    return context;
}

// DefaultApplicationContextFactory 内部逻辑（简化）：
public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
    return switch (webApplicationType) {
        case SERVLET   -> new AnnotationConfigServletWebServerApplicationContext();  // 普通 Web
        case REACTIVE  -> new AnnotationConfigReactiveWebServerApplicationContext(); // 响应式
        case NONE      -> new AnnotationConfigApplicationContext();                  // 非 Web
    };
}

this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

// SpringApplication.java
public ConfigurableApplicationContext run(String... args) {
    ...
    this.refreshContext(context);
    ...
}

private void refreshContext(ConfigurableApplicationContext context) {
    if (this.properties.isRegisterShutdownHook()) {
        shutdownHook.registerApplicationContext(context);
    }

    this.refresh(context);
}

protected void refresh(ConfigurableApplicationContext applicationContext) {
    applicationContext.refresh();
}

// ServletWebServerApplicationContext.java
public final void refresh() throws BeansException, IllegalStateException {
    try {
        super.refresh();
    } catch (RuntimeException var5) {
        WebServer webServer = this.webServer;
        if (webServer != null) {
            try {
                webServer.stop();
                webServer.destroy();
            } catch (RuntimeException stopOrDestroyEx) {
                var5.addSuppressed(stopOrDestroyEx);
            }
        }

        throw var5;
    }
}

// AbstractApplicationContext.java
public void refresh() {
  // 加锁，防止并发重复刷新容器
  this.startupShutdownLock.lock();

  try {
      // ━━━━━━━━━━━ 第一阶段：准备工作 ━━━━━━━━━━━

      // 1 刷新前的预处理：校验必填属性、初始化事件集合等
      this.prepareRefresh();

      // 2 获取 BeanFactory（DefaultListableBeanFactory）
      //    如果是 XML 配置，这里会解析 XML 加载 BeanDefinition
      //    注解驱动的话，这里拿到的是一个已存在的空工厂
      ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

      // 3 给 BeanFactory 配置基础设施：
      //    - 注册 ClassLoader
      //    - 注册内置 Bean（如 environment、systemProperties）
      //    - 添加几个默认的 BeanPostProcessor
      this.prepareBeanFactory(beanFactory);

      try {
          // ━━━━━━━━━━━ 第二阶段：BeanDefinition 处理 ━━━━━━━━━━━

          // 4 扩展点：子类可以在这里对 BeanFactory 做额外处理（模板方法）
          //    Web 容器在这里注册了 request/session 作用域
          this.postProcessBeanFactory(beanFactory);

          // 5 【核心】执行所有 BeanFactoryPostProcessor
          //    ConfigurationClassPostProcessor 就在这里被调用！
          //    → 解析 @Configuration、@ComponentScan、@Import、@Bean
          //    → 所有图纸（BeanDefinition）在这一步全部注册完毕
          this.invokeBeanFactoryPostProcessors(beanFactory);

          // 6 注册所有 BeanPostProcessor（只是注册，还没执行）
          //    比如 AutowiredAnnotationBeanPostProcessor（处理 @Autowired）
          //    比如 AopAwareObjenesisCglibAopProxy（处理 AOP）
          this.registerBeanPostProcessors(beanFactory);

          // ━━━━━━━━━━━ 第三阶段：初始化各种基础组件 ━━━━━━━━━━━

          // 7 初始化国际化资源（i18n，MessageSource）
          this.initMessageSource();

          // 8 初始化事件广播器（ApplicationEventMulticaster）
          //    后面发布事件靠它
          this.initApplicationEventMulticaster();

          // 9 扩展点：子类在这里做特殊初始化
          //    SpringBoot Web 容器在这里启动内嵌 Tomcat！
          this.onRefresh();

          // 10 注册所有 ApplicationListener 监听器
          this.registerListeners();

          // ━━━━━━━━━━━ 第四阶段：实例化 Bean ━━━━━━━━━━━

          // 11 【核心】实例化所有非懒加载的单例 Bean
          //    @Autowired 注入、AOP 代理、@PostConstruct 都在这里执行
          this.finishBeanFactoryInitialization(beanFactory);

          // 12 收尾：清理缓存、发布 ContextRefreshedEvent 事件
          this.finishRefresh();

      } catch (Error | RuntimeException ex) {
          // 出错了：停掉 Lifecycle Bean，销毁已创建的 Bean，取消刷新
          this.destroyBeans();
          this.cancelRefresh(ex);
          throw ex;
      }
  } finally {
      this.startupShutdownLock.unlock();
  }
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory,
        List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // 记录已经处理过的处理器名字，避免重复执行
    Set<String> processedBeans = new HashSet();

    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    // 第一大块：处理 BeanDefinitionRegistryPostProcessor
    // （比普通 BeanFactoryPostProcessor 更强，能注册新图纸）
    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    if (beanFactory instanceof BeanDefinitionRegistry registry) {
        // 用来存放两种处理器：
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList();           // 普通的
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList();  // 能注册图纸的

        // ── 第 0 轮：处理外部手动传入的处理器（编程式注册，不在图纸里）──
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
                // 注册额外图纸
                // 然后将功能给 internalConfigurationAnnotationProcessor
                // 通过 registry（注册中心），把我们在第一张截图中看到的那个排名第一的 internalConfigurationAnnotationProcessor（ConfigurationClassPostProcessor，也就是解析注解的核心包工头）的 BeanDefinition（图纸）给翻了出来
                // 把包工头默认的阅读器替换成了自己造的高级缓存阅读器
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
                // 普通的 → 先收集，最后再执行
                regularPostProcessors.add(postProcessor);
            }
        }

        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList();

        // ── 第 1 轮：从图纸里找 PriorityOrdered 的（最高优先级）──
        // ConfigurationClassPostProcessor 就在这里
        // 它实现了 PriorityOrdered
        String[] postProcessorNames = beanFactory.getBeanNamesForType(
                BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // getBean：实例化这个处理器（第一次真正造这个 Bean）
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName); // 标记已处理
            }
        }
        // 排序
        sortPostProcessors(currentRegistryProcessors, beanFactory); 
        registryProcessors.addAll(currentRegistryProcessors);
        
        // 执行！
        // ConfigurationClassPostProcessor 在这里扫描 @ComponentScan @Import 等
        // 新的 BeanDefinition 开始注册进来
        // 从 BeanDefinitionMap 里找有配置注解的图纸 → 解析它们 → 发现新图纸 → 注册进 BeanDefinitionMap → 循环，直到没有新图纸为止
        // 这段代码内部的流程其实非常纯粹，它就是一个带有性能监控的 for 循环
        // 会写一个 for 循环，挨个把 currentRegistryProcessors 集合里的包工头叫出来
        // 然后执行 postProcessor.postProcessBeanDefinitionRegistry(registry);
        // 当循环遍历到我们的主角 ConfigurationClassPostProcessor 时，前置条件全部满足，魔法开始生效
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // ── 第 2 轮：从图纸里找 Ordered 的（次优先级）──
        // 注意：重新 getBeanNamesForType，因为第 1 轮可能注册了新的处理器图纸
        postProcessorNames = beanFactory.getBeanNamesForType(
                BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // ── 第 3 轮：while 循环处理剩余的（滚雪球！）──
        // 每执行一批处理器，可能又注册进来新的处理器图纸，所以要不断重新扫描
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false; // 先假设没有新的
            postProcessorNames = beanFactory.getBeanNamesForType(
                    BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    // 发现没处理过的新处理器！
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true; // 标记还要再循环一次
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        // 所有 RegistryPostProcessor 的图纸注册完了之后
        // 再统一调用它们的 postProcessBeanFactory()（普通后置处理方法）
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 外部手动传入的普通处理器，最后执行
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

    } else {
        // beanFactory 不支持注册图纸，直接执行传入的处理器
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    // 第二大块：处理普通 BeanFactoryPostProcessor
    // （只能改图纸，不能注册新图纸）
    // 注意：上面已处理过的不再重复（processedBeans 过滤）
    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 按优先级分三组
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList(); // PriorityOrdered
    List<String> orderedPostProcessorNames = new ArrayList();                       // Ordered
    List<String> nonOrderedPostProcessorNames = new ArrayList();                    // 普通

    for (String ppName : postProcessorNames) {
        if (!processedBeans.contains(ppName)) { // 跳过已处理的
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            } else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
    }

    // 按顺序依次执行三组：PriorityOrdered → Ordered → 普通
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清理元数据缓存（因为图纸都处理完了，缓存已过时）
    beanFactory.clearMetadataCache();
}

// 第一轮：实现了 PriorityOrdered 的（最高优先级）
// ConfigurationClassPostProcessor 就在这里！它实现了 PriorityOrdered
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class);
for (String ppName : postProcessorNames) {
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
        // 实例化并执行 → ConfigurationClassPostProcessor 在这里被触发
        // → 开始扫描 @ComponentScan、@Import，注册新的图纸
    }
}

// 第二轮：实现了 Ordered 的（次优先级）
for (String ppName : postProcessorNames) {
    if (!processedBeans.contains(ppName) && isTypeMatch(ppName, Ordered.class)) { ... }
}

// 第三轮：while 循环 ← 就是"滚雪球"的核心！
while (reiterate) {
    reiterate = false;
    postProcessorNames = beanFactory.getBeanNamesForType(...); // 重新扫，有没有新的？
    for (String ppName : postProcessorNames) {
        if (!processedBeans.contains(ppName)) {
            // 有新的处理器图纸被注册进来了！继续执行
            reiterate = true;  // ← 标记还要再循环
        }
    }
}

// 按优先级分三组，依次执行：
// PriorityOrdered → Ordered → 普通
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);