如何查看注解实现_SpringBoot的注解@ConditonOnClass注解是如何实现的？

springboot核心注解@EnableAutoConfiguration会导入@Import(AutoConfigurationImportSelector.class)，这个类实现了DeferredImportSelector接口，即可以达到spring完成bean的初始化之后会回调该接口的selectImports方法，方法的参数是各个bean的类属性，注解等，返回的bean才会导入到spring中。AutoConfigurationImportSelector实现逻辑如下：

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
    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);
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return StringUtils.toStringArray(configurations);
}

该方法逻辑大致就是加载各个jar包下的spring.factories配置文件，读取出自动配置的类，然后去掉重复的以及需要排除的，然后进行过滤，即filter方法，该方法如下：

private List<String> filter(List<String> configurations,
        AutoConfigurationMetadata autoConfigurationMetadata) {
    long startTime = System.nanoTime();
    String[] candidates = StringUtils.toStringArray(configurations);
    boolean[] skip = new boolean[candidates.length];
    boolean skipped = false;
    for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
        invokeAwareMethods(filter);
        boolean[] match = filter.match(candidates, autoConfigurationMetadata);
        for (int i = 0; i < match.length; i++) {
            if (!match[i]) {
                skip[i] = true;
                skipped = true;
            }
        }
    }
    if (!skipped) {
        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);
}

重点看第一个for循环，getAutoConfigurationImportFilters()会返回所有AutoConfigurationImportFilter的实现类，目前只有OnClassCondition这个类实现了该接口，即返回的都是OnClassCondition类的对象，而OnClassCondition继承自SpringBootCondition，match会根据条件过滤掉不符合条件的配置类，留下符合条件的配置类，从而被AutoConfigurationImportSelector注入spring完成加载。这里说一下match方法是如何处理ConditionOnClass注解的，看实现，其中的getOutcomes方法实现，其中使用createOutcomesResolver方法创建了2个OutcomesResolver，需要注意的是，留下了一半的解析任务放在新开线程中实现以获得更好的性能，这里主要看StandardOutcomesResolver的实现，对应的实现方法：

private ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
				int start, int end, AutoConfigurationMetadata autoConfigurationMetadata) {
    ConditionOutcome[] outcomes = new ConditionOutcome[end - start];
    for (int i = start; i < end; i++) {
        String autoConfigurationClass = autoConfigurationClasses[i];
        Set<String> candidates = autoConfigurationMetadata
                .getSet(autoConfigurationClass, "ConditionalOnClass");
        if (candidates != null) {
            outcomes[i - start] = getOutcome(candidates);
        }
    }
    return outcomes;
}

private ConditionOutcome getOutcome(Set<String> candidates) {
    try {
        List<String> missing = getMatches(candidates, MatchType.MISSING,
                this.beanClassLoader);
        if (!missing.isEmpty()) {
            return ConditionOutcome.noMatch(
                    ConditionMessage.forCondition(ConditionalOnClass.class)
                            .didNotFind("required class", "required classes")
                            .items(Style.QUOTE, missing));
        }
    }
    catch (Exception ex) {
        // We'll get another chance later
    }
    return null;
}

可以看到读取了类上面的ConditionalOnClass注解的值，然后和环境中进行匹配，如果存在就返回ConditionOutcome对象，存在返回空。经过这些过滤，最终由上面说的AutoConfigurationImportSelector类返回后被spring加载从而实现了条件注解的配置功能。

另外@configuration类会在ConfigurationClassPostProcessor中进行处理，一些其他类型的@Condition条件判断等，如OnJavaCondition注解等，会在这里处理，这里不再赘述。