public interface ImportSelector {
   /**
    * Select and return the names of which class(es) should be imported based on
    * the {@link AnnotationMetadata} of the importing @{@link Configuration} class.
    * 選擇并返回需要導入的類的名稱，這些類基于AnnotationMetadata
    * 并且導入到@Configuration注解的類中的
    * @return the class names, or an empty array if none
    * 返回所有的class name，如果沒有，就返回空
    */
   String[] selectImports(AnnotationMetadata importingClassMetadata);
   /**
    * 返回排除的類，是一個類過濾器，但是這個方法被default注解了，
    * 可見Spring公司也知道，這個基本沒啥人用
    */
   @Nullable
   default Predicate<String> getExclusionFilter() {
      return null;
   }
}

/**
 * 由于我們使用的ImportSelector所以就不需要放到Spring容器當中了。
 * 我們要用@Import這個注解引入進去。
 */
public class MyImportSelect implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{IndexDao.class.getName()};
    }
}

@ComponentScan("com.demo")
@Import(MyImportSelect.class)
public class AppConfig {
}

public class IndexDao {
    public void query(){
        System.out.println("query IndexDao for MyImportSelect");
    }
}

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext anno=new AnnotationConfigApplicationContext(AppConfig.class);
         anno.getBean(IndexDao.class).query();
         }
}
運行打印
query IndexDao for MyImportSelect

public class IndexDao {
    public void query(){
	System.out.println("log for IndexDao3");
        return Proxy.newProxyInstance(IndexDao3);//偽碼
    }
}

@Retention(RetentionPolicy.RUNTIME) //開啟運行時加載
@Import(MyImportSelect.class)
public @interface EnableMySelector {
}

@ComponentScan("com.demo")
@EnableMySelector
public class AppConfig { }
運行，一樣打印
query IndexDao for MyImportSelect

org.springframework.context.annotation.ConfigurationClassParser#processImports
//這里攔截了DeferredImportSelector然后使用handle()
if (selector instanceof DeferredImportSelector) {
   this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}

public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
   DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
   if (this.deferredImportSelectors == null) {
      DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
      handler.register(holder);
      handler.processGroupImports();
   }
   else {
	//加入到了一個ArrayList中
      this.deferredImportSelectors.add(holder);
   }
}

org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
   //根據BeanDefinition的類型做不同的處理，一般都會調用ConfigurationClassParser.parse()進行解析
   for (BeanDefinitionHolder holder : configCandidates) {
      BeanDefinition bd = holder.getBeanDefinition(); //拿出BeanDefinition
      try {
         if (bd instanceof AnnotatedBeanDefinition) {  //判斷是不是加了注解的
            // 解析注解對象，并且把解析出來的bd方法map中，但是這里的bd指的的普通的
            // 普通和不普通的怎么區(qū)分。比如@Bean和各種beanFactoryPostProcessor得到的bean
            //如果被加了注解，又調用了一個parse()方法
            parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
         }
         else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
            parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
         }
         else {
            parse(bd.getBeanClassName(), holder.getBeanName());
         }
      }
      catch (BeanDefinitionStoreException ex) {
         throw ex;
      }
      catch (Throwable ex) {
         throw new BeanDefinitionStoreException(
               "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
      }
   }
	//處理，而此時上面其他的Import已經處理完了
   this.deferredImportSelectorHandler.process();
}