Springboot中的@Conditional注解详解

更新时间：2023年09月25日 08:45:29 作者：怪咖@

这篇文章主要介绍了Springboot中的@Conditional注解详解,@Conditional来源于spring-context包下的一个注解,Conditional中文是条件的意思,@Conditional注解它的作用是按照一定的条件进行判断,满足条件给容器注册bean,需要的朋友可以参考下

一、@Conditional源码

@Conditional 来源于 spring-context 包下的一个注解。Conditional中文是条件的意思，@Conditional注解它的作用是按照一定的条件进行判断，满足条件给容器注册bean。

通过他的注解内部可以发现，他就是一个纯功能性注解，他并没有依赖于其他注解，类上只有三个元注解。

@Target({ElementType.TYPE, ElementType.METHOD}) 使用范围接口、类、枚举、注解、方法
@Retention(RetentionPolicy.RUNTIME)： @Retention是用来修饰注解的生命周期的，RetentionPolicy.RUNTIME代表的是不仅被保存到class文件中，jvm加载class文件之后，仍然存在；一直有效！
@Documented： @Documented和@Deprecated注解长得有点像，@Deprecated是用来标注某个类或者方法不建议再继续使用，@Documented只能用在注解上，如果一个注解@B，被@Documented标注，那么被@B修饰的类，生成Javadoc文档时，会显示@B。

package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

@Conditional 只有一个参数，并且这个参数要求是继承与 Condition 类，并且参数是个数组，也就是可以传多个的。 Condition 类是一个函数式接口（只有一个方法的接口被称为函数式接口）。 matches 方法就是比较方法，如果为 true 则注入，如果为 false 则不注入。

@FunctionalInterface
public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

二、@Conditional扩展注解

而除了@Conditional注解外，springboot通过@Conditional注解又扩展了很多注解出来，如下@ConditionalOnBean、@ConditionalOnClass等等…

在这里插入图片描述

三、@Conditional实战

（1）自定义Condition实现类

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String isOpen = environment.getProperty("systemLog.isOpen");
        // 就算没有设置systemLog.isOpen，那么isOpen就等于null，Boolean.valueOf对于null照样会返回false的
        return Boolean.valueOf(isOpen);
    }
}

（2）自定义一个实体类，用于测试

public class TestBean1 {
    @Override
    public String toString() {
        return super.toString() + "--我是TestBean1";
    }
}

（3）添加配置类，并在类上使用@Conditional

@Configuration
@Conditional(MyCondition.class)
public class Myconfig {
    @Bean
    public TestBean1 testBean1(){
        return new TestBean1();
    }
}

（4）添加测试类

@RestController
public class CommonController {
    @Autowired(required = false)
    private Myconfig myconfig;
	@Autowired(required = false)
    private TestBean1 testBean1;
    @RequestMapping("/import")
    public void printImportBeanInfo() {
        System.out.println(myconfig);
        System.out.println(testBean1);
    }
}

（5）启动测试：访问 //localhost:8080/import ，可见Myconfig类并没有注入到容器，按正常来说被@Configuration修饰之后是会存放到容器当中的，但是显然因为@Conditional判断为false所以没有注入到容器当中。

在这里插入图片描述

通过这个测试不难发现假如@Bean所在的类没有注入到容器当中，那么他也不会被注入到容器当中。

（6）在 application.yml 当中添加如下配置，然后再启动测试。

systemLog:
  isOpen: true

在这里插入图片描述

（7）@Conditional还可以应用于方法上，我们可以让他和@Bean注解来配合使用

@Configuration
public class Myconfig {
    @Bean
    @Conditional(MyCondition.class)
    public TestBean1 testBean1(){
        return new TestBean1();
    }
}

四、@Conditional多条件

前言中说，@Conditional注解传入的是一个Class数组，存在多种条件类的情况。

这种情况貌似判断难度加深了，测试一波，新增新的条件类，实现的 matches 返回 false （这种写死返回false的方法纯属测试用，没有实际意义O(∩_∩)O）

public class ObstinateCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
         return false;
    }
}

@Configuration
@Conditional({MyCondition.class,ObstinateCondition.class})
public class Myconfig {
    @Bean
    public TestBean1 testBean1(){
        return new TestBean1();
    }
}

测试结果得知：

第一个条件类实现的方法返回true，第二个返回false，则结果false，不注入进容器。
第一个条件类实现的方法返回true，第二个返回true，则结果true，注入进容器中。

五、常见的扩展注解

关于这些扩展注解其实在官网源码当中是有注释的，感兴趣的可以看一下：

5.1.@ConditionalOnClass

主要是判断是否存在这个类文件，如果有这个文件就相当于满足条件，然后可以注入到容器当中。

当然并不是说容器里面是否有这个类哈，不要理解错了，这也就是我们有时候使用springboot只需要引入个依赖，框架就可以用的原因！

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnClass {
	// 必须出现的类
    Class<?>[] value() default {};
	// 必须存在的类名，必须是全限类名，也就是包含包名+类名。
    String[] name() default {};
}

用法示例：

@Configuration
@ConditionalOnClass({TestBean2.class})
public class Myconfig {
    @Bean
    @ConditionalOnClass(name = "com.gzl.cn.springbootcache.config.TestBean3")
    public TestBean1 testBean1(){
        return new TestBean1();
    }
}

5.2.@ConditionalOnMissingClass

@ConditionalOnMissingClass 只有一个 value 属性。他和 @ConditionalOnClass 功能正好相反，@ConditionalOnClass是class存在为true，而@ConditionalOnMissingClass是不存在为true，也就是存在为false。为fasle就意味着不注入。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnMissingClass {
	// 必须不存在的类名称，全类名
    String[] value() default {};
}

@ConditionalOnMissingClass("com.gzl.cn.springbootcache.config.TestBean5")

或者

@ConditionalOnMissingClass(value = "com.gzl.cn.springbootcache.config.TestBean5")

5.3.@ConditionalOnBean

bean存在的时候注入，不存在的时候不注入，这块就是指的spring的ioc容器了。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnBeanCondition.class})
public @interface ConditionalOnBean {
	// 指定bean的类类型。当所有指定类的bean都包含在容器中时，条件匹配。
    Class<?>[] value() default {};
	// 指定bean的全类名。当指定的所有类的bean都包含在容器中时，条件匹配。
    String[] type() default {};
	// bean所声明的注解,当ApplicationContext中存在声明该注解的bean时返回true
    Class<? extends Annotation>[] annotation() default {};
	// bean的id,当ApplicationContext中存在给定id的bean时返回true,这个id指的就是容器当中对象的id
    String[] name() default {};
	// 搜索容器层级,默认是所有上下文搜索
    SearchStrategy search() default SearchStrategy.ALL;
	// 可能在其泛型参数中包含指定bean类型的其他类
    Class<?>[] parameterizedContainer() default {};
}

（1）代码示例：假如我把testBean2方法删掉，那么testBean1也将会不注入。

@Configuration
public class Myconfig {
    @Bean
    public TestBean2 testBean2(){
        return new TestBean2();
    }
    @Bean
    @ConditionalOnBean(TestBean2.class)
    public TestBean1 testBean1() {
        return new TestBean1();
    }
}

（2）测试类

@RestController
public class CommonController {
    @Autowired(required = false)
    private TestBean1 testBean1;
    @Autowired(required = false)
    private TestBean2 testBean2;
    @Autowired(required = false)
    private Myconfig myconfig;
    @RequestMapping("/import")
    public void printImportBeanInfo() {
        System.out.println(myconfig);
        System.out.println(testBean1);
        System.out.println(testBean2);
    }
}

（3）运行输出结果：会发现三个对象是都注入到容器当中了。

（4）目前存在的问题

注意这里还存在一个执行顺序问题，假如我把以下代码放到启动类当中，而不是 Myconfig 配置文件当中，这时候会发现一个问题，testBean2注入进去了，但是带有 @ConditionalOnBean(TestBean2.class) 条件的 testBean1 没有注入进去。原因其实很简单，执行 testBean1 的时候，testBean2并没有注入进去，然后testBean1就注入失败了，紧接着失败后testBean2又注入进来了。

@Bean
public TestBean2 testBean2(){
    return new TestBean2();
}

（5）紧接着我又做了个试验，把启动类当中的testBean2删掉了，又创建了如下一个配置类，但是testBean1还是注入失败。

@Configuration
public class MyconfigTest {
    @Bean
    public TestBean2 testBean2(){
        return new TestBean2();
    }
}

（6）想要解决这个问题很简单，想办法让 MyconfigTest 比 Myconfig 先加载就可以了

于是我在MyconfigTest 添加了如下order注解

@Order(Ordered.HIGHEST_PRECEDENCE) //最高优先级

然后在Myconfig 也添加了Order注解

@Order(Ordered.LOWEST_PRECEDENCE) //最低优先级

但是仍然没有解决该问题。@Configuration并不能通过@Order指定顺序。

（7）大胆猜测下： @Configuration通过配置类名的自然顺序来加载的。

在这里插入图片描述

将MyconfigTest改名字：还别说改完名字真的就可以了！

在这里插入图片描述

（8）不可能每次遇到这种问题都改名字吧，经查文档，终于找到了需要的东西：我们可以通过@AutoConfigureBefore,@AutoConfigureAfter来控制配置类的加载顺序。

在MyconfigTest类上添加 @AutoConfigureBefore(Myconfig.class) ，意思是在Myconfig实例化之前加载。如果要让@AutoConfigureBefore生效，还需要在META-INF/spring.factories文件中添加如下内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.gzl.cn.springbootcache.config.MyconfigTest,\
com.gzl.cn.springbootcache.config.Myconfig

在这里插入图片描述

最终成功解决哈！

5.4.@ConditionalOnMissingBean

bean不存在的时候注入，存在的时候为false。跟@ConditionalOnBean正好是相反的。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnBeanCondition.class})
public @interface ConditionalOnMissingBean {
    Class<?>[] value() default {};
    String[] type() default {};
	// 识别匹配 bean 时，可以被忽略的 bean 的 class 类型
    Class<?>[] ignored() default {};
	//识别匹配 bean 时，可以被忽略的 bean 的 class 类型名称
    String[] ignoredType() default {};
    Class<? extends Annotation>[] annotation() default {};
    String[] name() default {};
    SearchStrategy search() default SearchStrategy.ALL;
    Class<?>[] parameterizedContainer() default {};
}

@ConditionalOnMissingBean 代表的是如果容器里面没有 TestBean1 的实例，那么就运行@Bean修饰的方法注入对象，不管注入的什么对象。

@Configuration
public class Myconfig {
    @Bean
    @ConditionalOnMissingBean(TestBean1.class)
    public TestBean1 testBean1() {
        return new TestBean1();
    }
}

注意： @ConditionalOnMissingBean 和 @ConditionalOnBean 使用的时候是可以不带任何属性的，不带任何属性的时候他就是判断的当前注入的类型。@ConditionalOnBean是判断当没有的时候进行注入，例如如下：他只会注入一个TestBean1进去。

@Configuration
public class Myconfig {
    @Bean
    @ConditionalOnMissingBean
    public TestBean1 testBean1() {
        System.out.println("1111111111");
        return new TestBean1();
    }
    @Bean
    @ConditionalOnMissingBean
    public TestBean1 testBean2() {
        System.out.println("2_222_222_222");
        return new TestBean1();
    }
}

5.5.@ConditionalOnProperty

@ConditionalOnProperty 主要可用于通过和 springboot 当中 application 配置文件来使用。在实战当中我们也可以通过他来实现配置化管理bean。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional({OnPropertyCondition.class})
public @interface ConditionalOnProperty {
	// 指定的属性完整名称，不能和name同时使用。
    String[] value() default {};
	// //配置文件中属性的前缀
    String prefix() default "";
	// //指定的属性名称
    String[] name() default {};
	// 指定的属性的属性值要等于该指定值，当value或name为一个时使用
    String havingValue() default "";
	// 当不匹配时是否允许加载，当为true时就算不匹配也不影响bean的注入或配置类的生效。
    boolean matchIfMissing() default false;
}

使用示例：

@Configuration
@ConditionalOnProperty(
        prefix = "system.log",
        name = {"open"},
        havingValue = "true",
        matchIfMissing = false
)
public class Myconfig {
    @Bean
    public TestBean1 testBean1() {
        return new TestBean1();
    }
}

然后只要在application添加如下配置，Myconfig和testBean1就会注入到容器当中。如果不设置也不会报错，只是注入不到容器里而已。

system:
  log:
    open: true

5.6.其他注解

@ConditionalOnJava：只有运行指定版本的 Java 才会加载 Bean
@ConditionalOnWebApplication 和 @ConditionalOnNotWebApplication：只有运行在(不在)web 应用里才会加载这个 bean
@ConditionalOnCloudPlatform：只有运行在指定的云平台上才加载指定的 bean
@ConditionalOnJndi：只有指定的资源通过 JNDI 加载后才加载 bean
@ConditionalOnExpression(“${test.express}==true”) ：可通过spring提供的spEL表达式灵活配置，当表达式为true的时候，才会实例化一个Bean
@ConditionalOnSingleCandidate(UserService.class) ：表示ioc容器中只有一个UserService类型的Bean，才生效
@ConditionalOnResource：指定的静态资源⽂件存在才加载

六、总结

在这里插入图片描述

到此这篇关于Springboot中的@Conditional注解详解的文章就介绍到这了,更多相关@Conditional注解内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java实现MD5加密的方式与实例代码
MD5加密是一种常见的加密方式，我们经常用在保存用户密码和关键信息上。那么它到底有什么，又什么好处呢，会被这么广泛的运用在应用开发中
2021-10-10
Spring开发核心之AOP的实现与切入点持久化
面向对象编程是一种编程方式，此编程方式的落地需要使用“类”和 “对象”来实现，所以，面向对象编程其实就是对 “类”和“对象” 的使用，面向切面编程，简单的说，就是动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程
2022-10-10
告诉你springboot各个文件夹的作用
这篇文章主要介绍了springboot各个文件夹是干嘛的,本文通过截图实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-08-08
比较java中Future与FutureTask之间的关系
在本篇文章里我们给大家分享了java中Future与FutureTask之间的关系的内容，有需要的朋友们可以跟着学习下。
2018-10-10
解决报错:java:读取jar包时出错:error in opening zip
文章总结：解决Java读取jar包时出错的问题,通过下载源码并刷新项目解决了问题,希望对大家有所帮助
2024-11-11
关于ScheduledThreadPoolExecutor不执行的原因分析
这篇文章主要介绍了关于ScheduledThreadPoolExecutor不执行的原因分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-08-08
Java8新特性:函数式编程
Java8最新引入函数式编程概念，该项技术可以大大提升编码效率，本文会对涉及的对象等进行两种方法的对比，对新技术更直白的看到变化，更方便学习
2021-06-06
Java的SPI机制以及基于SPI编程示例详解
这篇文章主要为大家介绍了Java的SPI机制以及基于SPI编程示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-08-08
Java编程long数据类型的使用问题
这篇文章主要介绍了Java编程数据类型long的使用问题，涉及长整型数据的取值范围和不同整数类型的表示方法,需要的朋友可以参考下
2017-09-09
mybatis plus or and 的合并写法实例
这篇文章主要介绍了mybatis plus or and 的合并写法实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-02-02