Spring註解@Import原理解析

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {
 ……
}

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
   Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
   boolean checkForCircularImports) {

  // 如果使用@Import註解修飾的類集合為空，直接返回
  if (importCandidates.isEmpty()) {
   return;
  }
  // 通過一個棧結構解決迴圈引入
  if (checkForCircularImports && isChainedImportOnStack(configClass)) {
   this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
  }
  else {
   // 新增到棧中，用於處理迴圈import的問題
   this.importStack.push(configClass);
   try {
    // 遍歷每一個@Import註解的類
    for (SourceClass candidate : importCandidates) {
     // 1. 
          // 檢驗設定類Import引入的類是否是ImportSelector子類
     if (candidate.isAssignable(ImportSelector.class)) {
      // Candidate class is an ImportSelector -> delegate to it to determine imports
      // 候選類是一個匯入選擇器->委託來確定是否進行匯入
      Class<?> candidateClass = candidate.loadClass();
      // 通過反射生成一個ImportSelect物件
      ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
        this.environment, this.resourceLoader, this.registry);
      // 獲取選擇器的額外過濾器
      Predicate<String> selectorFilter = selector.getExclusionFilter();
      if (selectorFilter != null) {
       exclusionFilter = exclusionFilter.or(selectorFilter);
      }
            
      // 判斷參照選擇器是否是DeferredImportSelector介面的範例
      // 如果是則應用選擇器將會在所有的設定類都載入完畢後載入
      if (selector instanceof DeferredImportSelector) {
       // 將選擇器新增到deferredImportSelectorHandler範例中，預留到所有的設定類載入完成後統一處理自動化設定類
       this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
      }
            
      else {
       // 獲取引入的類，然後使用遞迴方式將這些類中同樣新增了@Import註解除參照的類
              // 執行 ImportSelector.selectImports
       String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
       Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
       // 遞迴處理，被Import進來的類也有可能@Import註解
       processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
      }
     }
          // 2.
     // 如果是實現了ImportBeanDefinitionRegistrar介面的bd
     else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
      // Candidate class is an ImportBeanDefinitionRegistrar ->
      // delegate to it to register additional bean definitions
      // 候選類是ImportBeanDefinitionRegistrar  -> 委託給當前註冊器註冊其他bean
       Class<?> candidateClass = candidate.loadClass();
      ImportBeanDefinitionRegistrar registrar =
        ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
          this.environment, this.resourceLoader, this.registry);
      /**
       * 放到當前configClass的importBeanDefinitionRegistrars中
       * 在ConfigurationClassPostProcessor處理configClass時會隨之一起處理
       */
      configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
     }
     else {
      // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
      // process it as an @Configuration class
      // 候選類既不是ImportSelector也不是ImportBeanDefinitionRegistrar-->將其作為@Configuration設定類處理
      this.importStack.registerImport(
        currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
      /**
       * 如果Import的型別是普通類，則將其當作帶有@Configuration的類一樣處理
       */
      processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
     }
    }
   }
   catch (BeanDefinitionStoreException ex) {
   ……
   finally {
    this.importStack.pop();
   }
  }
 }

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {
 Class<? extends Annotation> annotation() default Annotation.class;
 boolean proxyTargetClass() default false;
 AdviceMode mode() default AdviceMode.PROXY;
 int order() default Ordered.LOWEST_PRECEDENCE;
}
// 
@Override
 public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
  ……
    // 獲取 Mode
  AdviceMode adviceMode = attributes.getEnum(getAdviceModeAttributeName());
    // 模板方法，由子類去實現
  String[] imports = selectImports(adviceMode);
  if (imports == null) {
   throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
  }
  return imports;
 }

public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {

 @Override
 @Nullable
 public String[] selectImports(AdviceMode adviceMode) {
  switch (adviceMode) {
   case PROXY:
    return new String[] {ProxyAsyncConfiguration.class.getName()};
   case ASPECTJ:
    return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
   default:
    return null;
  }
 }

}

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {
   @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
      ……
      return bpp;
   }
}