SpringBoot深入分析AutoConfigurationImportFilter自动化条件配置源码

@FunctionalInterface
public interface AutoConfigurationImportFilter {
	
	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负责具体实现
		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，再根据ClassNameFilter类型， 返回最终结果
			if (classNameFilter.matches(candidate, classLoader)) {
				matches.add(candidate);
			}
		}
		return matches;
	}

protected enum ClassNameFilter {
		// 两种类型， 当前存在优先， 如果classLoader中能够加载指定类, 返回true
		PRESENT {
			@Override
			public boolean matches(String className, ClassLoader classLoader) {
				return isPresent(className, classLoader);
			}
		},
		// 缺失优先规则， 即便在classLoader中能够加载指定类， 也是返回false
		MISSING {
			@Override
			public boolean matches(String className, ClassLoader classLoader) {
				return !isPresent(className, classLoader);
			}
		};
    	// 抽象方法， 有子类负责具体匹配逻辑实现 
		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();
    	// 根据配置上下文， 获取所有需要处理的自动化配置类信息， 也就是所有的auotconfigration实现类
		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数据
			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);
	}
	...
}