SpringBoot自动配置原理解析（三）-阿里云开发者社区

关联博文：

如下是ConfigurationClassParser的parse方法，当内部parse方法执行完后，就该执行this.deferredImportSelectorHandler.process();方法。这个时候我们的@Bean方法还只是configClass中的BeanMethod，还没有被注册为BeanDefinition。

public void parse(Set<BeanDefinitionHolder> configCandidates) {
  for (BeanDefinitionHolder holder : configCandidates) {
    BeanDefinition bd = holder.getBeanDefinition();
    try {
      if (bd instanceof AnnotatedBeanDefinition) {
        parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
      }
      else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
        parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
      }
      else {
        parse(bd.getBeanClassName(), holder.getBeanName());
      }
    }
    //...两个catch
  }
  this.deferredImportSelectorHandler.process();
}

我们来看看deferredImportSelectorHandler的process方法。

【1】DeferredImportSelectorHandler

DeferredImportSelectorHandler是ConfigurationClassParser的内部类，维护了一个成员deferredImportSelectors 存储DeferredImportSelectorHolder。

private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();

在前文我们看到了，我们AutoConfigurationImportSelector被实例化为DeferredImportSelectorHolder放到了deferredImportSelectors 中。

前面我们触发的是其handle方法，这里我们看下其process方法。

public void process() {
// 做一下置换，将deferredImportSelectors 赋予null
  List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
  this.deferredImportSelectors = null;
  try {
    if (deferredImports != null) {
    //实例化DeferredImportSelectorGroupingHandler 
      DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
      // 排序
      deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
      //对每一个DeferredImportSelectorHolder触发
      //DeferredImportSelectorGroupingHandler 的register方法
      deferredImports.forEach(handler::register);
      // 这里是核心
      handler.processGroupImports();
    }
  }
  finally {
    this.deferredImportSelectors = new ArrayList<>();
  }
}

这里有两个方法需要我们注意，分别是register和processGroupImports。我们首先看一下deferredImports.forEach(handler::register);。

① register

这里核心就是对List<DeferredImportSelectorHolder> deferredImports进行分组放到groupings中，并将所属configClass放到configurationClasses中。

// ConfigurationClassParser.DeferredImportSelectorGroupingHandler#register
public void register(DeferredImportSelectorHolder deferredImport) {
// 本文这里获取的group是AutoConfigurationImportSelector$AutoConfigurationGroup
  Class<? extends Group> group = deferredImport.getImportSelector()
      .getImportGroup();
//放入groupings并将value返回
  DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
      (group != null ? group : deferredImport),
      key -> new DeferredImportSelectorGrouping(createGroup(group)));
  grouping.add(deferredImport);
//放入configurationClasses中
  this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
      deferredImport.getConfigurationClass());
}

方法如上所示，首先得到ImportSelector的ImportGroup，本文这里得到的是AutoConfigurationImportSelector$AutoConfigurationGroup。

然后根据group 得到grouping ，将当前DeferredImportSelectorHolder deferredImport放到grouping 中。本文这里的deferredImport如下所示，其包含了所属configClass和引入的AutoConfigurationImportSelector。

当前this中groupings如下所示：

当前this中configurationClasses如下所示：

注意，这里的this指的是DeferredImportSelectorGroupingHandler。如下所示，DeferredImportSelectorGroupingHandler维护了两个Map。

private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();
private final Map<AnnotationMetadata, ConfigurationClass> configurationClasses = new HashMap<>();

② processGroupImports

register方法可以跳过，但是这个processGroupImports方法是核心。我们继续看DeferredImportSelectorGroupingHandler的processGroupImports方法。首先遍历触发每个grouping的getImports方法然后遍历触发processImports方法。当然本文这里我们只有一个分组就是AutoConfigurationGroup。

public void processGroupImports() {
  for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
  //本文我们得到的候选配置有45个
    grouping.getImports().forEach(entry -> {
      ConfigurationClass configurationClass = this.configurationClasses.get(
          entry.getMetadata());
      try {
      // 这里先说一下，执行完这个方法后候选配置有244个
      // 我们从spring.factories得到的配置类在这个processImports中被处理
        processImports(configurationClass, asSourceClass(configurationClass),
            asSourceClasses(entry.getImportClassName()), false);
      }
      //...一堆catch
    });
  }
}

entry里面存放的是什么呢？如下图所示：

processImports方法就是前文我们分析过的那个processImports方法。这里我们可以简单说一下，当我们获取到那些配置类比如MessageSourceAutoConfiguration时，这里会触发下面这行代码。

processImports(configurationClass, asSourceClass(configurationClass),
            asSourceClasses(entry.getImportClassName()), false);

唯一需要注意的是asSourceClasses(entry.getImportClassName())其实也就是说我们的XXXXAutoConfiguration会被作为候选导入类Collection<SourceClass> importCandidates扔给processImports方法。前文我们提到过importCandidates是可以被作为配置类触发解析过程的，也是可以在reader.loadBeanDefinitions过程中被注册为BeanDefinition的。有同学可能好奇，configurationClass是什么？如下图所示这里是我们的主启动类。

ok，接下来我们看一下getImports方法。这里触发的是DeferredImportSelectorGrouping 的getImports方法。

【2】DeferredImportSelectorGrouping

DeferredImportSelectorGrouping 如下所示，内部维护了group和与group相关的List<DeferredImportSelectorHolder> deferredImports。

private static class DeferredImportSelectorGrouping {
//维护了group
  private final DeferredImportSelector.Group group;
//维护了集合deferredImports 
  private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>();
  DeferredImportSelectorGrouping(Group group) {
    this.group = group;
  }
//提供了add方法
  public void add(DeferredImportSelectorHolder deferredImport) {
    this.deferredImports.add(deferredImport);
  }
  /**
   * Return the imports defined by the group.
   * @return each import with its associated configuration class
   */
   // 对deferredImports进行遍历，对group触发其process方法
  public Iterable<Group.Entry> getImports() {
    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
      this.group.process(deferredImport.getConfigurationClass().getMetadata(),
          deferredImport.getImportSelector());
    }
    // 触发group的selectImports方法
    return this.group.selectImports();
  }
}

前面我们提到了，这里group就是我们的AutoConfigurationGroup。下面我们分析process()和selectImports()方法。

① process

这里触发的是AutoConfigurationGroup的process方法。

// .AutoConfigurationImportSelector.AutoConfigurationGroup#process
@Override
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
  //...省略一个Assert.state,下面这句话是核心
  AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
      .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
//将得到autoConfigurationEntry放入ArrayList autoConfigurationEntries中
  this.autoConfigurationEntries.add(autoConfigurationEntry);
//遍历放入Map<String, AnnotationMetadata> entries = new LinkedHashMap<>()
  for (String importClassName : autoConfigurationEntry.getConfigurations()) {
    this.entries.putIfAbsent(importClassName, annotationMetadata);
  }
}

getAutoConfigurationMetadata()

首先触发getAutoConfigurationMetadata()方法，用来获取AutoConfigurationMetadata 。

AutoConfigurationImportSelector.AutoConfigurationGroup的getAutoConfigurationMetadata方法会实例化得到一个AutoConfigurationMetadata autoConfigurationMetadata。

其将会搜索并加载META-INF/spring-autoconfigure-metadata.properties配置信息得到其Properties然后根据Properties实例化得到PropertiesAutoConfigurationMetadata对象。

(1.2)核心方法getAutoConfigurationEntry

//// AutoConfigurationImportSelector#getAutoConfigurationEntry
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
    AnnotationMetadata annotationMetadata) {
// 如果环境配置了spring.boot.enableautoconfiguration为false，则直接返回
  if (!isEnabled(annotationMetadata)) {
    return EMPTY_ENTRY;
  }
  // 得到注解的属性
  AnnotationAttributes attributes = getAttributes(annotationMetadata);
  //获取候选配置类
  List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
  //移除重复的
  configurations = removeDuplicates(configurations);
  //获取配置的排除信息并从configurations移除排除的
  Set<String> exclusions = getExclusions(annotationMetadata, attributes);
  checkExcludedClasses(configurations, exclusions);
  configurations.removeAll(exclusions);
  //过滤configurations
  configurations = filter(configurations, autoConfigurationMetadata);
  // 触发AutoConfigurationImportListener监听的onAutoConfigurationImportEvent方法
  //可以简单理解为AutoConfigurationImportEvent事件被相应的监听器处理
  fireAutoConfigurationImportEvents(configurations, exclusions);
  //返回AutoConfigurationEntry
  return new AutoConfigurationEntry(configurations, exclusions);
}

方法流程梳理如下

如果环境配置了spring.boot.enableautoconfiguration为false，则直接返回

得到注解的属性

获取候选配置类–核心方法

移除重复的

获取配置的排除信息并从configurations移除排除的

过滤configurations

触发AutoConfigurationImportListener监听的onAutoConfigurationImportEvent方法，可以简单理解为AutoConfigurationImportEvent事件被相应的监听器处理

返回AutoConfigurationEntry

那么如何得到候选配置类？我们继续追踪getCandidateConfigurations(annotationMetadata, attributes);这个方法。

这里来到了AutoConfigurationImportSelector的getCandidateConfigurations，很明了，从META-INF/spring.factories检索EnableAutoConfiguration配置信息！！

// AutoConfigurationImportSelector#getCandidateConfigurations
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 从META-INF/spring.factories检索EnableAutoConfiguration配置信息
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
      getBeanClassLoader());
  Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
      + "are using a custom packaging, make sure that file is correct.");
  return configurations;
}
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
  return EnableAutoConfiguration.class;
}

这里得到的configurations如下所示，有130个：

如何过滤configurations呢？这里会从环境中检索AutoConfigurationImportFilter使用得到的Filter进行过滤。

protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
  return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);
}
// META-INF/spring.factories配置的AutoConfigurationImportFilter如下
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

如下所示，过滤完这里本文这里还剩下45个：

OK，我们继续回到DeferredImportSelectorGrouping 的getImports方法，接下来分析selectImports方法。

② selectImports

AutoConfigurationImportSelector.AutoConfigurationGroup的selectImports方法。就是对autoConfigurationEntries维护的配置类进行了整体筛选然后排序然后映射得到一个List。

public Iterable<Entry> selectImports() {
  if (this.autoConfigurationEntries.isEmpty()) {
    return Collections.emptyList();
  }
  // 获取到所有的排他配置
  Set<String> allExclusions = this.autoConfigurationEntries.stream()
      .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
// 获取到autoConfigurationEntries中所有配置类
  Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
      .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
      .collect(Collectors.toCollection(LinkedHashSet::new));
// 从中移除排他配置
  processedConfigurations.removeAll(allExclusions);
//排序 然后映射得到Entry这样一个List
  return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
      .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
      .collect(Collectors.toList());
}

当执行完所有的候选配置类后，也就是对我们从META-INF\spring.factories加载并过滤后的配置类执行完processImports方法后，来到了this.deferredImportSelectors = new ArrayList<>();，这时我们解析器里面的候选配置类有244个了！

得到一个entry 的集合后就开始遍历对每一个entry 触发processImports方法。

grouping.getImports().forEach(entry -> {
  ConfigurationClass configurationClass = this.configurationClasses.get(
      entry.getMetadata());
  try {
  // 这里先说一下，执行完这个方法后候选配置有244个
  // 我们从spring.factories得到的配置类在这个processImports中被处理
    processImports(configurationClass, asSourceClass(configurationClass),
        asSourceClasses(entry.getImportClassName()), false);
}

接下来就该ConfigurationClassBeanDefinitionReader使用加载BeanDefinition了，然后将registry.getBeanDefinitionCount() > candidateNames.length进行判断循环处理。

SpringBoot自动配置原理解析（三）

【1】DeferredImportSelectorHandler

① register

② processGroupImports

【2】DeferredImportSelectorGrouping

① process

(1.2)核心方法getAutoConfigurationEntry

② selectImports

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像