Spring创建Bean时是怎样判断条件的？

 我们在 Spring/ Spring Boot Starter 或者一些框架的源码里经常能看到类似如下的注解声明，可能作用在类上，也可能在某个方法上：

创新互联建站专注于成县企业网站建设,成都响应式网站建设公司,商城建设。成县网站建设公司,为成县等地区提供建站服务。全流程按需定制设计，专业设计，全程项目跟踪，创新互联建站专业和态度为您提供的服务

 
 
 
 
    
  
  
  
  
  1. @ConditionalOnProperty(name = "spring.cloud.refresh.enabled", matchIfMissing = true) 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. @ConditionalOnProperty(prefix = "management.metrics.export.atlas", name = "enabled", havingValue = "true", 
    4. 
  
  
  
  
  4.     matchIfMissing = true) 
    5.

我们一眼都能看出来，这是来「谈条件」的。需要满足某个属性存在，或者属性值是xx这一类的。

对于属性的匹配，是会在 Environment 里查找是否包含当前需要的属性，如果没指定 havingValue 的话，那需要同时属性的值不为「false」这个字符串，其它的东西都视为true。

今天的这篇做为铺垫，先来描述一下注解的工作原理，后面一篇我会写写与此有关的一个有趣的案例。

工作原理

浓缩版

在SpringBoot 启动过程中，会扫描当前依赖里的 @Configuration，然后遍历的过程中会判断其中哪些是要讲条件的。对于讲条件的这些，会判断

shouldSkip ，这里的是否跳过，会根据注解作用在类上，方法上，转向不同的Metadata，提取对应的实现类，但本质上还是通过 resolver 去Environment 里找找这个属性在不在，不在跳过，在的话是否值匹配。从而决定 Confirutaion 是否生效。

源码版

我们知道 Spring 启动的过程，也是创建和初始化Bean 的过程，在这个过程中，会先拿到BeanNames，并一个个的去创建和初始化。

此时，对于Configuration，是通过BeanPostProcessor的方式来处理的.

 
 
 
 
    
  
  
  
  
  1. public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
    2. 
  
  
  
  
  2.     int registryId = System.identityHashCode(registry); 
    3. 
  
  
  
  
  3.     this.registriesPostProcessed.add(registryId); 
    4. 
  
  
  
  
  4.     processConfigBeanDefinitions(registry);// 对，是这里 
    5. 
  
  
  
  
  5.   } 
    6.

部分调用栈如下：

 
 
 
 
    
  
  
  
  
  1. java.lang.Thread.State: RUNNABLE 
    2. 
  
  
  
  
  2.     at org.springframework.boot.autoconfigure.condition.OnPropertyCondition.getMatchOutcome(OnPropertyCondition.java:65) 
    3. 
  
  
  
  
  3.     at org.springframework.boot.autoconfigure.condition.SpringBootCondition.matches(SpringBootCondition.java:47) 
    4. 
  
  
  
  
  4.     at org.springframework.context.annotation.ConditionEvaluator.shouldSkip(ConditionEvaluator.java:108) 
    5. 
  
  
  
  
  5.     at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForBeanMethod(ConfigurationClassBeanDefinitionReader.java:181) 
    6. 
  
  
  
  
  6.     at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass(ConfigurationClassBeanDefinitionReader.java:142) 
    7. 
  
  
  
  
  7.     at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(ConfigurationClassBeanDefinitionReader.java:118) 
    8. 
  
  
  
  
  8.     at org.springframework.context.annotation.ConfigurationClassPostProcessor.processConfigBeanDefinitions(ConfigurationClassPostProcessor.java:328) 
    9. 
  
  
  
  
  9.     at org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor.java:233) 
    10.

这里对于 Class 和 Method，都在该方法中，处理入口不一样，传入的Meta也有所区别

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2.    * Build and validate a configuration model based on the registry of 
    3. 
  
  
  
  
  3.    * {@link Configuration} classes. 
    4. 
  
  
  
  
  4.    */ 
    5. 
  
  
  
  
  5.   public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { 
    6. 
  
  
  
  
  6.     List configCandidates = new ArrayList<>(); 
    7. 
  
  
  
  
  7.     String[] candidateNames = registry.getBeanDefinitionNames(); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     for (String beanName : candidateNames) { 
    10. 
  
  
  
  
  10.       BeanDefinition beanDef = registry.getBeanDefinition(beanName); 
    11. 
  
  
  
  
  11.       if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) || 
    12. 
  
  
  
  
  12.           ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) { 
    13. 
  
  
  
  
  13.       } 
    14. 
  
  
  
  
  14.       else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) { 
    15. 
  
  
  
  
  15.         configCandidates.add(new BeanDefinitionHolder(beanDef, beanName)); 
    16. 
  
  
  
  
  16.       } 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18.     // Return immediately if no @Configuration classes were found 
    19. 
  
  
  
  
  19.     if (configCandidates.isEmpty()) { 
    20. 
  
  
  
  
  20.       return; 
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     // Parse each @Configuration class 
    24. 
  
  
  
  
  24.     ConfigurationClassParser parser = new ConfigurationClassParser( 
    25. 
  
  
  
  
  25.         this.metadataReaderFactory, this.problemReporter, this.environment, 
    26. 
  
  
  
  
  26.         this.resourceLoader, this.componentScanBeanNameGenerator, registry); 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.     Set candidates = new LinkedHashSet<>(configCandidates); 
    29. 
  
  
  
  
  29.     Set alreadyParsed = new HashSet<>(configCandidates.size()); 
    30. 
  
  
  
  
  30.     do { 
    31. 
  
  
  
  
  31.       parser.parse(candidates); // 这里处理class 
    32. 
  
  
  
  
  32.       parser.validate(); 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34.       Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses()); 
    35. 
  
  
  
  
  35.       configClasses.removeAll(alreadyParsed); 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.       // Read the model and create bean definitions based on its content 
    38. 
  
  
  
  
  38.       if (this.reader == null) { 
    39. 
  
  
  
  
  39.         this.reader = new ConfigurationClassBeanDefinitionReader( 
    40. 
  
  
  
  
  40.             registry, this.sourceExtractor, this.resourceLoader, this.environment, 
    41. 
  
  
  
  
  41.             this.importBeanNameGenerator, parser.getImportRegistry()); 
    42. 
  
  
  
  
  42.       } 
    43. 
  
  
  
  
  43.       this.reader.loadBeanDefinitions(configClasses); // 这里处理Method 
    44. 
  
  
  
  
  44.       alreadyParsed.addAll(configClasses); 
    45. 
  
  
  
  
  45.     while (!candidates.isEmpty()); 
    46. 
  
  
  
  
  46.   } 
    47.

里面的逻辑，则都是在判断这些Condition 是否match，重点看这一行

condition.matches(this.context, metadata)

 
 
 
 
    
  
  
  
  
  1. for (Condition condition : conditions) { 
    2. 
  
  
  
  
  2.       ConfigurationPhase requiredPhase = null; 
    3. 
  
  
  
  
  3.       if (condition instanceof ConfigurationCondition) { 
    4. 
  
  
  
  
  4.         requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase(); 
    5. 
  
  
  
  
  5.       } 
    6. 
  
  
  
  
  6.       if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) { 
    7. 
  
  
  
  
  7.         return true; 
    8. 
  
  
  
  
  8.       } 
    9. 
  
  
  
  
  9.     } 
    10.

通过观察 Condition 这个接口你也能发现，和我们上面说的一样，这里不同的处理metadata是不同的。

在 SpringBoot 里，ConditionalOnProperty 的 Condition 实现，运用了一个模板方法模式， SpringBootCondition 做为模板，再调用各子类的实现方法。

 
 
 
 
    
  
  
  
  
  1. public final boolean matches(ConditionContext context, 
    2. 
  
  
  
  
  2.       AnnotatedTypeMetadata metadata) { 
    3. 
  
  
  
  
  3.     String classOrMethodName = getClassOrMethodName(metadata); 
    4. 
  
  
  
  
  4.       ConditionOutcome outcome = getMatchOutcome(context, metadata);// 这里交给了抽象方法 
    5. 
  
  
  
  
  5.       recordEvaluation(context, classOrMethodName, outcome); 
    6. 
  
  
  
  
  6.       return outcome.isMatch(); 
    7. 
  
  
  
  
  7.   } 
    8.

来看子类的实现

 
 
 
 
    
  
  
  
  
  1. private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, 
    2. 
  
  
  
  
  2.       PropertyResolver resolver) { 
    3. 
  
  
  
  
  3.     Spec spec = new Spec(annotationAttributes); 
    4. 
  
  
  
  
  4.     List missingProperties = new ArrayList<>(); 
    5. 
  
  
  
  
  5.     List nonMatchingProperties = new ArrayList<>(); 
    6. 
  
  
  
  
  6.     spec.collectProperties(resolver, missingProperties, nonMatchingProperties); 
    7. 
  
  
  
  
  7.     if (!missingProperties.isEmpty()) { 
    8. 
  
  
  
  
  8.       return ConditionOutcome.noMatch( 
    9. 
  
  
  
  
  9.           ConditionMessage.forCondition(ConditionalOnProperty.class, spec) 
    10. 
  
  
  
  
  10.               .didNotFind("property", "properties") 
    11. 
  
  
  
  
  11.               .items(Style.QUOTE, missingProperties)); 
    12. 
  
  
  
  
  12.     } 
    13. 
  
  
  
  
  13.     if (!nonMatchingProperties.isEmpty()) { 
    14. 
  
  
  
  
  14.       return ConditionOutcome.noMatch( 
    15. 
  
  
  
  
  15.           ConditionMessage.forCondition(ConditionalOnProperty.class, spec) 
    16. 
  
  
  
  
  16.               .found("different value in property", 
    17. 
  
  
  
  
  17.                   "different value in properties") 
    18. 
  
  
  
  
  18.               .items(Style.QUOTE, nonMatchingProperties)); 
    19. 
  
  
  
  
  19.     } 
    20. 
  
  
  
  
  20.     return ConditionOutcome.match(ConditionMessage 
    21. 
  
  
  
  
  21.         .forCondition(ConditionalOnProperty.class, spec).because("matched")); 
    22. 
  
  
  
  
  22.   } 
    23.

有了这个判断，对于 OnClass 之类的，你也能猜个八九不离十。

同样会有一个子类的实现

只不过判断的从属性，换成了在classloader里查找已加载的类。

本文转载自微信公众号「Tomcat那些事儿」，可以通过以下二维码关注。转载本文请联系Tomcat那些事儿公众号。

名称栏目：Spring创建Bean时是怎样判断条件的？
文章URL：http://www.csdahua.cn/qtweb/news1/547451.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

小程序开发知识

行业网站建设

和正兴机械　　 　wap网站制作　　 　不锈钢防护栏　　 　成都移动服务器托管　　 　成都做网站　　 　成都小程序开发　　 　企业网站建设公司　　 　护栏打桩机　　 　营山产后护理服务　　 　力比特机械　　 　合江网站建设　　 　西部信息服务器托管　　 　成都电商解决方案　　 　四川黔盛装饰　　 　双流做网站　　 　成都包装设计公司　　 　雅安电信机房　　 　全网整合营销　　 　梓潼做网站　　 　网站制作价格