springboot 服务智能上下线 springboot上下文

一、解析带解析的配置类

书接上文中最重要的两个方法，我们先看第一个，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();
	}

继续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);
	}

千呼万唤始出来，到了真正解析的地方，在继续之前我们有必要先了解一下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<>();

        // 省略所有的方法
}

熟悉了这个类之后我们现在开始debug，我们先看一下整体的解析流程

1. 如果被解析配置类有@Component注解，则解析其内部类
2. @PropertySource注解和@PropertySources注解解析
3. @ComponentScan注解解析
4. @Import注解解析
5. @ImportResource注解解析
6. @Bean注解解析
7. 接口中@Bean注解解析
8. 如果有父类，父类再次经过上述步骤循环

上面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;
	}

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();
			}
		}
	}

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<>();
			}
		}

1.2.1、将要导入的类遍历添加到DeferredImportSelectorGroupingHandler对象中

在这之前，我们先讲解一下DeferredImportSelector这个接口，他的大概结构是这个下面这样(删除了注释以及一些不重要方法)，DeferredImportSelector这个接口中还有一个Group接口，Group接口中还存在一个内部类Entry

而我们后面要讲的和自动装配相关的，@Import导入的AutoConfigurationImportSelector类，实现了这个DeferredImportSelector接口，
AutoConfigurationImportSelector类的内部类AutoConfigurationGroup也实现了DeferredImportSelector接口中的Group接口，另外一个内部类是AutoConfigurationEntryAutoConfigurationImportSelector类中的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;}
		}
	}
}

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());
		}

1.2.2、DeferredImportSelectorGroupingHandler 开始执行导入

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);
					}
                                        // 省略部分无影响逻辑
				});
			}
		}

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();
		}

1.2.2.1、加载获取所有的配置类

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);
	}

1.2.2.2、将所有的配置类解析为Entry

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());
		}

二、将解析出的类转为BeanDefinition

debug进入，这里面传入了所有解析出来的配置类

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
                        // 遍历配置类进行解析
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

看一下整体的解析流程，每一个解析过程就不看了，这里面的流程其实是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的自动装配流程解析完成，下一节对整个流程做一个总结