@FunctionalInterface
public interface AutoConfigurationImportFilter {
	/**
	 * Apply the filter to the given auto-configuration class candidates.
	 * @param autoConfigurationClasses the auto-configuration classes being considered.
	 * This array may contain {@code null} elements. Implementations should not change the
	 * values in this array.
	 * @param autoConfigurationMetadata access to the meta-data generated by the
	 * auto-configure annotation processor
	 * @return a boolean array indicating which of the auto-configuration classes should
	 * be imported. The returned array must be the same size as the incoming
	 * {@code autoConfigurationClasses} parameter. Entries containing {@code false} will
	 * not be imported.
	 */
	boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata);
}

abstract class FilteringSpringBootCondition extends SpringBootCondition
		implements AutoConfigurationImportFilter, BeanFactoryAware, BeanClassLoaderAware {
	// bean 工廠
	private BeanFactory beanFactory;
	// bean 加載器
	private ClassLoader beanClassLoader;
    // 
	@Override
	public boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {
		// 獲取條件化判斷報告， 用于記錄處理結果
		ConditionEvaluationReport report = ConditionEvaluationReport.find(this.beanFactory);
		// 獲取具體匹配處理結果， 由抽象方法getOutcomes負責具體實現(xiàn)
		ConditionOutcome[] outcomes = getOutcomes(autoConfigurationClasses, autoConfigurationMetadata);
		boolean[] match = new boolean[outcomes.length];
		// 遍歷條件處理結果
		for (int i = 0; i < outcomes.length; i++) {
			match[i] = (outcomes[i] == null || outcomes[i].isMatch());
			if (!match[i] && outcomes[i] != null) {
				// 日志打印記錄
				logOutcome(autoConfigurationClasses[i], outcomes[i]);
				if (report != null) {
					// 記錄匹配處理結果
					report.recordConditionEvaluation(autoConfigurationClasses[i], this, outcomes[i]);
				}
			}
		}
		return match;
	}
	...
}

protected List<String> filter(Collection<String> classNames, ClassNameFilter classNameFilter,
			ClassLoader classLoader) {
    	// 校驗， 為空判斷
		if (CollectionUtils.isEmpty(classNames)) {
			return Collections.emptyList();
		}
        // 記錄match匹配結果
		List<String> matches = new ArrayList<>(classNames.size());
        // 遍歷處理
		for (String candidate : classNames) {
            // 從指定的classLoader中加載class，再根據(jù)ClassNameFilter類型， 返回最終結果
			if (classNameFilter.matches(candidate, classLoader)) {
				matches.add(candidate);
			}
		}
		return matches;
	}

protected enum ClassNameFilter {
		// 兩種類型， 當前存在優(yōu)先， 如果classLoader中能夠加載指定類, 返回true
		PRESENT {
			@Override
			public boolean matches(String className, ClassLoader classLoader) {
				return isPresent(className, classLoader);
			}
		},
		// 缺失優(yōu)先規(guī)則， 即便在classLoader中能夠加載指定類， 也是返回false
		MISSING {
			@Override
			public boolean matches(String className, ClassLoader classLoader) {
				return !isPresent(className, classLoader);
			}
		};
    	// 抽象方法， 有子類負責具體匹配邏輯實現(xiàn) 
		public abstract boolean matches(String className, ClassLoader classLoader);
    	// 判斷指定的類， 是否能夠通過指定的classLoader加載
		public static boolean isPresent(String className, ClassLoader classLoader) {
			if (classLoader == null) {
				classLoader = ClassUtils.getDefaultClassLoader();
			}
			try {
				forName(className, classLoader);
				return true;
			}
			catch (Throwable ex) {
				return false;
			}
		}
		// 類的加載處理
		private static Class<?> forName(String className, ClassLoader classLoader) throws ClassNotFoundException {
			if (classLoader != null) {
				return classLoader.loadClass(className);
			}
			return Class.forName(className);
		}
	}

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
		long startTime = System.nanoTime();
    	// 根據(jù)配置上下文， 獲取所有需要處理的自動化配置類信息， 也就是所有的auotconfigration實現(xiàn)類
		String[] candidates = StringUtils.toStringArray(configurations);
		boolean[] skip = new boolean[candidates.length];
		boolean skipped = false;
    	// 遍歷處理， 通過getAutoConfigurationImportFilters方法， 獲取springFactores中的選擇處理器， 包含OnClassCondition、OnWebApplicationCondition和OnBeanCondition。
		for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
            // 填充filter信息
			invokeAwareMethods(filter);
            // 獲取filter的匹配結果
			boolean[] match = filter.match(candidates, autoConfigurationMetadata);
			for (int i = 0; i < match.length; i++) {
				if (!match[i]) {
                    // 如果沒有匹配， skip標記為true
					skip[i] = true;
                    // 清除該auotconfigration記錄信息
					candidates[i] = null;
					skipped = true;
				}
			}
		}
		if (!skipped) {
            // 完全匹配， 直接返回configurations數(shù)據(jù)
			return configurations;
		}
		List<String> result = new ArrayList<>(candidates.length);
		for (int i = 0; i < candidates.length; i++) {
			if (!skip[i]) {
                // 記錄需要處理的自動化配置信息
				result.add(candidates[i]);
			}
		}
		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 new ArrayList<>(result);
	}
	...
}