关联博文：
SpringBoot自动配置原理解析（一）
SpringBoot自动配置原理解析（二）
SpringBoot自动配置原理解析（三）
SpringBoot自动配置原理解析（四）
SpringBoot自动配置原理解析（五）
接上文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进行判断循环处理。
扫一扫
923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
