源码剖析-Run方法执行流程

一、SpringApplication() 构造方法

SpringBoot项目的mian函数

@SpringBootApplication//标注在类上说明这个类是`SpringBoot`的主配置类
public class SpringBootMytestApplication{

   public static void main(String[] args) {
      SpringApplication.run(SpringBootMytestApplication.class, args);
   }
}

点进run方法

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
   // 调用重载方法
   return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   // 两件事：1.初始化SpringApplication  2.执行run方法
   return new SpringApplication(primarySources).run(args);
}

primarySources就是核心启动类对应的Class
继续查看源码，SpringApplication 实例化过程，首先是进入带参数的构造方法，最终回来到两个参数的构造方法。

public SpringApplication(Class<?>... primarySources) {
   this(null, primarySources);
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   //设置资源加载器为null
   this.resourceLoader = resourceLoader;
   //断言加载资源类不能为null
   Assert.notNull(primarySources, "PrimarySources must not be null");
   //将primarySources数组转换为List，最后放到LinkedHashSet集合中
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

   //【1.1 推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是servlet环境 】
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
   //【1.2 初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer 】
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   //【1.3 初始化classpath下所有已配置的 ApplicationListener 】
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   //【1.4 根据调用栈，推断出 main 方法的类名 】
   this.mainApplicationClass = deduceMainApplicationClass();
}

this.resourceLoader = resourceLoader;
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
都是给SpringApplication该类的成员变量赋值

构造函数SpringApplication一共做了四件事
1、推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是servlet环境（后面会用到）
点进WebApplicationType.deduceFromClasspath()方法

private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
      "org.springframework.web.context.ConfigurableWebApplicationContext" };

private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";
/**
 * 判断 应用的类型
 * NONE: 应用程序不是web应用，也不应该用web服务器去启动
 * SERVLET: 应用程序应作为基于servlet的web应用程序运行，并应启动嵌入式servlet web（tomcat）服务器。
 * REACTIVE: 应用程序应作为 reactive web应用程序运行，并应启动嵌入式 reactive web服务器。
 * @return
 */
static WebApplicationType deduceFromClasspath() {
   //classpath下必须存在org.springframework.web.reactive.DispatcherHandler
   if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
         && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
      return WebApplicationType.REACTIVE;
   }

   for (String className : SERVLET_INDICATOR_CLASSES) {
      //classpath环境下不存在javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext
      if (!ClassUtils.isPresent(className, null)) {
         return WebApplicationType.NONE;
      }
   }

   return WebApplicationType.SERVLET;
}

返回类型是WebApplicationType的枚举类型， WebApplicationType 有三个枚举，三个枚举的解释如其中注释具体的判断逻辑如下：

WebApplicationType.REACTIVE classpath下存在org.springframework.web.reactive.DispatcherHandler
WebApplicationType.SERVLET classpath下存在javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext
WebApplicationType.NONE 不满足以上条件。 2、初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer
查看getSpringFactoriesInstances(ApplicationContextInitializer.class) debug查看getSpringFactoriesInstances(ApplicationContextInitializer.class)返回的是七个初始化器实例对象
继续查看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
   //通过指定的classLoader从 META-INF/spring.factories 的资源文件中，
   //读取 key 为 type.getName() 的 value
   Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   //创建工厂实例
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   //对Spring工厂实例排序（org.springframework.core.annotation.Order注解指定的顺序）
   AnnotationAwareOrderComparator.sort(instances);
   return instances;
}

查看SpringFactoriesLoader.loadFactoryNames()该方法在@EnableAutoConfiguration 也有用到，进入该方法

type为org.springframework.context.ApplicationContextInitializer,
而loadSpringFactories方法就是初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer，和上面的七个初始化器实例对象对应上继续查看List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);方法

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 {
         Class<?> instanceClass = ClassUtils.forName(name, classLoader);
         Assert.isAssignable(type, instanceClass);
         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;
}

该方法就是根据反射通过类的全路径将这七个初始化对象生成实例对象存入到List中并返回
最后查看setInitializers，将这七个初始化对象的list赋值给成员变量

public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
   this.initializers = new ArrayList<>(initializers);
}

3、初始化classpath下所有已配置的 ApplicationListener
初始化classpath下 META-INF/spring.factories中已配置的 ApplicationListener。
ApplicationListener 的加载过程和上面的 ApplicationContextInitializer 类的加载过程是一样的。不多说了，至于 ApplicationListener 是spring的事件监听器，典型的观察者模式，通过ApplicationEvent 类和 ApplicationListener 接口，可以实现对spring容器全生命周期的监听，当然也可以自定义监听事件

总结

关于 SpringApplication 类的构造过程，到这里我们就梳理完了。纵观 SpringApplication 类的实例化过程，我们可以看到，合理的利用该类，我们能在spring容器创建之前做一些预备工作，和定制化的需求。

比如，自定义SpringBoot的Banner，比如自定义事件监听器，再比如在容器refresh之前通过自定义 ApplicationContextInitializer 修改配置一些配置或者获取指定的bean都是可以的

二、run() 方法

经过深入分析后，会发现SpringBoot也就是给Spring包了一层皮，事先替我们准备好Spring所需要的环境及一些基础

public ConfigurableApplicationContext run(String... args) {
   //记录程序运行时间
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   // ConfigurableApplicationContext Spring 的上下文
   ConfigurableApplicationContext context = null;
   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
   configureHeadlessProperty();
   //【1、获取并启动监听器】
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //【2、构造应用上下文环境】
      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
      //处理需要忽略的Bean
      configureIgnoreBeanInfo(environment);
      //打印banner
      Banner printedBanner = printBanner(environment);
      ///【3、初始化应用上下文】
      context = createApplicationContext();
      //实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误
      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
            new Class[] { ConfigurableApplicationContext.class }, context);
      //【4、刷新应用上下文前的准备阶段】
      prepareContext(context, environment, listeners, applicationArguments, printedBanner);
      //【5、刷新应用上下文】
      refreshContext(context);
      //【6、刷新应用上下文后的扩展接口】
      afterRefresh(context, applicationArguments);
      //时间记录停止
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      //发布容器启动完成事件
      listeners.started(context);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

SpringBoot源码阅读-run方法执行流程

源码剖析-Run方法执行流程

一、SpringApplication() 构造方法

总结

二、run() 方法