Spring Boot源码分析三：启动流程

前言

本文是作者写关于Spring源码的第一篇文章，作者水平有限，所有的源码文章仅限用作个人学习记录。文中如有错误欢迎各位留言指正。

createSpringFactoriesInstances

上文说到读取配置文件spring.factories时，将读取到配置文件中的类进行实例化，现在来看这个方法。

// 参数分别是 类型，参数类型，类加载器，参数，类名称
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
      ClassLoader classLoader, Object[] args, Set<String> names) {
      // 初始化一个与类名集合大小一样的集合
   List<T> instances = new ArrayList<>(names.size());
   // 遍历类名集合逐一实例化
   for (String name : names) {
      try {
         // 这里又实用到了ClassUtils，使用这个工具类获取到这个类名称字符串的类型。这个工具类的forName方法的写法很好，我在很多方法都有看到类似的影子。
         // 逻辑大概就是先判断是不是基础类型，如果不是就用类加载器进行加载
         // 只要是我们自己定义的类就是这样Class.forName(name, false, clToUse);
         Class<?> instanceClass = ClassUtils.forName(name, classLoader);
         // 判断type这个Class是不是instanceClass的超类
         Assert.isAssignable(type, instanceClass);
         // 找到Class的指定参数类型的构造方法
         Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
         // 通过构造方法和参数实例化一个类的对象。这又有一个工具类了
         T instance = (T) BeanUtils.instantiateClass(constructor, args);
         // 保存实力对象
         instances.add(instance);
      }
      catch (Throwable ex) {
         throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
      }
   }
   return instances;
}

实例化SpringApplication的构造方法分析完了，接下来就看看SpringApplication的成员方法run方法的逻辑。

run

这个方法有点多，不同版本也有一定的差异。

public ConfigurableApplicationContext run(String... args) {
// 为了计时用的，老版本和新版本不一样
   long startTime = System.nanoTime();
   // 初始化一个引导器的上下文，这是属于Spring Boot的上下文。后边还有一个Spring的上下文。apach好喜欢context这个东西，证明写框架这个context是真的好用。
   DefaultBootstrapContext bootstrapContext = createBootstrapContext();
   // 这是Spring的上下文，在这里定义，在下面进行的初始化
   ConfigurableApplicationContext context = null;
   // 配置一个系统属性
   configureHeadlessProperty();
   // 获取配置文件的监听器 重点 也是扩展点，凡是读取配置文件的地方都是扩展点，因为配置在配置文件中的initializer、listener都会在某个阶段被调用
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting(bootstrapContext, this.mainApplicationClass);
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      configureIgnoreBeanInfo(environment);
      Banner printedBanner = printBanner(environment);
      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);
      }
      listeners.started(context, timeTakenToStartup);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
   }
   try {
      Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
      listeners.ready(context, timeTakenToReady);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

createBootstrapContext

private DefaultBootstrapContext createBootstrapContext() {
// 通过无参构造实例化了一个对象
   DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
   // 遍历SpringApplication的构造方法中读取spring.factories配置文件中BootStrapRegistryInitializer并实例化的对象，并调用它们的initialize方法，这是一个扩展点哟。如果我们给spring.factories中添加BootStrapRegistryInitializer的配置在这里也会执行
   this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
   return bootstrapContext;
}

configureHeadlessProperty

这里可以学习这个写法，存在就用现有的，不存在这设置自己定义的值

private void configureHeadlessProperty() {
    private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
   System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
         System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

getRunListeners

这个方法其实也是比较重的，需要好好分析。 首先是通过getSpringFactoriesInstances方法从配置文件中加载出配置的SpringApplicationRunListener的实现类集合，在加载到配置文件配置的实现类的类名的时候找参数是SpringApplication、String[]的构造函数。传递的参数值就是SpringApplication这个类自己和我们启动类的args方法。

这里我们加载到的是org.springframework.boot.context.event.EventPublishingRunListener。之前就说过写框架的大神都喜欢在构造方法中做一些事情。我们跟进到这个类的构造方法看看，而且我们要看的是参数类型为SpringApplication、String[]的构造函数。

这里还提醒一点如果是类有继承关系，也要注意看当前类继承的类的构造函数有没有做什么事情哟~~~

这里的EventPublishingRunListeneri就是的构造函数中就做了事情。

public EventPublishingRunListener(SpringApplication application, String[] args) {
// 保存了我们的SpringApplication对象
   this.application = application;
   // 保存了我们的启动类的参数
   this.args = args;
   // SimpleApplicationEventMulticaster是Spring框架中用于广播应用程序事件的简单实现。它可以被用来注册和管理事件监听器，以及在事件被触发时通知所有监听器
   // 我们来看看他的构造函数
   this.initialMulticaster = new SimpleApplicationEventMulticaster();
   // 开始遍历我们初始化SpringApplication的时候从配置文件加载的Listerner。见下面截图一
   // 并将其加入到事件广播器中，提前预告一下，这里就相当于注册和管理监听器，事件是它的包装类发的，但是最后还是他自己发的，说是发，其实就是循环调用这里添加的监听器的监听onApplicationEvent方法
   for (ApplicationListener<?> listener : application.getListeners()) {
      // 最后是保存在到了DefaultListenerRetriever的applicationListerners的属性中
      // 下面有截图二
      this.initialMulticaster.addApplicationListener(listener);
   }
}

SimpleApplicationEventMulticaster的无参构造函数是空的什么都没有做。

但是它有继承，看看他的父类构造函数有没有做什么。

发现他的父类AbstractApplicationEventMulticaster只有一个隐式的构造函数。所以不用关心。

• 截图一

• 截图二

看看我们最终要创建的对象监听器对象。其实就是一个包装类，行为几乎都依赖他的属性来实现。最重要的就是刚才初始化的EventPublishingRunListener。

OK 今天先到这里吧。

See you next time :)