前言：

Spring4推出了@Conditional注解，方便程序根据当前环境或者容器情况来动态注入bean，对@Conditional注解不熟悉的朋友可移步至 Spring @Conditional注解 详细讲解及示例 这篇博客进行学习。

继@Conditional注解后，又基于此注解推出了很多派生注解，比如@ConditionalOnBean、@ConditionalOnMissingBean、@ConditionalOnExpression、@ConditionalOnClass......动态注入bean变得更方便了。本篇将讲解@ConditionalOnBean注解。

配置类中有两个Computer类的bean，一个是笔记本电脑，一个是备用电脑。如果当前容器中已经有电脑bean了，就不注入备用电脑，如果没有，则注入备用电脑，这里需要使用到@ConditionalOnMissingBean。



  1. 

    

    

    

    @Configuration
    

    2. 

  2. 

    

    

    

    public class BeanConfig {
    

    3. 

  3. 

    

    

    

     
    

    4. 

  4. 

    

    

    

        @Bean(name = "notebookPC")
    

    5. 

  5. 

    

    

    

        public Computer computer1(){
    

    6. 

  6. 

    

    

    

            return new Computer("笔记本电脑");
    

    7. 

  7. 

    

    

    

        }
    

    8. 

  8. 

    

    

    

     
    

    9. 

  9. 

    

    

    

        @ConditionalOnMissingBean(Computer.class)
    

    10. 

  10. 

    

    

    

        @Bean("reservePC")
    

    11. 

  11. 

    

    

    

        public Computer computer2(){
    

    12. 

  12. 

    

    

    

            return new Computer("备用电脑");
    

    13. 

  13. 

    

    

    

        }
    

    14. 

  14. 

    

    

    

    }

这个注解就实现了功能，这个@ConditionalOnMissingBean为我们做了什么呢？我们来一探究竟.。

一探究竟：

首先，来看@ConditionalOnMissingBean的声明：



  1. 

    

    

    

    //可以标注在类和方法上
    

    2. 

  2. 

    

    

    

    @Target({ElementType.TYPE, ElementType.METHOD})
    

    3. 

  3. 

    

    

    

    @Retention(RetentionPolicy.RUNTIME)
    

    4. 

  4. 

    

    

    

    @Documented
    

    5. 

  5. 

    

    

    

    //使用了@Conditional注解，条件类是OnBeanCondition
    

    6. 

  6. 

    

    

    

    @Conditional({OnBeanCondition.class})
    

    7. 

  7. 

    

    

    

    public @interface ConditionalOnMissingBean {
    

    8. 

  8. 

    

    

    

        Class<?>[] value() default {};
    

    9. 

  9. 

    

    

    

     
    

    10. 

  10. 

    

    

    

        String[] type() default {};
    

    11. 

  11. 

    

    

    

     
    

    12. 

  12. 

    

    

    

        Class<?>[] ignored() default {};
    

    13. 

  13. 

    

    

    

     
    

    14. 

  14. 

    

    

    

        String[] ignoredType() default {};
    

    15. 

  15. 

    

    

    

     
    

    16. 

  16. 

    

    

    

        Class<? extends Annotation>[] annotation() default {};
    

    17. 

  17. 

    

    

    

     
    

    18. 

  18. 

    

    

    

        String[] name() default {};
    

    19. 

  19. 

    

    

    

     
    

    20. 

  20. 

    

    

    

        SearchStrategy search() default SearchStrategy.ALL;
    

    21. 

  21. 

    

    

    

    }

这时候，我们就看到了我们熟悉的@Conditional注解，OnBeanCondition作为条件类。

OnBeanCondition类的声明：



  1. 

    

    

    

    //定义带注释的组件的排序顺序，2147483647即为默认值
    

    2. 

  2. 

    

    

    

    @Order(2147483647)
    

    3. 

  3. 

    

    

    

    class OnBeanCondition extends SpringBootCondition implements ConfigurationCondition {

它继承了SpringBootCondition类，OnBeanCondition类中没有matches方法，而SpringBootCondition类中有实现matches方法。OnBeanCondition还实现了ConfigurationCondition，ConfigurationCondition接口不熟悉的读者可以到Spring ConfigurationCondition接口详解 了解接口。OnBeanCondition类重写了getConfigurationPhase()方法，表示在注册bean的时候注解生效：



  1. 

    

    

    

        public ConfigurationPhase getConfigurationPhase() {
    

    2. 

  2. 

    

    

    

            return ConfigurationPhase.REGISTER_BEAN;
    

    3. 

  3. 

    

    

    

        }

就从matches方法开始：



  1. 

    

    

    

        //SpringBootCondition类中的matches方法
    

    2. 

  2. 

    

    

    

        public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    

    3. 

  3. 

    

    

    

            //获取当前的类名或者方法名（由标注的位置决定）
    

    4. 

  4. 

    

    

    

            String classOrMethodName = getClassOrMethodName(metadata);
    

    5. 

  5. 

    

    

    

     
    

    6. 

  6. 

    

    

    

            try {
    

    7. 

  7. 

    

    

    

                //关键代码：这里就会判断出结果
    

    8. 

  8. 

    

    

    

                ConditionOutcome outcome = this.getMatchOutcome(context, metadata);
    

    9. 

  9. 

    

    

    

                //存入日志
    

    10. 

  10. 

    

    

    

                this.logOutcome(classOrMethodName, outcome);
    

    11. 

  11. 

    

    

    

                //存入记录
    

    12. 

  12. 

    

    

    

                this.recordEvaluation(context, classOrMethodName, outcome);
    

    13. 

  13. 

    

    

    

                //最后返回ConditionOutcome的isMatch就是返回boolean类型结果
    

    14. 

  14. 

    

    

    

                return outcome.isMatch();
    

    15. 

  15. 

    

    

    

            } catch (NoClassDefFoundError var5) {
    

    16. 

  16. 

    

    

    

                throw new IllegalStateException("Could not evaluate condition on " + classOrMethodName + " due to " + var5.getMessage() + " not found. Make sure your own configuration does not rely on that class. This can also happen if you are @ComponentScanning a springframework package (e.g. if you put a @ComponentScan in the default package by mistake)", var5);
    

    17. 

  17. 

    

    

    

            } catch (RuntimeException var6) {
    

    18. 

  18. 

    

    

    

                throw new IllegalStateException("Error processing condition on " + this.getName(metadata), var6);
    

    19. 

  19. 

    

    

    

            }
    

    20. 

  20. 

    

    

    

        }

关键代码在OnBeanCondition的getMatchOutcome方法上：



  1. 

    

    

    

        /**
    

    2. 

  2. 

    

    

    

         * 获得判断结果的方法，ConditionOutcome类中存着boolean类型的结果
    

    3. 

  3. 

    

    

    

         */
    

    4. 

  4. 

    

    

    

        public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
    

    5. 

  5. 

    

    

    

    	//返回一个新的ConditionMessage
    

    6. 

  6. 

    

    

    

            ConditionMessage matchMessage = ConditionMessage.empty();
    

    7. 

  7. 

    

    

    

            OnBeanCondition.BeanSearchSpec spec;
    

    8. 

  8. 

    

    

    

            List matching;
    

    9. 

  9. 

    

    

    

            //这是metadata会调用isAnnotated方法判断当前标注的注解是不是ConditionalOnMissingBean
    

    10. 

  10. 

    

    

    

    	//其实@ConditionalOnBean、@ConditionalOnMissingBean和@ConditionalOnSingleCandidate都是使用这个条件类，所以这里做判断
    

    11. 

  11. 

    

    

    

            if (metadata.isAnnotated(ConditionalOnBean.class.getName())) {
    

    12. 

  12. 

    

    

    

                spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnBean.class);
    

    13. 

  13. 

    

    

    

                matching = this.getMatchingBeans(context, spec);
    

    14. 

  14. 

    

    

    

                if (matching.isEmpty()) {
    

    15. 

  15. 

    

    

    

                    return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnBean.class, new Object[]{spec}).didNotFind("any beans").atAll());
    

    16. 

  16. 

    

    

    

                }
    

    17. 

  17. 

    

    

    

     
    

    18. 

  18. 

    

    

    

                matchMessage = matchMessage.andCondition(ConditionalOnBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching);
    

    19. 

  19. 

    

    

    

            }
    

    20. 

  20. 

    

    

    

     
    

    21. 

  21. 

    

    

    

            if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {
    

    22. 

  22. 

    

    

    

                OnBeanCondition.BeanSearchSpec spec = new OnBeanCondition.SingleCandidateBeanSearchSpec(context, metadata, ConditionalOnSingleCandidate.class);
    

    23. 

  23. 

    

    

    

                matching = this.getMatchingBeans(context, spec);
    

    24. 

  24. 

    

    

    

                if (matching.isEmpty()) {
    

    25. 

  25. 

    

    

    

                    return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).didNotFind("any beans").atAll());
    

    26. 

  26. 

    

    

    

                }
    

    27. 

  27. 

    

    

    

     
    

    28. 

  28. 

    

    

    

                if (!this.hasSingleAutowireCandidate(context.getBeanFactory(), matching, spec.getStrategy() == SearchStrategy.ALL)) {
    

    29. 

  29. 

    

    

    

                    return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).didNotFind("a primary bean from beans").items(Style.QUOTE, matching));
    

    30. 

  30. 

    

    

    

                }
    

    31. 

  31. 

    

    

    

     
    

    32. 

  32. 

    

    

    

                matchMessage = matchMessage.andCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).found("a primary bean from beans").items(Style.QUOTE, matching);
    

    33. 

  33. 

    

    

    

            }
    

    34. 

  34. 

    

    

    

     
    

    35. 

  35. 

    

    

    

            //如果当前注入的bean是@ConditionalOnMissingBean
    

    36. 

  36. 

    

    

    

            if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
    

    37. 

  37. 

    

    

    

                //返回一个spec（说明），这里的spec规定了搜索的内容，比如搜索策略、需要搜索的类名......
    

    38. 

  38. 

    

    

    

                spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnMissingBean.class);
    

    39. 

  39. 

    

    

    

                //主要的搜索实现在这个方法里，最后返回一个list
    

    40. 

  40. 

    

    

    

                matching = this.getMatchingBeans(context, spec);
    

    41. 

  41. 

    

    

    

                //判断搜索出来的结果
    

    42. 

  42. 

    

    

    

                if (!matching.isEmpty()) {
    

    43. 

  43. 

    

    

    

                    return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching));
    

    44. 

  44. 

    

    

    

                }
    

    45. 

  45. 

    

    

    

     
    

    46. 

  46. 

    

    

    

                matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, new Object[]{spec}).didNotFind("any beans").atAll();
    

    47. 

  47. 

    

    

    

            }
    

    48. 

  48. 

    

    

    

     
    

    49. 

  49. 

    

    

    

            return ConditionOutcome.match(matchMessage);
    

    50. 

  50. 

    

    

    

        }

spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnBean.class);

这句中，相当于从内部类中将标注@ConditionalOnMissingBean注解时的属性都取出来：



  1. 

    

    

    

            BeanSearchSpec(ConditionContext context, AnnotatedTypeMetadata metadata, Class<?> annotationType) {
    

    2. 

  2. 

    

    

    

                this.annotationType = annotationType;
    

    3. 

  3. 

    

    

    

                MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(annotationType.getName(), true);
    

    4. 

  4. 

    

    

    

                //将attributes这个map中的数据放到对应的list成员变量中
    

    5. 

  5. 

    

    

    

                this.collect(attributes, "name", this.names);
    

    6. 

  6. 

    

    

    

                this.collect(attributes, "value", this.types);
    

    7. 

  7. 

    

    

    

                this.collect(attributes, "type", this.types);
    

    8. 

  8. 

    

    

    

                this.collect(attributes, "annotation", this.annotations);
    

    9. 

  9. 

    

    

    

                this.collect(attributes, "ignored", this.ignoredTypes);
    

    10. 

  10. 

    

    

    

                this.collect(attributes, "ignoredType", this.ignoredTypes);
    

    11. 

  11. 

    

    

    

                this.strategy = (SearchStrategy)metadata.getAnnotationAttributes(annotationType.getName()).get("search");
    

    12. 

  12. 

    

    

    

                OnBeanCondition.BeanTypeDeductionException deductionException = null;
    

    13. 

  13. 

    

    

    

     
    

    14. 

  14. 

    

    

    

                try {
    

    15. 

  15. 

    

    

    

                    if (this.types.isEmpty() && this.names.isEmpty()) {
    

    16. 

  16. 

    

    

    

                        this.addDeducedBeanType(context, metadata, this.types);
    

    17. 

  17. 

    

    

    

                    }
    

    18. 

  18. 

    

    

    

                } catch (OnBeanCondition.BeanTypeDeductionException var7) {
    

    19. 

  19. 

    

    

    

                    deductionException = var7;
    

    20. 

  20. 

    

    

    

                }
    

    21. 

  21. 

    

    

    

     
    

    22. 

  22. 

    

    

    

                this.validate(deductionException);
    

    23. 

  23. 

    

    

    

            }
    

    24. 

  24. 

    

    

    

     
    

    25. 

  25. 

    

    

    

            //验证的方法
    

    26. 

  26. 

    

    

    

            protected void validate(OnBeanCondition.BeanTypeDeductionException ex) {
    

    27. 

  27. 

    

    

    

                if (!this.hasAtLeastOne(this.types, this.names, this.annotations)) {
    

    28. 

  28. 

    

    

    

                    String message = this.annotationName() + " did not specify a bean using type, name or annotation";
    

    29. 

  29. 

    

    

    

                    if (ex == null) {
    

    30. 

  30. 

    

    

    

                        throw new IllegalStateException(message);
    

    31. 

  31. 

    

    

    

                    } else {
    

    32. 

  32. 

    

    

    

                        throw new IllegalStateException(message + " and the attempt to deduce the bean's type failed", ex);
    

    33. 

  33. 

    

    

    

                    }
    

    34. 

  34. 

    

    

    

                }
    

    35. 

  35. 

    

    

    

            }

看一下OnBeanCondition类中的getMatchingBeans方法，里面有用到搜索策略，详见搜索策略介绍



  1. 

    

    

    

        private List<String> getMatchingBeans(ConditionContext context, OnBeanCondition.BeanSearchSpec beans) {
    

    2. 

  2. 

    

    

    

            //获得当前bean工厂
    

    3. 

  3. 

    

    

    

            ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    

    4. 

  4. 

    

    

    

            //判断当前的搜索策略是否是PARENTS或者ANCESTORS，默认是ALL
    

    5. 

  5. 

    

    

    

            if (beans.getStrategy() == SearchStrategy.PARENTS || beans.getStrategy() == SearchStrategy.ANCESTORS) {
    

    6. 

  6. 

    

    

    

                BeanFactory parent = beanFactory.getParentBeanFactory();
    

    7. 

  7. 

    

    

    

                Assert.isInstanceOf(ConfigurableListableBeanFactory.class, parent, "Unable to use SearchStrategy.PARENTS");
    

    8. 

  8. 

    

    

    

                //如果是PARENTS或者ANCESTORS，当前bean工厂就用父工厂
    

    9. 

  9. 

    

    

    

                beanFactory = (ConfigurableListableBeanFactory)parent;
    

    10. 

  10. 

    

    

    

            }
    

    11. 

  11. 

    

    

    

     
    

    12. 

  12. 

    

    

    

            if (beanFactory == null) {
    

    13. 

  13. 

    

    

    

                return Collections.emptyList();
    

    14. 

  14. 

    

    

    

            } else {
    

    15. 

  15. 

    

    

    

                List<String> beanNames = new ArrayList();
    

    16. 

  16. 

    

    

    

                //如果当前搜索策略等于CURRENT，为true
    

    17. 

  17. 

    

    

    

                boolean considerHierarchy = beans.getStrategy() != SearchStrategy.CURRENT;
    

    18. 

  18. 

    

    

    

                //这里的type就是需要查找的bean的类型
    

    19. 

  19. 

    

    

    

                //下面，会从属性中找bean
    

    20. 

  20. 

    

    

    

                Iterator var6 = beans.getTypes().iterator();
    

    21. 

  21. 

    

    

    

     
    

    22. 

  22. 

    

    

    

                String beanName;
    

    23. 

  23. 

    

    

    

                while(var6.hasNext()) {
    

    24. 

  24. 

    

    

    

                    beanName = (String)var6.next();
    

    25. 

  25. 

    

    

    

                    //如果找到了类型，接下来就是根据类型找bean的实例名，找示例名的方法在下方，实际上就是一个getNamesForType
    

    26. 

  26. 

    

    

    

                    beanNames.addAll(this.getBeanNamesForType(beanFactory, beanName, context.getClassLoader(), considerHierarchy));
    

    27. 

  27. 

    

    

    

                }
    

    28. 

  28. 

    

    

    

     
    

    29. 

  29. 

    

    

    

                var6 = beans.getIgnoredTypes().iterator();
    

    30. 

  30. 

    

    

    

     
    

    31. 

  31. 

    

    

    

                while(var6.hasNext()) {
    

    32. 

  32. 

    

    

    

                    beanName = (String)var6.next();
    

    33. 

  33. 

    

    

    

                    beanNames.removeAll(this.getBeanNamesForType(beanFactory, beanName, context.getClassLoader(), considerHierarchy));
    

    34. 

  34. 

    

    

    

                }
    

    35. 

  35. 

    

    

    

     
    

    36. 

  36. 

    

    

    

                var6 = beans.getAnnotations().iterator();
    

    37. 

  37. 

    

    

    

     
    

    38. 

  38. 

    

    

    

                while(var6.hasNext()) {
    

    39. 

  39. 

    

    

    

                    beanName = (String)var6.next();
    

    40. 

  40. 

    

    

    

                    beanNames.addAll(Arrays.asList(this.getBeanNamesForAnnotation(beanFactory, beanName, context.getClassLoader(), considerHierarchy)));
    

    41. 

  41. 

    

    

    

                }
    

    42. 

  42. 

    

    

    

     
    

    43. 

  43. 

    

    

    

                var6 = beans.getNames().iterator();
    

    44. 

  44. 

    

    

    

     
    

    45. 

  45. 

    

    

    

                while(var6.hasNext()) {
    

    46. 

  46. 

    

    

    

                    beanName = (String)var6.next();
    

    47. 

  47. 

    

    

    

                    if (this.containsBean(beanFactory, beanName, considerHierarchy)) {
    

    48. 

  48. 

    

    

    

                        beanNames.add(beanName);
    

    49. 

  49. 

    

    

    

                    }
    

    50. 

  50. 

    

    

    

                }
    

    51. 

  51. 

    

    

    

                //将存放bean实例名的list返回
    

    52. 

  52. 

    

    

    

                return beanNames;
    

    53. 

  53. 

    

    

    

            }
    

    54. 

  54. 

    

    

    

        }
    

    55. 

  55. 

    

    

    

     
    

    56. 

  56. 

    

    

    

     
    

    57. 

  57. 

    

    

    

     
    

    58. 

  58. 

    

    

    

        //根据类型获取bean的name
    

    59. 

  59. 

    

    

    

        private Collection<String> getBeanNamesForType(ListableBeanFactory beanFactory, String type, ClassLoader classLoader, boolean considerHierarchy) throws LinkageError {
    

    60. 

  60. 

    

    

    

            try {
    

    61. 

  61. 

    

    

    

                Set<String> result = new LinkedHashSet();
    

    62. 

  62. 

    

    

    

                this.collectBeanNamesForType(result, beanFactory, ClassUtils.forName(type, classLoader), considerHierarchy);
    

    63. 

  63. 

    

    

    

                return result;
    

    64. 

  64. 

    

    

    

            } catch (ClassNotFoundException var6) {
    

    65. 

  65. 

    

    

    

                return Collections.emptySet();
    

    66. 

  66. 

    

    

    

            } catch (NoClassDefFoundError var7) {
    

    67. 

  67. 

    

    

    

                return Collections.emptySet();
    

    68. 

  68. 

    

    

    

            }
    

    69. 

  69. 

    

    

    

        }
    

    70. 

  70. 

    

    

    

     
    

    71. 

  71. 

    

    

    

        private void collectBeanNamesForType(Set<String> result, ListableBeanFactory beanFactory, Class<?> type, boolean considerHierarchy) {
    

    72. 

  72. 

    

    

    

            result.addAll(BeanTypeRegistry.get(beanFactory).getNamesForType(type));
    

    73. 

  73. 

    

    

    

            if (considerHierarchy && beanFactory instanceof HierarchicalBeanFactory) {
    

    74. 

  74. 

    

    

    

                BeanFactory parent = ((HierarchicalBeanFactory)beanFactory).getParentBeanFactory();
    

    75. 

  75. 

    

    

    

                if (parent instanceof ListableBeanFactory) {
    

    76. 

  76. 

    

    

    

                    this.collectBeanNamesForType(result, (ListableBeanFactory)parent, type, considerHierarchy);
    

    77. 

  77. 

    

    

    

                }
    

    78. 

  78. 

    

    

    

            }
    

    79. 

  79. 

    

    

    

     
    

    80. 

  80. 

    

    

    

        }

找完bean了之后，回到刚才的代码里：



  1. 

    

    

    

            //如果当前注入的bean是@ConditionalOnMissingBean
    

    2. 

  2. 

    

    

    

            if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
    

    3. 

  3. 

    

    

    

                //返回一个spec（说明），这里的spec规定了搜索的内容，比如搜索策略、需要搜索的类名......
    

    4. 

  4. 

    

    

    

                spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnMissingBean.class);
    

    5. 

  5. 

    

    

    

                matching = this.getMatchingBeans(context, spec);
    

    6. 

  6. 

    

    

    

                if (!matching.isEmpty()) {
    

    7. 

  7. 

    

    

    

                    return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching));
    

    8. 

  8. 

    

    

    

                }
    

    9. 

  9. 

    

    

    

     
    

    10. 

  10. 

    

    

    

                matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, new Object[]{spec}).didNotFind("any beans").atAll();
    

    11. 

  11. 

    

    

    

            }

如果第5行返回的list不是空的，就会返回ConditionOutcome对象noMatch方法，表示不匹配。ConditionOutcome类用于存放过滤结果，只有两个变量：



  1. 

    

    

    

    /**
    

    2. 

  2. 

    

    

    

     * 过滤结果类
    

    3. 

  3. 

    

    

    

     */
    

    4. 

  4. 

    

    

    

    public class ConditionOutcome {
    

    5. 

  5. 

    

    

    

    	/**
    

    6. 

  6. 

    

    

    

    	 * 匹配结果 true or false
    

    7. 

  7. 

    

    

    

    	 */
    

    8. 

  8. 

    

    

    

        private final boolean match;
    

    9. 

  9. 

    

    

    

    	/**
    

    10. 

  10. 

    

    

    

    	 * 匹配结果信息
    

    11. 

  11. 

    

    

    

    	 */
    

    12. 

  12. 

    

    

    

        private final ConditionMessage message;

两者区别：

@ConditionOnBean在判断list的时候，如果list没有值，返回false，否则返回true

@ConditionOnMissingBean在判断list的时候，如果list没有值，返回true，否则返回false，其他逻辑都一样

例子：

  • @ConditionalOnBean(javax.sql.DataSource.class)    

    Spring容器或者所有父容器中需要存在至少一个javax.sql.DataSource类的实例

SpringBoot @ConditionalOnBean、@ConditionalOnMissingBean注解源码分析与示例的更多相关文章

  1. SpringBoot的条件注解源码解析

    SpringBoot的条件注解源码解析 @ConditionalOnBean.@ConditionalOnMissingBean 启动项目 会在ConfigurationClassBeanDefini ...

  2. Springboot 加载配置文件源码分析

    Springboot 加载配置文件源码分析 本文的分析是基于springboot 2.2.0.RELEASE. 本篇文章的相关源码位置:https://github.com/wbo112/blogde ...

  3. Spring笔记(5) - 声明式事务@EnableTransactionManagement注解源码分析

    一.背景 前面详解了实现Spring事务的两种方式的不同实现:编程式事务和声明式事务,对于配置都使用到了xml配置,今天介绍Spring事务的注解开发,例如下面例子: 配置类:注册数据源.JDBC模板 ...

  4. java io系列02之 ByteArrayInputStream的简介,源码分析和示例(包括InputStream)

    我们以ByteArrayInputStream,拉开对字节类型的“输入流”的学习序幕.本章,我们会先对ByteArrayInputStream进行介绍,然后深入了解一下它的源码,最后通过示例来掌握它的 ...

  5. java io系列03之 ByteArrayOutputStream的简介,源码分析和示例(包括OutputStream)

    前面学习ByteArrayInputStream,了解了“输入流”.接下来,我们学习与ByteArrayInputStream相对应的输出流,即ByteArrayOutputStream.本章,我们会 ...

  6. java io系列04之 管道(PipedOutputStream和PipedInputStream)的简介,源码分析和示例

    本章,我们对java 管道进行学习. 转载请注明出处:http://www.cnblogs.com/skywang12345/p/io_04.html java 管道介绍 在java中,PipedOu ...

  7. springBoot从入门到源码分析

    先分享一个springBoot搭建学习项目,和springboot多数据源项目的传送门:https://github.com/1057234721/springBoot 1. SpringBoot快速 ...

  8. spring注解源码分析--how does autowired works？

    1. 背景 注解可以减少代码的开发量,spring提供了丰富的注解功能.我们可能会被问到,spring的注解到底是什么触发的呢?今天以spring最常使用的一个注解autowired来跟踪代码,进行d ...

  9. SpringBoot拦截器及源码分析

    1.拦截器是什么 java里的拦截器(Interceptor)是动态拦截Action调用的对象,它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码,也可以在一个Action执行前阻止 ...

随机推荐

  1. C#结构体+结构体与类的区别

    C# 结构(Struct) 在 C# 中,结构是值类型数据结构.它使得一个单一变量可以存储各种数据类型的相关数据.struct 关键字用于创建结构. C# 结构的特点 您已经用了一个简单的名为 Boo ...

  2. spring的依赖注入如何降低了耦合

    依赖注入:程序运行过程中,如需另一个对象协作(调用它的方法.访问他的属性时),无须在代码中创建被调用者,而是依赖于外部容器的注入 看过一些比较好的回答 1.一个人(Java实例,调用者)需要一把斧子( ...

  3. 常用JavaScript代码库（又名：WFang.js）

    1.根据公司项目封装ajax请求,结合layer框架一起使用 /*提取接口公共部分*/ var ApiConf = { server:"http://localhost:8080/Batte ...

  4. 网站开发综合技术 第二部分 CSS样式表

    第2部分 CSS样式表 CSS(Cascading Style Sheets,层叠样式表),作用是美化HTML网页. /*注释*/    注释语法 2.1.样式表的基本概念 2.1.1.样式表分类 1 ...

  5. 专题七：UDP编程补充——UDP广播程序的实现

    一.程序实现 UDP广播程序的实现代码: using System; using System.Net; using System.Net.Sockets; using System.Text; us ...

  6. Spring(二) -- 春风拂面之 核心 AOP

    ”万物皆对象“是面向对象编程思想OOP(Object Oriented Programming) 的最高境界.在面向对象中,我一直将自己(开发者)放在一个至高无上的位置上,可以操纵万物(对象),犹如一 ...

  7. Python之双色球选购和三级菜单问题

    1:双色球选购# 1 双色球(假设一共八个球,6个红球,球号1-32.2个蓝球,球号1-16)# 2 确保用户不能重复选择,不能超出范围# 3 用户输入有误时有相应的错误提示# 4 最后展示用户选择的 ...

  8. .Net实战之反射相关类之间的人体经络关系

    --1.类的部分组成成员 --2.巧记成员之间的关系 [MyTable("T_UserInfo")] public class UserInfo : Person, UserSer ...

  9. leetcode486 Predict the Winner

    思路: 博弈. 实现: class Solution { public: bool PredictTheWinner(vector<int>& nums) { ][]; int n ...

  10. 前端面试题HTML

    浏览器页面有哪三层构成,分别是什么,作用是什么?