Spring EnableAutoConfigurationImportSelector 是如何工作的 ?

关注

转载最新推荐文章于 2026-07-06 09:11:31 发布 496 阅读 AI 写同款· GEO 优化 ›

[Spring Boot] 4. Spring Boot实现自动配置的原理入口注解类@EnableAutoConfiguration@SpringBootApplication注解中包含了自动配置的入口注解：@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration 阅读详情

https://blog.youkuaiyun.com/andy_zhang2007/article/details/78580980

功能

EnableAutoConfigurationImportSelector 是一个DeferredImportSelector，由 spring boot autoconfigure 从版本1.3开始,提供用来处理EnableAutoConfiguration自动配置。

EnableAutoConfigurationImportSelector继承自AutoConfigurationImportSelector,从 spring boot 1.5 以后，EnableAutoConfigurationImportSelector已经不再被建议使用，而是推荐使用 AutoConfigurationImportSelector。
何时被引入

Spring boot应用中使用了注解@SpringBootApplication，该注解隐含地导入了EnableAutoConfigurationImportSelector,如下注解依赖链所示 :

// 注解链
@SpringBootApplication
=> @EnableAutoConfiguration
=> @Import(EnableAutoConfigurationImportSelector.class)

    1
    2
    3
    4

何时被执行

Springboot应用启动过程中使用ConfigurationClassParser分析配置类时，如果发现注解中存在@Import(ImportSelector)的情况，就会创建一个相应的ImportSelector对象，并调用其方法 public String[] selectImports(AnnotationMetadata annotationMetadata), 这里 EnableAutoConfigurationImportSelector的导入@Import(EnableAutoConfigurationImportSelector.class) 就属于这种情况,所以ConfigurationClassParser会实例化一个 EnableAutoConfigurationImportSelector 并调用它的 selectImports() 方法。

   // selectImports 的具体执行逻辑
   @Override
   public String[] selectImports(AnnotationMetadata annotationMetadata) {
       if (!isEnabled(annotationMetadata)) {
           return NO_IMPORTS;
       }
       try {
           // 从配置文件中加载 AutoConfigurationMetadata
           AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                   .loadMetadata(this.beanClassLoader);
           AnnotationAttributes attributes = getAttributes(annotationMetadata);
           // 获取所有候选配置类EnableAutoConfiguration
           // 使用了内部工具使用SpringFactoriesLoader，查找classpath上所有jar包中的
           // META-INF\spring.factories，找出其中key为
           // org.springframework.boot.autoconfigure.EnableAutoConfiguration
           // 的属性定义的工厂类名称。
           // 虽然参数有annotationMetadata,attributes,但在 AutoConfigurationImportSelector 的
           // 实现 getCandidateConfigurations()中，这两个参数并未使用
           List<String> configurations = getCandidateConfigurations(annotationMetadata,
                   attributes);
           // 去重
           configurations = removeDuplicates(configurations);
           // 排序 : 先按字典序，再按order属性，再考虑注解 @AutoConfigureBefore @AutoConfigureAfter
           configurations = sort(configurations, autoConfigurationMetadata);
           // 应用 exclusion 属性
           Set<String> exclusions = getExclusions(annotationMetadata, attributes);
           checkExcludedClasses(configurations, exclusions);
           configurations.removeAll(exclusions);
           // 应用过滤器AutoConfigurationImportFilter，
           // 对于 spring boot autoconfigure，定义了一个需要被应用的过滤器：
           // org.springframework.boot.autoconfigure.condition.OnClassCondition，
           // 此过滤器检查候选配置类上的注解@ConditionalOnClass，如果要求的类在classpath
           // 中不存在，则这个候选配置类会被排除掉
           configurations = filter(configurations, autoConfigurationMetadata);
           // 现在已经找到所有需要被应用的候选配置类
           // 广播事件 AutoConfigurationImportEvent
           fireAutoConfigurationImportEvents(configurations, exclusions);
           return configurations.toArray(new String[configurations.size()]);
       }
       catch (IOException ex) {
           throw new IllegalStateException(ex);
       }
   }
   /**
   * Return the auto-configuration class names that should be considered. By default
   * this method will load candidates using SpringFactoriesLoader with
   * getSpringFactoriesLoaderFactoryClass().
   * @param metadata the source metadata
   * @param attributes the getAttributes(AnnotationMetadata) annotation
   * attributes
   * @return a list of candidate configurations
   */
   protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
           AnnotationAttributes attributes) {
       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;
   }

   /**
   * Return the class used by SpringFactoriesLoader to load configuration
   * candidates.
   * @return the factory class
   */
   protected Class<?> getSpringFactoriesLoaderFactoryClass() {
       return EnableAutoConfiguration.class;
   }
   /**
      * 根据autoConfigurationMetadata信息对候选配置类configurations进行过滤
      **/
   private List<String> filter(List<String> configurations,
           AutoConfigurationMetadata autoConfigurationMetadata) {
       long startTime = System.nanoTime();
       String[] candidates = configurations.toArray(new String[configurations.size()]);
       // 记录候选配置类是否需要被排除,skip为true表示需要被排除,全部初始化为false,不需要被排除
       boolean[] skip = new boolean[candidates.length];
       // 记录候选配置类中是否有任何一个候选配置类被忽略，初始化为false
       boolean skipped = false;
       // 获取AutoConfigurationImportFilter并逐个应用过滤
       for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
           // 对过滤器注入其需要Aware的信息
           invokeAwareMethods(filter);
           // 使用此过滤器检查候选配置类跟autoConfigurationMetadata的匹配情况
           boolean[] match = filter.match(candidates, autoConfigurationMetadata);
           for (int i = 0; i < match.length; i++) {
               if (!match[i]) {
               // 如果有某个候选配置类不符合当前过滤器，将其标记为需要被排除，
               // 并且将 skipped设置为true，表示发现了某个候选配置类需要被排除
                   skip[i] = true;
                   skipped = true;
               }
           }
       }
       if (!skipped) {
       // 如果所有的候选配置类都不需要被排除，则直接返回外部参数提供的候选配置类集合
           return configurations;
       }
       // 逻辑走到这里因为skipped为true，表明上面的的过滤器应用逻辑中发现了某些候选配置类
       // 需要被排除，这里排除那些需要被排除的候选配置类，将那些不需要被排除的候选配置类组成
       // 一个新的集合返回给调用者
       List<String> result = new ArrayList<String>(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<String>(result);
   }
   /**
      * 使用内部工具 SpringFactoriesLoader，查找classpath上所有jar包中的
      * META-INF\spring.factories，找出其中key为
      * org.springframework.boot.autoconfigure.AutoConfigurationImportFilter
      * 的属性定义的过滤器类并实例化。
      * AutoConfigurationImportFilter过滤器可以被注册到 spring.factories用于对自动配置类
      * 做一些限制，在这些自动配置类的字节码被读取之前做快速排除处理。
      * spring boot autoconfigure 缺省注册了一个 AutoConfigurationImportFilter :
      * org.springframework.boot.autoconfigure.condition.OnClassCondition
   **/
   protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
       return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class,
               this.beanClassLoader);
   }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131

Spring 工具类 ConfigurationClassParser 是如何工作的？
Springboot 的内部工具类 SpringFactoriesLoader
---------------------
作者：九九八八
来源：优快云
原文：https://blog.youkuaiyun.com/andy_zhang2007/article/details/78580980
版权声明：本文为博主原创文章，转载请附上博文链接！