[Java] spring boot@EnableXXXX注解编程模型讲解

• @EnableXXXX编程模型
  
• @Import注解处理时机节点（@Confguration注解的类处理）
  
  
  
  • ImportSelector
    
  • ImportBeanDefinitionRegistrar处理
    
  • @Configurtion注解的类处理
    
  • 统一调用配置类解析出来的信息注册BeanDefinition
    
  
  

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(XXXX.class)
public @interface EnableDiscoveryClient {
   /**
  * If true, the ServiceRegistry will automatically register the local server.
  */
   boolean autoRegister() default true;
}

• 普通配置类，里面包含@Bean方法用于实例化bean
  
• ImportSelector实现类
  
• ImportBeanDefinitionRegistrar实现类
  

• 寻找BeanFactory中所有被@Configuration注解修饰的类，包括被@Configuration派生注解修饰的类。
  
• 寻找被@Configuration注解修饰的类上的所有注解元信息（这里的搜索不仅是搜索当前注解，还会迭代往修饰注解的注解的注解上层…..一直搜索@Import，直到注解最原始的注解），获取@Import注解的导入类信息，如果没有则不处理。
  
• 根据导入类的信息，判定为
  

org.springframework.context.support.AbstractApplicationContext#refresh
org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions（主线代码，必看）

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  //定义@Conguration注解修饰的类注册信息列表
 List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
 String[] candidateNames = registry.getBeanDefinitionNames();
//检查当前context中所有的bean注册信息
 for (String beanName : candidateNames) {
  BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
      ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
     if (logger.isDebugEnabled()) {
      logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
     }
  }
   //检查class是否是@Conguration注解修饰的类，包括被“继承”@Conguration注解的注解，例如@SpringBootConguration，具体可以跟踪ConfigurationClassUtils.checkConfigurationClassCandidate实现
  else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
     configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  }
 }
 // Return immediately if no @Configuration classes were found
 if (configCandidates.isEmpty()) {
  return;
 }
 // Sort by previously determined @Order value, if applicable
  //对配置类排序，顺序由Ordered接口决定
 configCandidates.sort((bd1, bd2) -> {
  int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
  int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
  return Integer.compare(i1, i2);
 });
//......略略略
 // Parse each @Configuration class
  //处理每一个配置类
 ConfigurationClassParser parser = new ConfigurationClassParser(
     this.metadataReaderFactory, this.problemReporter, this.environment,
     this.resourceLoader, this.componentScanBeanNameGenerator, registry);
 Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
 Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
 do {
   //解析处理配置类逻辑
  parser.parse(candidates);
   //......略略略
 }
 while (!candidates.isEmpty());
//......略略略
}

org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set

String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());

else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
   // Candidate class is an ImportBeanDefinitionRegistrar ->
   // delegate to it to register additional bean definitions
   Class<?> candidateClass = candidate.loadClass();
   ImportBeanDefinitionRegistrar registrar =
     BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
   ParserStrategyUtils.invokeAwareMethods(
     registrar, this.environment, this.resourceLoader, this.registry);
     //将ImportBeanDefinitionRegistrar放入map缓存起来
   configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}

public void addImportBeanDefinitionRegistrar(ImportBeanDefinitionRegistrar registrar, AnnotationMetadata importingClassMetadata) {
   this.importBeanDefinitionRegistrars.put(registrar, importingClassMetadata);
}

// Process individual @Bean methods
//对配置类的@Bean方法处理逻辑
//获取所有@Bean标注的方法元信息，后续处理
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
   configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}

//处理@Configuration,递归寻找@Configuration，以及解析@Configuration里面的@Import、@Bean、@Component、@ImportResource等。
parser.parse(candidates);
parser.validate();
//获取parser中解析得到的所有配置类
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
   this.reader = new ConfigurationClassBeanDefinitionReader(
     registry, this.sourceExtractor, this.resourceLoader, this.environment,
     this.importBeanNameGenerator, parser.getImportRegistry());
}
//根据递归找出的配置类和解析配置类得到的信息，加载BeanDefinition
this.reader.loadBeanDefinitions(configClasses);

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions
org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass

private void loadBeanDefinitionsForConfigurationClass(
    ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
   if (trackedConditionEvaluator.shouldSkip(configClass)) {
    String beanName = configClass.getBeanName();
    if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
     this.registry.removeBeanDefinition(beanName);
    }
    this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
    return;
   }
   if (configClass.isImported()) {
    registerBeanDefinitionForImportedConfigurationClass(configClass);
   }
   for (BeanMethod beanMethod : configClass.getBeanMethods()) {
     //利用@Bean的Method加载BeanDefinition
    loadBeanDefinitionsForBeanMethod(beanMethod);
   }
   loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
  //利用缓存的ImportBeanDefinitionRegistrar加载注册beandefintion
   loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsFromRegistrars（以ImportBeanDefinitionRegistrar为例跟踪）
org.springframework.context.annotation.ImportBeanDefinitionRegistrar#registerBeanDefinitions（注册BeanDefinition信息到BeanFactory）