SpringBoot- 启动原理（下）

SpringBoot系列- 启动原理（下）

   从上一篇文章《SpringBoot系列-启动原理（上）》中，介绍了SpringBoot应用启动的核心方法run()的整体情况。这篇文章来详细展开介绍。其中比较重要的方法会标记上***

   一、createBootstrapContext ***

   DefaultBootstrapContext bootstrapContext = createBootstrapContext();

   1. SpringApplication#createBootstrapContext方法：

   private DefaultBootstrapContext createBootstrapContext() {
     DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
     this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
     return bootstrapContext;
   }

   DefaultBootstrapContext 是 Spring Boot 2.4 版本引入的，它是用来提供应用启动时的一些早期引导操作。它允许在创建 ApplicationContext 之前，提前加载和初始化某些关键组件或资源。这对于某些在启动时需要提前初始化的场景非常重要，例如：

• 配置属性源的初始化（如 Environment 配置）
• 提供一些应用启动时的依赖资源（如外部配置文件、网络服务的连接等）

   2. bootstrapContext 与 applicationContext 的区别

   1) bootstrapContext 

   bootstrapContext 是在 applicationContext 之前的一个轻量级上下文，它不会管理 bean 的生命周期，也不会处理依赖注入等常规操作。它主要用于在应用上下文完全初始化前，提前处理一些启动相关的任务。

   2) applicationContext  

   applicationContext 是完整的 Spring 容器，用于管理应用的 bean 生命周期、依赖注入、事件驱动等。

   二、getRunListeners ***

   SpringApplicationRunListeners listeners = this.getRunListeners(args);

   创建所有 Spring 运行监听器。从META-INF/spring.factories中获取并启动监听器。这些监听器都是SpringApplicationRunListener接口的实现类。 

   这里面涉及到SPI扩展机制，详细请参考文章《SpringBoot系列- SPI机制》

   1.  getRunListeners() 

   SpringApplication#getRunListeners() ，源码如下：  

    private SpringApplicationRunListeners getRunListeners(String[] args) {
        Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };

        // 通过getSpringFactoriesInstances方法指定SpringApplicationRunListener 类型来加载的
        // 注意下参数 this 就是当前的 SpringApplication 对象，用于获取监听器集合
        return new SpringApplicationRunListeners(logger,
                getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
                this.applicationStartup);
    }      

   2. getSpringFactoriesInstances() 

   SpringApplication#getSpringFactoriesInstances() ，源码如下：  

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
    return getSpringFactoriesInstances(type, new Class<?>[]{});
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    //从META-INF/spring.factories中加载对应类型的类的自动配置类
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 加载上来后反射实例化
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    //对实例列表进行排序
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

    3. SpringFactoriesLoader

    SpringFactoriesLoader#loadFactoryNames

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    SpringFactoriesLoader类的两个核心方法：loadFactoryNames() 是用来寻找spring.factories文件中的Factory名称的，loadFactories() 是用来寻找类的。

   三、starting ***

   listeners.starting(bootstrapContext, this.mainApplicationClass);

   广播SpringApplicationEvent事件，分发给监听器列表

   SpringApplicationRunListeners#starting()，源码如下：

    void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
        doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
                (step) -> {
                    if (mainApplicationClass != null) {
                        step.tag("mainApplicationClass", mainApplicationClass.getName());
                    }
                });
    }

   四、prepareEnvironment ***

   ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

   准备环境，项目运行环境Environment的预配置

   SpringApplication#prepareEnvironment()，源码如下：

    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
            DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        // 创建并配置当前SpringBoot应用将要使用的Environment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach(environment);

        //广播ApplicationEnvironmentPreparedEvent事件,分发给监听器列表
        listeners.environmentPrepared(bootstrapContext, environment);
         //... 
        return environment;
    }

   五、printBanner 

   Banner printedBanner = printBanner(environment);

   创建 Banner 的打印类

   六、createApplicationContext ***

   context = this.createApplicationContext();

   创建Spring容器，即创建应用上下文。根据应用程序的类型，创建相应的ApplicationContext实例。

   1. SpringApplication#createApplicationContext()

    protected ConfigurableApplicationContext createApplicationContext() {
        return this.applicationContextFactory.create(this.webApplicationType);
    }

   2. WebApplicationType 枚举类

public enum WebApplicationType {
   NONE,
   SERVLET,
   REACTIVE;
   //...
}

   WebApplicationType 是 Spring Boot 中的一个枚举类，用于表示应用程序的类型，即 Spring Boot 应用程序的运行环境类型。这个枚举类在 Spring Boot 启动时用于确定应用程序是 Web 应用程序（如 MVC、WebFlux）, 还是非 Web 应用程序（如命令行工具）。它主要有以下三种类型：

   1)  NONE:  非 Web 应用（CLI、批处理等)。这种类型的应用程序不需要嵌入式的 Web 服务器，如 Tomcat、Jetty、Undertow 等。

   2) SERVLET: 基于 Servlet 的传统 Web 应用（如使用 Spring MVC）。此类型的应用程序需要嵌入式的 Web 服务器，并且支持 Spring MVC 来处理 HTTP 请求。

   3) REACTIVE: 基于反应式编程模型的 Web 应用（如使用 Spring WebFlux）。

   这里默认的应用程序类型为SERVLET。

  七、prepareContext ***

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

  准备应用上下文：这一步主要是在容器刷新之前的准备动作。包含一个非常关键的操作：将启动类注入容器，为后续开启自动化配置奠定基础。

    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {

        //广播ApplicationContextInitializedEvent事件，分发给监听器列表
        listeners.contextPrepared(context);

        //加载 Bean 定义，包括启动类
        load(context, sources.toArray(new Object[0]));

        //广播ApplicationPreparedEvent事件，分发给监听器列表
        listeners.contextLoaded(context);

        //...
    }

   上下文加载时，把通过SPI机制加载进来的监听器注册到上下文中。后面AbstractApplicationContext#refresh()方法中registerListeners()中会将上下文中的监听器取出来，注册到多播器上去。

   EventPublishingRunListener#contextLoaded方法

 

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        for (ApplicationListener<?> listener : this.application.getListeners()) {
            if (listener instanceof ApplicationContextAware) {
                ((ApplicationContextAware) listener).setApplicationContext(context);
            }
            context.addApplicationListener(listener);
        }
        this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
    }

   八、refreshContext ***

   this.refreshContext(context);

   这里调用了Spring的refresh方法，详细请参考文章《Spring容器系列-启动原理（下）》

    private void refreshContext(ConfigurableApplicationContext context) {
        if (this.registerShutdownHook) {
            shutdownHook.registerApplicationContext(context);
        }
        refresh(context);
    }

   这里我们看下refresh方法中第9个方法onRefresh()

   主要作用：模版方法，由子类重写。用于在容器刷新时执行特定的自定义操作：如创建Tomcat，Jetty等WEB服务器

   ServletWebServerApplicationContext#onRefresh()

    protected void onRefresh() {
        super.onRefresh();
        try {
            // 创建Tomcat，Jetty等WEB服务器
            createWebServer();
        }
        catch (Throwable ex) {
            throw new ApplicationContextException("Unable to start web server", ex);
        }
    }

   可以看到在SpringBoot项目中，对onRefresh这个方法进行了重写，内嵌了Tomcat的启动。

   九、 afterRefresh

   afterRefresh(context, applicationArguments);

   应用上下文刷新之后的事件的处理

   SpringApplication#afterRefresh()，源码如下：

//扩展接口，设计模式中的模板方法，默认为空实现。
//如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
}

   十、started ***

   listeners.started(context, timeTakenToStartup);

   广播ApplicationStartedEvent事件，分发给监听器列表

    @Override
    public void started(ConfigurableApplicationContext context, Duration timeTaken) {
        context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
        AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
    }

   十一、callRunners

   callRunners(context, applicationArguments);

   调用并执行所有实现了 ApplicationRunner 和 CommandLineRunner 接口的类，使得在项目启动完成后立即执行一些特定程序。Runner 运行器用于在服务启动时进行一些业务初始化操作（比如初始化数据、加载资源、连接外部服务等），这些操作只在服务启动后执行一次。

   SpringApplication#callRunners()，源码如下：

    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet<>(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

   1. ApplicationRunner 接口

@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

   2. CommandLineRunner 接口

@FunctionalInterface
public interface CommandLineRunner {
   void run(String... args) throws Exception;
}

  ApplicationRunner 和 CommandLineRunner 接口的主要区别在于命令行参数的处理方式：ApplicationRunner 接受已经解析的参数通过 ApplicationArguments 对象，而 CommandLineRunner 则是原始的字符串数组。

   十二、ready

   listeners.ready(context, timeTakenToReady); 

   广播ApplicationReadyEvent事件，分发给监听器列表

 

    @Override
    public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
        context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context, timeTaken));
        AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
    }