SpringBoot @ConditionalOnBean、@ConditionalOnMissingBean注解源码分析与示例

最新推荐文章于 2024-09-05 11:21:29 发布
最新推荐文章于 2024-09-05 11:21:29 发布
阅读量650 收藏 3
点赞数
分类专栏： java springboot
原文链接：https://blog.csdn.net/xcy1193068639/article/details/81517456
版权

前言：

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

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

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

@Configuration
public class BeanConfig {
 
    @Bean(name = "notebookPC")
    public Computer computer1(){
        return new Computer("笔记本电脑");
    }
 
    @ConditionalOnMissingBean(Computer.class)
    @Bean("reservePC")
    public Computer computer2(){
        return new Computer("备用电脑");
    }
}

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

一探究竟：
首先，来看@ConditionalOnMissingBean的声明：

//可以标注在类和方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
//使用了@Conditional注解，条件类是OnBeanCondition
@Conditional({OnBeanCondition.class})
public @interface ConditionalOnMissingBean {
    Class<?>[] value() default {};
 
    String[] type() default {};
 
    Class<?>[] ignored() default {};
 
    String[] ignoredType() default {};
 
    Class<? extends Annotation>[] annotation() default {};
 
    String[] name() default {};
 
    SearchStrategy search() default SearchStrategy.ALL;
}

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

OnBeanCondition类的声明：

//定义带注释的组件的排序顺序，2147483647即为默认值
@Order(2147483647)
class OnBeanCondition extends SpringBootCondition implements ConfigurationCondition {

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

public ConfigurationPhase getConfigurationPhase() {
    return ConfigurationPhase.REGISTER_BEAN;
}

就从matches方法开始：

  //SpringBootCondition类中的matches方法
    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取当前的类名或者方法名（由标注的位置决定）
        String classOrMethodName = getClassOrMethodName(metadata);
 
        try {
            //关键代码：这里就会判断出结果
            ConditionOutcome outcome = this.getMatchOutcome(context, metadata);
            //存入日志
            this.logOutcome(classOrMethodName, outcome);
            //存入记录
            this.recordEvaluation(context, classOrMethodName, outcome);
            //最后返回ConditionOutcome的isMatch就是返回boolean类型结果
            return outcome.isMatch();
        } catch (NoClassDefFoundError var5) {
            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);
        } catch (RuntimeException var6) {
            throw new IllegalStateException("Error processing condition on " + this.getName(metadata), var6);
        }
    }

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

  /**
     * 获得判断结果的方法，ConditionOutcome类中存着boolean类型的结果
     */
    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
	//返回一个新的ConditionMessage
        ConditionMessage matchMessage = ConditionMessage.empty();
        OnBeanCondition.BeanSearchSpec spec;
        List matching;
        //这是metadata会调用isAnnotated方法判断当前标注的注解是不是ConditionalOnMissingBean
	//其实@ConditionalOnBean、@ConditionalOnMissingBean和@ConditionalOnSingleCandidate都是使用这个条件类，所以这里做判断
        if (metadata.isAnnotated(ConditionalOnBean.class.getName())) {
            spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnBean.class);
            matching = this.getMatchingBeans(context, spec);
            if (matching.isEmpty()) {
                return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnBean.class, new Object[]{spec}).didNotFind("any beans").atAll());
            }
 
            matchMessage = matchMessage.andCondition(ConditionalOnBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching);
        }
 
        if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {
            OnBeanCondition.BeanSearchSpec spec = new OnBeanCondition.SingleCandidateBeanSearchSpec(context, metadata, ConditionalOnSingleCandidate.class);
            matching = this.getMatchingBeans(context, spec);
            if (matching.isEmpty()) {
                return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).didNotFind("any beans").atAll());
            }
 
            if (!this.hasSingleAutowireCandidate(context.getBeanFactory(), matching, spec.getStrategy() == SearchStrategy.ALL)) {
                return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).didNotFind("a primary bean from beans").items(Style.QUOTE, matching));
            }
 
            matchMessage = matchMessage.andCondition(ConditionalOnSingleCandidate.class, new Object[]{spec}).found("a primary bean from beans").items(Style.QUOTE, matching);
        }
 
        //如果当前注入的bean是@ConditionalOnMissingBean
        if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
            //返回一个spec（说明），这里的spec规定了搜索的内容，比如搜索策略、需要搜索的类名......
            spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnMissingBean.class);
            //主要的搜索实现在这个方法里，最后返回一个list
            matching = this.getMatchingBeans(context, spec);
            //判断搜索出来的结果
            if (!matching.isEmpty()) {
                return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching));
            }
 
            matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, new Object[]{spec}).didNotFind("any beans").atAll();
        }
 
        return ConditionOutcome.match(matchMessage);
    }

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

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

BeanSearchSpec(ConditionContext context, AnnotatedTypeMetadata metadata, Class<?> annotationType) {
        this.annotationType = annotationType;
        MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(annotationType.getName(), true);
        //将attributes这个map中的数据放到对应的list成员变量中
        this.collect(attributes, "name", this.names);
        this.collect(attributes, "value", this.types);
        this.collect(attributes, "type", this.types);
        this.collect(attributes, "annotation", this.annotations);
        this.collect(attributes, "ignored", this.ignoredTypes);
        this.collect(attributes, "ignoredType", this.ignoredTypes);
        this.strategy = (SearchStrategy)metadata.getAnnotationAttributes(annotationType.getName()).get("search");
        OnBeanCondition.BeanTypeDeductionException deductionException = null;
 
        try {
            if (this.types.isEmpty() && this.names.isEmpty()) {
                this.addDeducedBeanType(context, metadata, this.types);
            }
        } catch (OnBeanCondition.BeanTypeDeductionException var7) {
            deductionException = var7;
        }
 
        this.validate(deductionException);
    }
 
    //验证的方法
    protected void validate(OnBeanCondition.BeanTypeDeductionException ex) {
        if (!this.hasAtLeastOne(this.types, this.names, this.annotations)) {
            String message = this.annotationName() + " did not specify a bean using type, name or annotation";
            if (ex == null) {
                throw new IllegalStateException(message);
            } else {
                throw new IllegalStateException(message + " and the attempt to deduce the bean's type failed", ex);
            }
        }
    }

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

    private List<String> getMatchingBeans(ConditionContext context, OnBeanCondition.BeanSearchSpec beans) {
        //获得当前bean工厂
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //判断当前的搜索策略是否是PARENTS或者ANCESTORS，默认是ALL
        if (beans.getStrategy() == SearchStrategy.PARENTS || beans.getStrategy() == SearchStrategy.ANCESTORS) {
            BeanFactory parent = beanFactory.getParentBeanFactory();
            Assert.isInstanceOf(ConfigurableListableBeanFactory.class, parent, "Unable to use SearchStrategy.PARENTS");
            //如果是PARENTS或者ANCESTORS，当前bean工厂就用父工厂
            beanFactory = (ConfigurableListableBeanFactory)parent;
        }
 
        if (beanFactory == null) {
            return Collections.emptyList();
        } else {
            List<String> beanNames = new ArrayList();
            //如果当前搜索策略等于CURRENT，为true
            boolean considerHierarchy = beans.getStrategy() != SearchStrategy.CURRENT;
            //这里的type就是需要查找的bean的类型
            //下面，会从属性中找bean
            Iterator var6 = beans.getTypes().iterator();
 
            String beanName;
            while(var6.hasNext()) {
                beanName = (String)var6.next();
                //如果找到了类型，接下来就是根据类型找bean的实例名，找示例名的方法在下方，实际上就是一个getNamesForType
                beanNames.addAll(this.getBeanNamesForType(beanFactory, beanName, context.getClassLoader(), considerHierarchy));
            }
 
            var6 = beans.getIgnoredTypes().iterator();
 
            while(var6.hasNext()) {
                beanName = (String)var6.next();
                beanNames.removeAll(this.getBeanNamesForType(beanFactory, beanName, context.getClassLoader(), considerHierarchy));
            }
 
            var6 = beans.getAnnotations().iterator();
 
            while(var6.hasNext()) {
                beanName = (String)var6.next();
                beanNames.addAll(Arrays.asList(this.getBeanNamesForAnnotation(beanFactory, beanName, context.getClassLoader(), considerHierarchy)));
            }
 
            var6 = beans.getNames().iterator();
 
            while(var6.hasNext()) {
                beanName = (String)var6.next();
                if (this.containsBean(beanFactory, beanName, considerHierarchy)) {
                    beanNames.add(beanName);
                }
            }
            //将存放bean实例名的list返回
            return beanNames;
        }
    }
 
 
 
    //根据类型获取bean的name
    private Collection<String> getBeanNamesForType(ListableBeanFactory beanFactory, String type, ClassLoader classLoader, boolean considerHierarchy) throws LinkageError {
        try {
            Set<String> result = new LinkedHashSet();
            this.collectBeanNamesForType(result, beanFactory, ClassUtils.forName(type, classLoader), considerHierarchy);
            return result;
        } catch (ClassNotFoundException var6) {
            return Collections.emptySet();
        } catch (NoClassDefFoundError var7) {
            return Collections.emptySet();
        }
    }
 
    private void collectBeanNamesForType(Set<String> result, ListableBeanFactory beanFactory, Class<?> type, boolean considerHierarchy) {
        result.addAll(BeanTypeRegistry.get(beanFactory).getNamesForType(type));
        if (considerHierarchy && beanFactory instanceof HierarchicalBeanFactory) {
            BeanFactory parent = ((HierarchicalBeanFactory)beanFactory).getParentBeanFactory();
            if (parent instanceof ListableBeanFactory) {
                this.collectBeanNamesForType(result, (ListableBeanFactory)parent, type, considerHierarchy);
            }
        }
 
    }

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

//如果当前注入的bean是@ConditionalOnMissingBean
    if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
        //返回一个spec（说明），这里的spec规定了搜索的内容，比如搜索策略、需要搜索的类名......
        spec = new OnBeanCondition.BeanSearchSpec(context, metadata, ConditionalOnMissingBean.class);
        matching = this.getMatchingBeans(context, spec);
        if (!matching.isEmpty()) {
            return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingBean.class, new Object[]{spec}).found("bean", "beans").items(Style.QUOTE, matching));
        }
 
        matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, new Object[]{spec}).didNotFind("any beans").atAll();
    }

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

/**
 * 过滤结果类
 */
public class ConditionOutcome {
	/**
	 * 匹配结果 true or false
	 */
    private final boolean match;
	/**
	 * 匹配结果信息
	 */
    private final ConditionMessage message;

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

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

例子：
@ConditionalOnBean(javax.sql.DataSource.class)
Spring容器或者所有父容器中需要存在至少一个javax.sql.DataSource类的实例

江湖人称黑哥
关注
专栏目录
springboot~@ConditionalOnMissingBean一切为了可扩展性
m0_66876551的博客
04-27 815
@ConditionalOnMissingBean在很多spring框架里都得到很广泛的应用，如spring-boot-starter-security，spring-cloud-starter-oauth2中的应用。 注意@ConditionalOnMissingBean这种注解需要添加在@Bean上面，而不是添加到@Service，@Component等上面。 主要是根本的使用方法，而本篇主要阐述它在可扩展性上的应用，通过一个例子来说明问题，以讲故事的方式来阐述给大家听： 从前，有一个接口，它提供.
SpringBoot自定义自动装配与Conditional失效问题
|-| [- |_ |_ ()
08-01 1905
文章目录前言自动装配规则类命名规则package命名规则jar包构建规则jar包结构jar包取名构建自定义的自动装配@ConditionOnBean失效问题为何非自动装配的配置会失效？为何自动装配的配置就有效？ 前言 参考书籍《SpringBoot编程思想》— 小马哥mercyblitz 此书是难得的讲述SpringBoot的一本好书，由Spring的注解发展史介绍到Spring的注解驱动，以一...
@ConditionalOnMissingBean注解的使用
最新发布
峰晨的博客
09-05 251
@ConditionalOnMissingBean注解
SpringBoot --- @ConditionalOnMissingBean
百世经纶『一页書』
04-04 1386
SpringBoot --- @ConditionalOnMissingBean1.错误代码2.正确代码3.意义 @ConditionalOnMissingBean 它是修饰bean的一个注解，主要实现的是，当你的bean被注册之后，如果再注册相同类型的bean，就不会成功 1.错误代码 //错误代码，会报警，重复注入AMapper @Component public class AutoConfig { @Bean public AConfig aConfig() {
@ConditionalOnMissingBean注解理解
dichengyan0013的博客
12-14 4189
@ConditionalOnMissingBean注解作用在@bean定义上，它的作用就是在容器加载它作用的bean时，检查容器中是否存在目标类型（ConditionalOnMissingBean注解的value值）的bean了，如果存在这跳过原始bean的BeanDefinition加载动作。 转载于:https://www.cnblogs.com/shamo89/p/78501...
@ConditionalOn...注解，条件组合你知道吗？
热门推荐
日拱一兵
07-31 1万+
上一篇文章你应该知道的 @ConfigurationProperties 注解的使用姿势，这一篇就够了介绍了如何通过@ConfigurationProperties...
springboot之三：原理分析之自动配置condition
09-06
这些文件可能包含了示例代码或者Spring Boot自动配置的相关源码，可以帮助我们更深入地理解条件判断如何工作，以及如何自定义条件注解来适应特定的场景。 在实际开发中，我们可以利用这些条件注解来实现细粒度的...
SpringBoot 理论总结
许诗宇的博客
03-06 863
目录 讲述一下 SpringBoot 自动装配原理？ 前言 什么是 SpringBoot 自动装配？ SpringBoot 是如何实现自动装配的？ @EnableAutoConfiguration:实现自动装配的核心注解 AutoConfigurationImportSelector:加载自动装配类 如何实现一个 Starter 总结 注意：本文参考 docs/system-design/framework/spring/spring-boot-auto-assembly-princ
SpringBoot 入门及两大特性分析
qq_22651103的博客
03-02 2026
SpringBoot 入门及两大特性分析 0 前言 Spring从诞生之初，基于最核心的依赖注入（DI）和面向切面编程（AOP），实现了重量级EJB的功能，虽然说Spring是一个轻量级的框架（和EJB相比），但是配置却“重量级”，Spring 从最初版本的XML配置 -&amp;gt; Spring2.5 的基于注解的组件扫描（component-scan） -&amp;gt; Spring3.0 的基于 J...
springboot @ConditionalOnMissingBean注解的作用详解
08-18
主要介绍了springboot @ConditionalOnMissingBean注解的作用详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
@ConditionalOnBean、@ConditionalOnMissingBean
weixin_43719015的博客
09-08 177
SpringBoot @ConditionalOnBean、@ConditionalOnMissingBean注解源码分析与示例 SpringBoot2 | 条件注解 @ConditionalOnBean 原理源码分析（七）
《SpringBoot源码分析》@ConditionalOnBean
WormholeStack
12-05 411
由示例引出本文的主角 首先新建两个Pojo，分别是People和Company /** * @description： People * @Author MRyan * @Date 2020/12/5 14:20 * @Version 1.0 */ @Data @ToString @NoArgsConstructor @AllArgsConstructor public class People { /** * 姓名 */ private String nam
@ConditionalOnBean、@ConditionalOnMissingBean、@ConditionalOnClass
weixiaohuai的博客
07-31 1889
是 Spring Boot 中的一个条件注解，用于在 Spring 容器中存在指定类型的 Bean 时才会生效。这个注解通常用于在某个 Bean 存在的前提下才加载另外一些相关的配置或 Bean，以实现根据已有的 Bean 进行条件化加载其他配置或 Bean。它可以帮助实现依赖于其他 Bean 存在与否的功能。
@ConditionalOnMissingBean
chiyiji9177的博客
07-22 1144
该注解表示，如果存在它修饰的类的bean，则不需要再创建这个bean； 可以给该注解传入参数例如@ConditionOnMissingBean(name = "example")， 这个表示如果name为“example”的bean存在，这该注解修饰的代码块不执行。 @Bean ...
@ConditionalOnBean 与@ConditionalOnMissingBean
09-13
@ConditionalOnBean和@ConditionalOnMissingBean注解都是Spring框架中的条件注解，用于在配置类中根据特定条件来决定是否创建某个Bean。 @ConditionalOnBean注解的作用是：只有当容器中存在指定的Bean时，才会创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值