springboot启动bean加载处理器ConfigurationClassPostProcessor 三（@Import注解）

处理@Import注解注解的具体方法是，ConfigurationClassPostProcessor 中的processImports

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {

		if (importCandidates.isEmpty()) {
			return;
		}

		if (checkForCircularImports && isChainedImportOnStack(configClass)) {
			this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
		}
		else {
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					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);
						}
						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);
						}
					}
					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();
			}
		}
	}

看代码思路还是比较清晰的，但是里面也隐藏了很多逻辑的。他这里会有三个判断，也就是说@import注解导入的类型有三种

1. 具体的class类（没有实现ImportSelector、ImportBeanDefinitionRegistrar接口）
2. 实现接口 ImportSelector
3. 实现接口 ImportBeanDefinitionRegistrar

先看下一个总体的处理思路流程

这里的①我们已经介绍了springboot启动bean加载处理器ConfigurationClassPostProcessor 一（@ComponentScan注解）、springboot启动bean加载处理器ConfigurationClassPostProcessor 二（@PropertySource注解），进入这两个注解处理的类都会生成bean定义并加载到spring容器中，@import不同，它在经过processImports处理后都没有及时的加载到容器中。
我们看下对@import注解处理的具体逻辑：

• 具体的class类，当做类似@Configuration注解处理
• 实现接口 ImportSelector，如果是DeferredImportSelector类型加入到DeferredImportSelectorHandler；否则会递归执行processImports方法–》加入到configurationClasses 中
• 实现接口 ImportBeanDefinitionRegistrar，在当前类信息中加入

在parse方法执行后，都会把当前的类加入到configurationClasses 中，@import方法就是在parse执行完后loadBeanDefinitions方法进行处理（ImportSelector中如果是DeferredImportSelector类型会在parse方法后有个专门的DeferredImportSelectorHandler进行先处理），这时候才会加载bean容器中。

其它都好理解，我们来看下DeferredImportSelector类型的处理流程，首先要看下DeferredImportSelectorHandler处理器的实现逻辑，它是个内部类，包含两个方法handle、process，两个方法到具体执行流程都是一样的，会执行processGroupImports，主要判断是deferredImportSelectors ==null

private class DeferredImportSelectorHandler {

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

		/**
		 * Handle the specified {@link DeferredImportSelector}. If deferred import
		 * selectors are being collected, this registers this instance to the list. If
		 * they are being processed, the {@link DeferredImportSelector} is also processed
		 * immediately according to its {@link DeferredImportSelector.Group}.
		 * @param configClass the source configuration class
		 * @param importSelector the selector to handle
		 */
		public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
			DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
			if (this.deferredImportSelectors == null) {
				DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
				handler.register(holder);
				handler.processGroupImports();
			}
			else {
				this.deferredImportSelectors.add(holder);
			}
		}

		public void process() {
			List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
			this.deferredImportSelectors = null;
			try {
				if (deferredImports != null) {
					DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
					deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
					deferredImports.forEach(handler::register);
					handler.processGroupImports();
				}
			}
			finally {
				this.deferredImportSelectors = new ArrayList<>();
			}
		}
	}

结合解析@import过程，会递归的执行processImports直到最后导入的类是普通的类结束。