springboot启动流程（十）springboot自动配置机制
所有文章
https://www.cnblogs.com/lay2017/p/11478237.html
正文
在第七篇文章中我们了解到，refresh过程将会调用ConfigurationClassPostProcessor这个后置处理器，而这个后置处理器将会去调用ConfigurationClassParser这个配置类的解析器，而第一个被解析的配置类就是我们main方法所在的主类（主类是在refresh之前的，prepareRefresh方法加载成为BeanDefinition到BeanFactory中的）。
而后，在第八篇文章中我们主要看了看ConfigurationClassParser是怎么解析配置类的@ComponentScan这个注解的。
那么本文将继续从ConfigurationClassParser这个过程开始，看看parse的处理过程关于自动配置的内容。
自动配置入口
首先，我们回到ConfigurationClassParser的parse方法。
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 (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex); } } // 处理自动配置的入口 this.deferredImportSelectorHandler.process(); }
springboot解析过程将从解析main方法所在的主类开始，所以我们先跟进parse方法
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException { processConfigurationClass(new ConfigurationClass(metadata, beanName)); }
再跟进processConfigurationClass方法
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException { // 判断当前配置类是否应该跳过解析 if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) { return; } // 省略 // 向父类递归解析 SourceClass sourceClass = asSourceClass(configClass); do { // 解析当前配置类的核心逻辑 sourceClass = doProcessConfigurationClass(configClass, sourceClass); } while (sourceClass != null); // }
这里先做了一个判断，是否跳过当前配置类的解析（后面会提及）。而后就是对配置类的递归解析，如果有父类将会递归解析。
跟进doProcessConfigurationClass方法，我们省略其它内容
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException { // // 处理@Import注解 processImports(configClass, sourceClass, getImports(sourceClass), true); // return null; }
我们看到，解析逻辑中包含着一个processImports方法，用于处理@Import注解。我们知道，每一个springboot程序将会注解一个@SpringBootApplication注解，这个注解是一个组合注解，我们看看该注解。
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) public @interface SpringBootApplication { // 省略 }
@SpringBootApplication注解组合了@EnableAutoConfiguration注解，我们再看看@EnableAutoConfiguration注解
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage @Import(AutoConfigurationImportSelector.class) public @interface EnableAutoConfiguration { // 省略 }
可以看到，@Import注解导入了一个AutoConfigurationImportSelector类。
我们再回到doProcessConfigurationClass方法
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException { // // 处理@Import注解 processImports(configClass, sourceClass, getImports(sourceClass), true); // return null; }
processImports之前，会调用getImports方法获取当前配置类的@Import，也包含组合的注解。所以@SpringBootApplication组合的@Import注解导入的配置类AutoConfigurationImportSelector将在这里被获取。
我们跟进getImport方法看看
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException { Set<SourceClass> imports = new LinkedHashSet<>(); Set<SourceClass> visited = new LinkedHashSet<>(); collectImports(sourceClass, imports, visited); return imports; }
再跟进collectImports看看是怎么搜集类的
private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited) throws IOException { if (visited.add(sourceClass)) { // 获取所有注解 for (SourceClass annotation : sourceClass.getAnnotations()) { String annName = annotation.getMetadata().getClassName(); // 非@Import注解的，递归看看有没有组合@Import注解 if (!annName.equals(Import.class.getName())) { collectImports(annotation, imports, visited); } } imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value")); } }
很显然，搜集过程将对所有注解递归处理，这样我们就获得了main方法所在主类的所有@Import导入的类。
再回到doProcessConfigurationClass方法
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException { // // 处理@Import注解 processImports(configClass, sourceClass, getImports(sourceClass), true); // return null; }
跟进processImports方法
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports) { // if (checkForCircularImports && isChainedImportOnStack(configClass)) { // } else { // try { for (SourceClass candidate : importCandidates) { if (candidate.isAssignable(ImportSelector.class)) { Class<?> candidateClass = candidate.loadClass(); ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class); // if (selector instanceof DeferredImportSelector) { this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector); } else { // } } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { // } else { // processConfigurationClass(candidate.asConfigClass(configClass)); } } } // } }
这里遍历了我们getImports方法获取到的类，但是目前我们还只有AutoConfiguratonImportSelector这个类。这个类实现了DeferredImportSelector接口，所以我们继续跟进handle方法
public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) { DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector); if (this.deferredImportSelectors == null) { // } else { // 添加到集合 this.deferredImportSelectors.add(holder); } }
AutoConfigurationImportSelector被包装已经添加到了集合中。那么这个被添加到集合中的类是什么时候被处理的呢？
我们回到本文最开始的代码片段，parse方法
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 (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex); } } // 处理自动配置的入口 this.deferredImportSelectorHandler.process(); }
可以看到，parse方法的最后一行，调用了process方法，将会对这些类进行处理，这也就是自动配置的入口方法了。
处理AutoConfigurationImportSelector
我们跟进process方法，看看处理过程
public void process() { List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors; this.deferredImportSelectors = null; try { if (deferredImports != null) { DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler(); deferredImports.sort(DEFERRED_IMPORT_COMPARATOR); // 遍历导入的类，将这些类注册到handler中 deferredImports.forEach(handler::register); // 处理handler中的导入类 handler.processGroupImports(); } } finally { // } }
这里先将导入类调用handler的register方法进行注册，然后集中处理。我们稍微瞄一眼register方法
public void register(DeferredImportSelectorHolder deferredImport) { Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup(); DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent((group != null ? group : deferredImport), key -> new DeferredImportSelectorGrouping(createGroup(group))); // 添加到group中 grouping.add(deferredImport); this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getConfigurationClass()); }
跟进add方法
private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>(); public void add(DeferredImportSelectorHolder deferredImport) { this.deferredImports.add(deferredImport); }
添加到一个集合中存放起来
我们回到process方法
public void process() { List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors; this.deferredImportSelectors = null; try { if (deferredImports != null) { DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler(); deferredImports.sort(DEFERRED_IMPORT_COMPARATOR); // 遍历导入的类，将这些类注册到handler中 deferredImports.forEach(handler::register); // 处理handler中的导入类 handler.processGroupImports(); } } finally { // } }
register完毕以后，将会processGroupImports，我们跟进processGroupImports方法
public void processGroupImports() { for (DeferredImportSelectorGrouping grouping : this.groupings.values()) { // 获取所有AutoConfigurationImportSelector返回的待处理的配置类，并遍历 grouping.getImports().forEach(entry -> { ConfigurationClass configurationClass = this.configurationClasses.get( entry.getMetadata()); try { // 处理所有配置类 processImports(configurationClass, asSourceClass(configurationClass), asSourceClasses(entry.getImportClassName()), false); } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to process import candidates for configuration class [" + configurationClass.getMetadata().getClassName() + "]", ex); } }); } }
AutoConfigurationImportSelector需要进行自动配置的类将会在这里的getImports方法中返回，而后processImports方法将会处理所有这些需要自动配置的类
我们先跟进getImports方法，看看是怎么获取所有待处理的配置类的
public Iterable<Group.Entry> getImports() { for (DeferredImportSelectorHolder deferredImport : this.deferredImports) { // 处理生成结果 this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector()); } // 返回结果 return this.group.selectImports(); }
我们主要看process方法，进入到AutoConfigurationGroup的process方法
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) { AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector).getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata); this.autoConfigurationEntries.add(autoConfigurationEntry); for (String importClassName : autoConfigurationEntry.getConfigurations()) { this.entries.putIfAbsent(importClassName, annotationMetadata); } }
再跟进getAutoConfigurationEntry
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) { // AnnotationAttributes attributes = getAttributes(annotationMetadata); List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); // // 过滤 configurations = filter(configurations, autoConfigurationMetadata); // return new AutoConfigurationEntry(configurations, exclusions); }
继续跟进getCandidateConfigurations
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()); // return configurations; }
我们看到一个熟悉的方法loadFactoryNames（不熟悉的话，请阅读辅助内容），看看getSpringFactoriesLoaderFactoryClass返回什么
protected Class<?> getSpringFactoriesLoaderFactoryClass() { return EnableAutoConfiguration.class; }
我们可以随机打开一个spring.factories看看EnableAutoConfiguration作为key的配置
可以看到spring.factories中将需要进行自动配置的类作为value配置在这里，所以getCandidateConfigurations方法将会把这些配置类返回。我们再回到getAutoConfigurationEntry方法
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) { // AnnotationAttributes attributes = getAttributes(annotationMetadata); List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); // // 过滤 configurations = filter(configurations, autoConfigurationMetadata); // return new AutoConfigurationEntry(configurations, exclusions); }
获取完configurations后，将会进行一次过滤操作，这样可以避免大量的不需要配置的类被加载。
再回到AutoConfiguration的process方法
private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>(); public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) { AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector).getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata); this.autoConfigurationEntries.add(autoConfigurationEntry); for (String importClassName : autoConfigurationEntry.getConfigurations()) { this.entries.putIfAbsent(importClassName, annotationMetadata); } }
我们调用getAutoConfigurationEntry获得需要自动配置的类，然后再这里会被添加到一个Map集合中存放起来。
到这里，AutoConfigurationImportSelector的getImports方法的process过程就结束了。我们回到getImports方法
public Iterable<Group.Entry> getImports() { for (DeferredImportSelectorHolder deferredImport : this.deferredImports) { // 处理生成结果 this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector()); } // 返回结果 return this.group.selectImports(); }
process方法获取了Imports，而selectImports将返回结果。
到这里，我们的getImports方法就获取了可能需要进行自动配置的类，回到DeferredImportSelectorGroupingHandler类的processGroupImports方法
public void processGroupImports() { for (DeferredImportSelectorGrouping grouping : this.groupings.values()) { // 获取所有AutoConfigurationImportSelector返回的待处理的配置类，并遍历 grouping.getImports().forEach(entry -> { ConfigurationClass configurationClass = this.configurationClasses.get( entry.getMetadata()); try { // 处理所有配置类 processImports(configurationClass, asSourceClass(configurationClass), asSourceClasses(entry.getImportClassName()), false); } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to process import candidates for configuration class [" + configurationClass.getMetadata().getClassName() + "]", ex); } }); } }
跟进processImports
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports) { // if (checkForCircularImports && isChainedImportOnStack(configClass)) { // } else { // try { for (SourceClass candidate : importCandidates) { if (candidate.isAssignable(ImportSelector.class)) { // } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { // } else { // 处理配置类 processConfigurationClass(candidate.asConfigClass(configClass)); } } } // } }
导入的类作为配置类来处理，跟进processConfigurationClass方法
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException { // 是否要进行配置解析 if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) { return; } // SourceClass sourceClass = asSourceClass(configClass); do { // 解析的逻辑 sourceClass = doProcessConfigurationClass(configClass, sourceClass); } while (sourceClass != null); // }
我们久违的processConfigurationClass方法，一开始我们关注的是doProcessConfigurationClass看它解析过程的。现在我们来看看shouldSkip方法，看看是怎么判断当前配置类是否要进行解析的。
跟进shouldSkip方法
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) { // List<Condition> conditions = new ArrayList<>(); // 获取配置类中所有@Conditional以及组合@Conditional的条件 for (String[] conditionClasses : getConditionClasses(metadata)) { for (String conditionClass : conditionClasses) { Condition condition = getCondition(conditionClass, this.context.getClassLoader()); conditions.add(condition); } } // // 遍历这些条件 for (Condition condition : conditions) { ConfigurationPhase requiredPhase = null; if (condition instanceof ConfigurationCondition) { requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase(); } // 判断条件是否不匹配 if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) { return true; } } return false; }
shouldSkip方法，将会拿到当前配置类的所有@Conditional或者组合了@Conditional的注解，并将注解生成Condition条件，再遍历这些条件看是否有不满足条件的将返回true。
总结
springboot的自动配置将从解析main方法所在的主类开始，ConfigurationClassParser在解析@Import的时候会获取到AutoConfigurationImportSelector类。AutoConfigurationImportSelector将会获取到所有可能需要进行自动配置的类，而后每个配置类将被和main方法所在的主类一样准备解析，在解析之前会根据像@Conditional或者组合@Conditional的注解来生成判断条件Condition，根据是否满足Condition来决定是否要进行自动配置。
