Spring Boot 源码剖析 - 启动流程

public SpringApplication(Class<?>... primarySources) {
  // 传入的类叫做主要源，这也说明了它的重要性
  this(null, primarySources);
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  this.resourceLoader = resourceLoader;
  Assert.notNull(primarySources, "PrimarySources must not be null");
  this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  // 检测应用类型”响应式、Servlet、普通应用
  this.webApplicationType = WebApplicationType.deduceFromClasspath();
  // 设置启动器
  this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
  // 设置初始化器
  setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  // 设置监听器
  setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  // 检测主类
  this.mainApplicationClass = deduceMainApplicationClass();
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
  ClassLoader classLoader = getClassLoader();
  // 获取指定类型的完整类名
  Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
  // 创建它们
  List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
  // 按照@Order注解排序
  AnnotationAwareOrderComparator.sort(instances);
  return instances;
}

// 直接调用了反射创建实例
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;
}

// 注意这个spring.factories的位置
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
  Assert.notNull(factoryType, "'factoryType' must not be null");
  ClassLoader classLoaderToUse = classLoader;
  if (classLoaderToUse == null) {
    classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  }
  // 关键方法，根据指定的工厂类型，获取其实现类们的名字
  List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
  if (logger.isTraceEnabled()) {
    logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
  }
  List<T> result = new ArrayList<>(factoryImplementationNames.size());
  for (String factoryImplementationName : factoryImplementationNames) {
    // 反射实例化这些工厂实现类
    result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
  }
  // 按照Order和Priority注解排序
  AnnotationAwareOrderComparator.sort(result);
  return result;
}

/**
 * Load the fully qualified class names of factory implementations of the
 * given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given
 * class loader.
 * <p>As of Spring Framework 5.3, if a particular implementation class name
 * is discovered more than once for the given factory type, duplicates will
 * be ignored.
 * @param factoryType the interface or abstract class representing the factory
 * @param classLoader the ClassLoader to use for loading resources; can be
 * {@code null} to use the default
 * @throws IllegalArgumentException if an error occurs while loading factory names
 * @see #loadFactories
 */
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());
}

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
  Map<String, List<String>> result = cache.get(classLoader);
  if (result != null) {
    return result;
  }

  result = new HashMap<>();
  try {
    // 获取所有包下的 META-INF/spring.factories 文件
    Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
    while (urls.hasMoreElements()) {
      URL url = urls.nextElement();
      UrlResource resource = new UrlResource(url);
      // 将spring.factories文件的内容加载成属性
      Properties properties = PropertiesLoaderUtils.loadProperties(resource);
      for (Map.Entry<?, ?> entry : properties.entrySet()) {
        String factoryTypeName = ((String) entry.getKey()).trim();
        // 值按逗号拆分
        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
        // 组装成key-list的形式
        for (String factoryImplementationName : factoryImplementationNames) {
          result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
            .add(factoryImplementationName.trim());
        }
      }
    }

    // Replace all lists with unmodifiable lists containing unique elements
    result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                      .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
    cache.put(classLoader, result);
  }
  catch (IOException ex) {
    ... ...
  }
  return result;
}

private static <T> T instantiateFactory(String factoryImplementationName, Class<T> factoryType, ClassLoader classLoader) {
  try {
    Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName, classLoader);
    // 反射实例化
    return (T) ReflectionUtils.accessibleConstructor(factoryImplementationClass).newInstance();
  } catch (Throwable ex) {
    ... ...
  }
}

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";

// 要么是响应式应用、要么是Servlet应用、要么是普通应用
static WebApplicationType deduceFromClasspath() {
  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) {
    if (!ClassUtils.isPresent(className, null)) {
      return WebApplicationType.NONE;
    }
  }
  return WebApplicationType.SERVLET;
}

private Class<?> deduceMainApplicationClass() {
  try {
    StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
    for (StackTraceElement stackTraceElement : stackTrace) {
      if ("main".equals(stackTraceElement.getMethodName())) {
        return Class.forName(stackTraceElement.getClassName());
      }
    }
  } catch (ClassNotFoundException ex) {
    // Swallow and continue
  }
  return null;
}

public ConfigurableApplicationContext run(String... args) {
  // 秒表，仅作为启动时间记录用
  StopWatch stopWatch = new StopWatch();
  stopWatch.start();
  // 创建默认的BootstrapContext，前面说了它是启动阶段的临时容器
  DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  ConfigurableApplicationContext context = null;
  // SpringApplicationRunListener，专为SpringApplication启动的各个阶段准备的监听器
  // 其实只有一个实现类EventPublishingRunListener，用于创建启动中的事件并广播出去
  SpringApplicationRunListeners listeners = getRunListeners(args);
  listeners.starting(bootstrapContext, this.mainApplicationClass);
  try {
    // 命令行参数封装起来
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // 准备环境
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    // 打印banner
    Banner printedBanner = printBanner(environment);
    // 创建容器
    context = createApplicationContext();
    context.setApplicationStartup(this.applicationStartup);
    // 准备容器
    prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    // 刷新容器
    refreshContext(context);
    // 刷新容器的善后处理：默认为空
    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, listeners);
    throw new IllegalStateException(ex);
  }

  try {
    // 广播运行中事件
    listeners.running(context);
  }
  catch (Throwable ex) {
    handleRunFailure(context, ex, null);
    throw new IllegalStateException(ex);
  }
  return context;
}

private SpringApplicationRunListeners getRunListeners(String[] args) {
  Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
  // 从sprin.factories中获取SpringApplicationRunListener子类
  return new SpringApplicationRunListeners(logger,getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args), this.applicationStartup);
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
  // 创建environment对象
  ConfigurableEnvironment environment = getOrCreateEnvironment();
  // 配置环境对象：添加conversionService和命令行参数
  configureEnvironment(environment, applicationArguments.getSourceArgs());
  // 向环境中添加属性源：ConfigurationPropertySource
  ConfigurationPropertySources.attach(environment);
  // 广播环境准备好的消息
  listeners.environmentPrepared(bootstrapContext, environment);
  // 将默认属性移到属性源的最末尾，属性源的顺序很重要
  DefaultPropertiesPropertySource.moveToEnd(environment);
  // 将类中的profile加入environment的activeProfiles中，使得该profile生效
  configureAdditionalProfiles(environment);
  ... ...
  return environment;
}

// 不同的应用类型，需要创建不同的环境对象，前面分析ApplicationContext时说过不同环境对象的区别
private ConfigurableEnvironment getOrCreateEnvironment() {
  if (this.environment != null) {
    return this.environment;
  }
  switch (this.webApplicationType) {
    case SERVLET:
      return new StandardServletEnvironment();
    case REACTIVE:
      return new StandardReactiveWebEnvironment();
    default:
      return new StandardEnvironment();
  }
}

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
  // 处理ConversionService，前面分析ApplicationContext时说过该对象的作用，用于类型转换
  if (this.addConversionService) {
    ConversionService conversionService = ApplicationConversionService.getSharedInstance();
    environment.setConversionService((ConfigurableConversionService) conversionService);
  }
  // 配置属性源：将命令行参数加入属性源
  configurePropertySources(environment, args);
  // 没用
  configureProfiles(environment, args);
}

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

// 不言自明
ApplicationContextFactory DEFAULT = (webApplicationType) -> {
  try {
    switch (webApplicationType) {
      case SERVLET:
        return new AnnotationConfigServletWebServerApplicationContext();
      case REACTIVE:
        return new AnnotationConfigReactiveWebServerApplicationContext();
      default:
        return new AnnotationConfigApplicationContext();
    }
  } catch (Exception ex) {
    ... ...
  }
};

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
                            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
                            ApplicationArguments applicationArguments, Banner printedBanner) {
  // 注入environment
  context.setEnvironment(environment);
  // 注入resourceLoader、classLoader、beanNameGenerator、conversionService
  postProcessApplicationContext(context);
  // 应用所有在构造方法中和set注入的ApplicationContextInitializer
  applyInitializers(context);
  // 广播事件
  listeners.contextPrepared(context);
  // 临时容器工作完成，关闭
  bootstrapContext.close(context);
  // 下面添加一些与SpringBoot相关的一些Bean
  ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
  beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
  if (printedBanner != null) {
    beanFactory.registerSingleton("springBootBanner", printedBanner);
  }
  if (beanFactory instanceof DefaultListableBeanFactory) {
    ((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
  }
  if (this.lazyInitialization) {
    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
  }
  // 获取加载源，即配置类所在源
  Set<Object> sources = getAllSources();
  Assert.notEmpty(sources, "Sources must not be empty");
  // 从源加载Bean定义到容器中
  load(context, sources.toArray(new Object[0]));
  // 广播事件：Bean定义加载完成
  listeners.contextLoaded(context);
}

public class AnnotationAwareOrderComparator extends OrderComparator {

  public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();

  public static void sort(List<?> list) {
    if (list.size() > 1) {
      // 将当前单例当做比较器传入
      list.sort(INSTANCE);
    }
  }

  // 这个在OrderComparator会调用到
  protected Integer findOrder(Object obj) {
    // 调用父类的方法获取order：实现Ordered接口就给出值
    Integer order = super.findOrder(obj);
    if (order != null) {
      return order;
    }
    // 否则从注解中找
    return findOrderFromAnnotation(obj);
  }

  @Nullable
  private Integer findOrderFromAnnotation(Object obj) {
    // 从@Order注解中取得排序值
    AnnotatedElement element = (obj instanceof AnnotatedElement ? (AnnotatedElement) obj : obj.getClass());
    MergedAnnotations annotations = MergedAnnotations.from(element, SearchStrategy.TYPE_HIERARCHY);
    Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
    if (order == null && obj instanceof DecoratingProxy) {
      return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
    }
    return order;
  }

}

public int compare(@Nullable Object o1, @Nullable Object o2) {
  return doCompare(o1, o2);
}

private int doCompare(@Nullable Object o1, @Nullable Object o2) {
  boolean p1 = (o1 instanceof PriorityOrdered);
  boolean p2 = (o2 instanceof PriorityOrdered);
  // PriorityOrdered有短路作用，有实现PriorityOrdered的比没有实现的优先级低
  if (p1 && !p2) {
    return -1;
  } else if (p2 && !p1) {
    return 1;
  }

  // 二者都没有实现PriorityOrdered，则根据Ordered接口或@Order注解来
  int i1 = getOrder(o1);
  int i2 = getOrder(o2);
  return Integer.compare(i1, i2);
}

protected int getOrder(@Nullable Object obj) {
  if (obj != null) {
    Integer order = findOrder(obj);
    if (order != null) {
      return order;
    }
  }
  // 没有实现任何顺序的优先级最低
  return Ordered.LOWEST_PRECEDENCE;
}

protected Integer findOrder(Object obj) {
  return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
}