【Spring Boot 源码学习】走近 AutoConfigurationImportSelector

/**
 * 实现了确定基于给定选择条件应该导入哪些 @Configuration 类的类型的接口，
 * 通常是一个或多个注解属性。
 * 
 * 一个 ImportSelector 可以实现以下任意一个 Aware 接口，并在调用 selectImports 
 * 方法之前调用其对应的方法：
 *    EnvironmentAware
 *    BeanFactoryAware
 *    BeanClassLoaderAware
 *    ResourceLoaderAware
 * 
 * 另外，该类也可以提供一个带有以下支持的参数类型的单个构造函数：
 *    Environment
 *    BeanFactory
 *    ClassLoader
 *    ResourceLoader
 * 
 * ImportSelector 实现通常与普通的 @Import 注解一样进行处理。
 * 然而，还可以推迟选择要导入的内容，直到所有 @Configuration 
 * 类都被处理完毕（详见 DeferredImportSelector）。
 *
 */
public interface ImportSelector {

    /**
     * 根据导入的 @Configuration 类的 AnnotationMetadata（注解元数据），
     * 选择并返回应该导入的类名称。
     * 
     * @return 返回类名的数组，如果没有则返回空数组。
     */
    String[] selectImports(AnnotationMetadata importingClassMetadata);

    /**
     * 返回一个用于从导入的候选类中排除类的断言函数，
     * 该函数会递归地应用于通过此选择器的导入项找到的所有类。
     * 
     * 如果对于给定的完全限定类名，该断言函数返回 true，
     * 则该类将不被视为被导入的配置类，从而跳过类文件加载和元数据检查。
     * 
     * @return 返回一个用于完全限定的候选类名的筛选断言函数，该函数适用于递归导入的配置类。
     * 如果没有筛选断言函数，则返回 null。
     * @since 5.2.4
     */
    @Nullable
    default Predicate<String> getExclusionFilter() {
        return null;
    }

}

// 其他导入语句省略
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.DeferredImportSelector;
import org.springframework.core.Ordered;

/**
 * DeferredImportSelector 用于处理自动配置的延迟导入选择器。
 * 如果需要自定义的 @EnableAutoConfiguration 变体，也可以通过继承这个类来实现。
 */
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
        ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    // 其他省略
}

/**
 * 一种在所有 @Configuration bean 处理完毕后运行的 ImportSelector 变体。
 * 这种类型的选择器在所选的导入项带有条件时特别有用。
 * 
 * 实现类可以扩展 org.springframework.core.Ordered 接口或使用 
 * org.springframework.core.annotation.Order 注解来指定与
 * 其他 DeferredImportSelectors 的优先级。
 * 
 * 实现类还可以提供一个导入组（import group），
 * 它可以在不同的选择器之间提供额外的排序和过滤逻辑。
 */
public interface DeferredImportSelector extends ImportSelector {

    /**
     * 返回一个特定的导入组。
     * 默认实现会在不需要分组的情况下返回 null。
     * 
     * @return 导入组的类，如果没有则返回 null。
     * @since 5.0
     */
    @Nullable
    default Class<? extends Group> getImportGroup() {
        return null;
    }


    /**
     * 用于将来自不同导入选择器的结果进行分组的接口。
     * 
     * @since 5.0
     */
    interface Group {

        /**
         * 使用指定的 DeferredImportSelector 处理导入的 @Configuration 类的 AnnotationMetadata。
         */
        void process(AnnotationMetadata metadata, DeferredImportSelector selector);

        /**
         * 返回此组应该导入的类的条目
         */
        Iterable<Entry> selectImports();


        /**
         * 一个条目，包含导入的配置类的 AnnotationMetadata 和要导入的类名。
         */
        class Entry {

            private final AnnotationMetadata metadata;

            private final String importClassName;

            public Entry(AnnotationMetadata metadata, String importClassName) {
                this.metadata = metadata;
                this.importClassName = importClassName;
            }

            /**
             * 返回导入的配置类的 AnnotationMetadata【注解元数据】
             */
            public AnnotationMetadata getMetadata() {
                return this.metadata;
            }

            /**
             * 返回要导入的类的完全限定名称。
             */
            public String getImportClassName() {
                return this.importClassName;
            }

            // 省略。。。
        }
    }

}

    @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);
    }

    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        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 = getConfigurationClassFilter().filter(configurations);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }