书接上文中最重要的两个方法，我们先看第一个，debug进入
public void parse(Set<beandefinitionholder> configCandidates) {
// 传入的带解析的配置类是一个集合，但是我们本次debug是springboot第一次启动，此时这个结合只有启动类这一个配置类
for (BeanDefinitionHolder holder : configCandidates) {
// 获取 BeanDefinition
BeanDefinition bd = holder.getBeanDefinition();
try {
// 根据不同的BeanDefinition进入不同的解析分支，
// 其实就是调用了不同的重载解析方法，最终进入后面进入了同一方法，所以我们只需要看这一次的debug的这个方法即可，下面的两个分支就不用看了
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);
}
}
// 延迟导入选择器持有者开始执行，该步骤和自动装配逻辑有关，请看标题1.2
// 这里提前说一下，配置类中@import中要导入的类如果实现了DeferredImportSelector接口，就会存在deferredImportSelectorHandler属性
// 在类解析完成后会调用deferredImportSelectorHandler属性的process方法，开始执行导入
this.deferredImportSelectorHandler.process();
}
</beandefinitionholder>
继续debug
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
// 前面说的三个解析重载方法，最终都会调用这一个方法
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<string> filter) throws IOException {
// 判断这个配置类上面有没有 @Condition 注解，如果有判断是否成立，不成立不需要解析
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
// 从已经解析过的类集合中获取这个类
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
// 如果已经存在了
if (existingClass != null) {
// 则判断这个类是不是从其他类里面导入的
if (configClass.isImported()) {
// 判断已经存在的类是不是从其他类里导入的
if (existingClass.isImported()) {
// 如果成立则将导入类合并
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
// 如果这个类不是从其他类导入，则从配置类中删除
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
// 将配置类对象ConfigurationClass，包装成 源类
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
// 开始执行真正的解析
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
// 将解析过的配置类加入配置类集合，后面转换为BeanDefinition
this.configurationClasses.put(configClass, configClass);
}
</string>
千呼万唤始出来，到了真正解析的地方，在继续之前我们有必要先了解一下 ConfigurationClass这个类，后续解析出啦的信息都会存到这个类中
// 被final修饰，不可继承
final class ConfigurationClass {
// 报错了配置类的注解元数据信息
private final AnnotationMetadata metadata;
// 配置类资源
private final Resource resource;
// 配置类名称
private String beanName;
// 配置类是通过那个类导入的
private final Set<configurationclass> importedBy = new LinkedHashSet<>(1);
// 配置类所有的被@bean注解的方法，包括他的接口和父类中被@bean标注的方法
private final Set<beanmethod> beanMethods = new LinkedHashSet<>();
// 配置类中@ImportResource注解标注的资源
private final Map<string, class<? extends beandefinitionreader>> importedResources = new LinkedHashMap<>();
// 配置类中@import中的类，并且这个类实现了ImportBeanDefinitionRegistrar接口
private final Map<importbeandefinitionregistrar, annotationmetadata> importBeanDefinitionRegistrars = new LinkedHashMap<>();
// 配置类中@bean注解标注的方法，上面还有@Condition注解，但是不满足条件，要跳过解析的方法为
final Set<string> skippedBeanMethods = new HashSet<>();
// 省略所有的方法
}
</string></importbeandefinitionregistrar,></string,></beanmethod></configurationclass>
熟悉了这个类之后我们现在开始debug，我们先看一下整体的解析流程
上面8步中，都是Spring中的逻辑，我们都不看了，本次主要是看自动装配，我们只需要看第4步即可
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<string> filter)
throws IOException {
// 第一步，首先判断传入的配置类有没有@Component注解，如果有，则需要检查配置类中有没有内部类，并且这个内部类是不是配置类
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass, filter);
}
// 第二步，获取配置类上面的@PropertySource注解和@PropertySources注解，进行解析
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 第三步，获取配置类上面的@ComponentScan注解进行解析
Set<annotationattributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<beandefinitionholder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// 第四步，解析配置类上面的@Import注解，自动装配逻辑有关，也是我们后面重点关注的，请看标题1.1
// 关于getImports方法，一个注解可能是被多个注解标注，就像我们这次要看的@SpringBootApplication，它里面有 @SpringBootConfiguration 和 @EnableAutoConfiguration 两个注解
// 而这两个注解里面又都被 @Import注解标注，所以在解析@Import注解前，要先找到所有的@Import注解，这里使用的是递归的方式，而且每个@Import注解可以导入多个类，我们就不看这个方法了，只需要知道我们再debug时，
// 第一次解析的配置类就是 springboot 的启动类，而启动类上的@SpringBootApplication最终会解析出来两个 @Import 导入的类
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 第五步，获取配置类上面的@ImportResource注解进行解析
AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 第六步，获取配置类里面标志@Bean注解的方法进行解析
Set<methodmetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 第七步，判断配置类是否有实现接口，如果有检查接口中的方法是否有@bean注解，如果有进行解析
processInterfaces(configClass, sourceClass);
// 第八步，判断配置类是否有父类，如果有，获取父类返回，在进行一次解析
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// 没有父类，则解析完成
return null;
}
</methodmetadata></beandefinitionholder></annotationattributes></string>
1.1、 processImports 解析
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<sourceclass> importCandidates, Predicate<string> exclusionFilter,
boolean checkForCircularImports) {
// 判断是否有要导入的类
if (importCandidates.isEmpty()) {
return;
}
// checkForCircularImports传入就是true,isChainedImportOnStack方法执行结果也是true
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
this.importStack.push(configClass);
try {
// 遍历要导入的类
for (SourceClass candidate : importCandidates) {
// 如果这个类实现了ImportSelector这个接口
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
// 将这个类实例化
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
Predicate<string> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
// 判断这个类是否实现了DeferredImportSelector接口，如果实现了就加入deferredImportSelectorHandler处理器，这一步和自动装配有关，所以整个流程中只有这一步是我们关注的重点
// 我们所熟知的@SpringBootApplication 中就有一个@AutoConfigurationPackage注解，
// 而整个@AutoConfigurationPackage注解中就有 @Import注解，他导入的类AutoConfigurationImportSelector，就实现了这个接口
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
else {
// 否则就再次进行一次要导入类的解析，不过
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<sourceclass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
// 如果这个类实现了ImportBeanDefinitionRegistrar这个接口，就将这个类实例化，然后存入当前正在解析的配置类
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
// 如果这个要导入的类上面两个接口都没实现，则就对这个类进行解析，可能这个类是一个配置类
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
}
finally {
this.importStack.pop();
}
}
}
</sourceclass></string></string></sourceclass>
debug进入 deferredImportSelectorHandler的 handle方法
在我们开篇第一个方法，parse方法，最后面就发现，在配置类解析完成后，有 deferredImportSelectorHandler方法的回调
public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
// 将要导入的类，包装成 DeferredImportSelectorHolder类型，然后将它加入到deferredImportSelectors集合中，在上面我们就发现，配置类
DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
// deferredImportSelectors 这里是true，deferredImportSelectorHandler在创建的时候就会初始化deferredImportSelectors属性，
// deferredImportSelectors是一个集合，里面存储DeferredImportSelectorHolder类型
if (this.deferredImportSelectors == null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
handler.register(holder);
handler.processGroupImports();
}
else {
this.deferredImportSelectors.add(holder);
}
}
1.2、deferredImportSelectorHandler.process 执行解析
public void process() {
// 获取之前配置类解析过程中所有@Import注解导入的实现DeferredImportSelector接口的类的持有者类，注意：是类的持有者类
List<deferredimportselectorholder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
// 创建一个DeferredImportSelectorGroupingHandler对象
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
// 将deferredImports集合里面的要导入的类排序
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
// 将要导入的类遍历添加到DeferredImportSelectorGroupingHandler对象中，见标题1.2.1
deferredImports.forEach(handler::register);
// DeferredImportSelectorGroupingHandler 开始执行导入，见表格1.2.2
handler.processGroupImports();
}
}
finally {
// 在导入类解析完成后，将deferredImportSelectors重置，清空
this.deferredImportSelectors = new ArrayList<>();
}
}
</deferredimportselectorholder>
在这之前，我们先讲解一下 DeferredImportSelector这个接口，他的大概结构是这个下面这样(删除了注释以及一些不重要方法)， DeferredImportSelector这个接口中还有一个 Group接口， Group接口中还存在一个内部类 Entry
而我们后面要讲的和自动装配相关的，@Import导入的 AutoConfigurationImportSelector类，实现了这个 DeferredImportSelector接口，
AutoConfigurationImportSelector类的内部类 AutoConfigurationGroup也实现了 DeferredImportSelector接口中的 Group接口，另外一个内部类是 AutoConfigurationEntry
AutoConfigurationImportSelector类中的 getImportGroup方法返回的就是他的内部类 AutoConfigurationGroup
内部类 AutoConfigurationGroup有两个方法
process方法，用来执行 AutoConfigurationImportSelector，从spring.factory中获取所有的要自动装配的类，然后封装到内部类 AutoConfigurationEntry中
selectImports方法，就是将 process方法解析出来的 AutoConfigurationEntry对象中的要自动装配的类逐个转换为 Entry类型，然后返回
Entry中有两个属性，其中一个 importClassName就是要导入的配置的全类名，会对这个类进行上文中相同的配置类解析过程
public interface DeferredImportSelector extends ImportSelector {
default Class<? extends Group> getImportGroup() {
return null;
}
interface Group {
void process(AnnotationMetadata metadata, DeferredImportSelector selector);
Iterable<entry> selectImports();
class Entry {
private final AnnotationMetadata metadata;
private final String importClassName;
public Entry(AnnotationMetadata metadata, String importClassName) {
this.metadata = metadata;
this.importClassName = importClassName;
}
public AnnotationMetadata getMetadata() {return this.metadata;}
public String getImportClassName() {return this.importClassName;}
}
}
}
</entry>
debug进入注册方法
public void register(DeferredImportSelectorHolder deferredImport) {
// 获取DeferredImportSelectorHolder中的AutoConfigurationImportSelector的AutoConfigurationGroup
Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup();
// 然后将AutoConfigurationGroup包装成DeferredImportSelectorGrouping
// 再以DeferredImportSelectorHolder或者AutoConfigurationGroup为key,以DeferredImportSelectorGrouping为值存入groupings集合，返回的就是DeferredImportSelectorGrouping
DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
(group != null ? group : deferredImport),
key -> new DeferredImportSelectorGrouping(createGroup(group)));
// 在把DeferredImportSelectorHolder加入DeferredImportSelectorGrouping
grouping.add(deferredImport);
this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getConfigurationClass());
}
public void processGroupImports() {
// 获取到之前所有的grouping，遍历执行
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
Predicate<string> exclusionFilter = grouping.getCandidateFilter();
// foreach 里面的逻辑就是我们前面的配置类解析过程，我们就不再看了，最终会把解析出来的配置类全部存入ConfigurationClassParser类中的configurationClasses集合中
// 我们主要看getImports()这个方法
grouping.getImports().forEach(entry -> {
ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
try {
processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
exclusionFilter, false);
}
// 省略部分无影响逻辑
});
}
}
</string>
debug进入getImports这个方法
public Iterable<group.entry> getImports() {
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
// 执行，获取到所有配置到spring.factory的配置类，见标题1.2.2.1
this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector());
}
// 将上面获取到的所有配置类进行配置类解析为Entry，见标题1.2.2.2
return this.group.selectImports();
}
</group.entry>
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
// 省略部分无影响逻辑
// 这一步里获取到所有的spring.factory配置的自动装配类，然后包装到AutoConfigurationEntry中，核销逻辑一会debug要看
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 获取到所有的配置类集合
List<string> configurations = getCandidateConfigurations(annotationMetadata, attributes);
// 删除重复的集合
configurations = removeDuplicates(configurations);
// 获取要排除的配置类
Set<string> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
// 删除要排除的配置类
configurations.removeAll(exclusions);
// 过滤掉不符合自动装配条件的过滤器，其实就获取到spring.factory配置的实现AutoConfigurationImportFilter接口的类，主要有OnBeanCondition，OnClassCondition，OnWebApplicationCondition这三个
configurations = getConfigurationClassFilter().filter(configurations);
// 发送自动装配时间
fireAutoConfigurationImportEvents(configurations, exclusions);
// 将配置类集合包装到AutoConfigurationEntry对象中
return new AutoConfigurationEntry(configurations, exclusions);
}
</string></string>
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());
Set<string> processedConfigurations = this.autoConfigurationEntries.stream()
.map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
.collect(Collectors.toCollection(LinkedHashSet::new));
processedConfigurations.removeAll(allExclusions);
return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
.map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
.collect(Collectors.toList());
}
</string></string></entry>
debug进入，这里面传入了所有解析出来的配置类
public void loadBeanDefinitions(Set<configurationclass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
// 遍历配置类进行解析
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
</configurationclass>
看一下整体的解析流程，每一个解析过程就不看了，这里面的流程其实是Spring的流程
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// 判断配置类是否由其他配置类导入的，而不是@Import注解导入的
if (configClass.isImported()) {
// 将这个配置类本身解析成一个beanDefinition
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 判断这个配置类是不是有@Bean注解的方法，如果有，则将@Bean注解返回的结果解析成一个BeanDefinition
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 获取这个配置类中@ImportResources或者@ImportResource导入的类，这些类解析成一个BeanDefinition
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 将前面@Import注解导入的实现了ImportBeanDefinitionRegistrar的接口的类解析成一个BeanDefinition
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
至此，整个Springboot的自动装配流程解析完成，下一节对整个流程做一个总结
Original: https://www.cnblogs.com/junzisi/p/15553604.html
Author: 君子思
Title: 10、SpringBoot 启动 刷新应用上下文 自动装配解析(二)
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/607565/
转载文章受原作者版权保护。转载请注明原作者出处！