@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		// 會在所有@Configuration都解析完了之后才執(zhí)行
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		// 獲取自動配置類（spring.factories中所導(dǎo)入的）
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		// 獲取@EnableAutoConfiguration的屬性
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 獲取spring.factories中所有的AutoConfiguration
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		// 去重（也就是按類名去重）
		configurations = removeDuplicates(configurations);
		// 獲取需要排除的AutoConfiguration，可以通過@EnableAutoConfiguration注解的exclude屬性，或者spring.autoconfigure.exclude來配置
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		// 排除
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		// 獲取spring.factories中的AutoConfigurationImportFilter對AutoConfiguration進行過濾
		// 默認會拿到OnBeanCondition、OnClassCondition、OnWebApplicationCondition
		// 這三個會去判斷上面的AutoConfiguration是否符合它們自身所要求的條件，不符合的會過濾掉，表示不會進行解析了
		// 會利用spring-autoconfigure-metadata.properties中的配置來進行過濾
		// spring-autoconfigure-metadata.properties文件中的內(nèi)容是利用Java中的AbstractProcessor技術(shù)在編譯時生成出來的
		configurations = getConfigurationClassFilter().filter(configurations);
		// configurations表示合格的，exclusions表示被排除的，把它們記錄在ConditionEvaluationReportAutoConfigurationImportListener中
		fireAutoConfigurationImportEvents(configurations, exclusions);

		// 最后返回的AutoConfiguration都是符合條件的
		return new AutoConfigurationEntry(configurations, exclusions);
	}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		//核心方法 傳入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;
	}
//返回EnableAutoConfiguration
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			//獲取類加載器
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
		//這個name就是EnableAutoConfiguration
		String factoryTypeName = factoryType.getName();
		//這部分代碼具體的去加載自動配置類
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

protected final <T> List<T> removeDuplicates(List<T> list) {
		return new ArrayList<>(new LinkedHashSet<>(list));
	}

protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		Set<String> excluded = new LinkedHashSet<>();
		//獲取EnableAutoConfiguration注解的exclude屬性的值 添加到排除集合當(dāng)中
		excluded.addAll(asList(attributes, "exclude"));
		//獲取EnableAutoConfiguration注解的excludeName屬性的值 添加到排除集合當(dāng)中
		excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
		//從配置文件中獲取spring.autoconfigure.exclude 的值 添加到排除集合中
		excluded.addAll(getExcludeAutoConfigurationsProperty());
		return excluded;
	}

private ConfigurationClassFilter getConfigurationClassFilter() {
		if (this.configurationClassFilter == null) {
			//獲取自動配置類的過濾器
			List<AutoConfigurationImportFilter> filters = getAutoConfigurationImportFilters();
			for (AutoConfigurationImportFilter filter : filters) {
				invokeAwareMethods(filter);
			}
			//將所有過濾器封裝成 ConfigurationClassFilter
			this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);
		}
		return this.configurationClassFilter;
	}
protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
		//底層從 META-INF/spring.factories中加載 AutoConfigurationImportFilter的值
		return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);
	}

List<String> filter(List<String> configurations) {
			long startTime = System.nanoTime();
			//把自動配置類的名稱封裝成數(shù)組
			String[] candidates = StringUtils.toStringArray(configurations);
			boolean skipped = false;
			// 逐個利用AutoConfigurationImportFilter來判斷所有的自動配置類的條件是否匹配，匹配結(jié)果存在match數(shù)組中
			// 先利用OnBeanCondition進行過濾
			// 再利用OnClassCondition進行過濾
			// 再利用OnWebApplicationCondition進行過濾
			for (AutoConfigurationImportFilter filter : this.filters) {
				//把過濾的結(jié)果 放入到boolean的數(shù)組中
				boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
				for (int i = 0; i < match.length; i++) {
					if (!match[i]) {
						//如果匹配失敗 排除掉該自動配置類
						candidates[i] = null;
						skipped = true;
					}
				}
			}
			// 全部都匹配
			if (!skipped) {
				return configurations;
			}
			// 把匹配的記錄在result集合中，最后返回
			List<String> result = new ArrayList<>(candidates.length);
			for (String candidate : candidates) {
				if (candidate != null) {
					result.add(candidate);
				}
			}
			if (logger.isTraceEnabled()) {
				int numberFiltered = configurations.size() - result.size();
				logger.trace("Filtered " + numberFiltered + " auto configuration class in "
						+ TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
			}
			return result;
		}
	}

AutoConfigurationEntry(Collection<String> configurations, Collection<String> exclusions) {
			this.configurations = new ArrayList<>(configurations);
			this.exclusions = new HashSet<>(exclusions);
		}
		public List<String> getConfigurations() {
			return this.configurations;
		}
		public Set<String> getExclusions() {
			return this.exclusions;
		}