【springboot】springboot 注解之 @Conditional

码农打工人

已于 2023-10-10 09:12:14 修改

阅读量1.2k

点赞数

分类专栏： springboot 文章标签： spring boot spring java

于 2023-03-30 14:34:49 首次发布

本文链接：https://blog.csdn.net/zzd13546036394/article/details/129757145

版权

springboot 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

前言
一、@Conditional
二、@Conditional 的实现子注解
三、@ConditionalOnClass 注解
四、@ConditionalOnMissingClass 注解
五、@ConditionalOnBean 与 @ConditionalOnMissingBean
六、@ConditionalOnProperty 注解
@ConditionalOnWebApplication

前言

conditional 这个英文单词翻译过来是有条件的，所以 @Conditional 注解是作为条件存在的，如果满足配置的条件则执行，如果没有满足的话就不执行。

一、@Conditional

@Conditional 注解上面说了是作为条件执行的，那么是作为什么条件呢？这我们就需要知道 @Conditional 主要是作用在什么上面。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

上面是 @Conditional 注解的源码。我们看到注解的作用域是类、方法上。既然是作用在类上，即可以大体猜测到与 IOC 容器添加 bean 有关系。
事实上 @Conditional 注解一般与 @Configuration、@Bean 共同使用，也可以与 @Controller、@Service、@Component、@Repository 等等这些注解一起使用。所以 @Conditional 通常是作为是否添加这个对象为 IOC 容器组件的条件出现的。
既然知道 @Conditional 注解的作用，那么该注解应该如何使用呢？我们看到该注解有一个必填的属性 value，value 属性的类型是 Condition 接口的实现类数组。我们看下 Condition 接口的源码。

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

Condition 接口只有一个抽象方法，返回 boolean 类型，可以知道返回为 true 则条件成立，返回 false 条件不成立。
方法中有两个参数，context 中包含容器、bean 工厂、类加载器、资源加载器、环境配置这五大核心属性获取方法，metadata 是注解的信息。
从这里我们也可以自己实现 matches 方法，去自定义一个条件类。
自己去实现 Condition 接口比较复杂，那么有没有一些已经实现好的常用的一些类呢？springboot 给我们提供了大量的这样的实现类，让我们基本不用自己去实现 Condition 接口，就可以满足日常的开发。

二、@Conditional 的实现子注解

springboot 提供了大量的 @Conditional 子注解供我们使用，我们只需知道有哪些常用的子注解供我们使用即可。
springboot 提供的 @Conditional 子注解有：

@ConditionalOnBean
@ConditionalOnClass
@ConditionalOnCloudPlatform
@ConditionalOnExpression
@ConditionalOnJava
@ConditionalOnJndi
@ConditionalOnMissingBean
@ConditionalOnMissingClass
@ConditionalOnNotWebApplication
@ConditionalOnProperty
@ConditionalOnResource
@ConditionalOnSingleCandidate
@ConditionalOnWarDeployment
@ConditionalOnWebApplication

这些子注解是如何实现的呢？我们以 @ConditionalOnBean 注解为例看下源码：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnBeanCondition.class})
public @interface ConditionalOnBean {
    Class<?>[] value() default {};

    String[] type() default {};

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

    String[] name() default {};

    SearchStrategy search() default SearchStrategy.ALL;

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

可以看到 OnBeanCondition 是 Condition 接口的具体实现类。
我们挑选一些日常常用的子注解做具体的说明。

三、@ConditionalOnClass 注解

@ConditionalOnClass 的意思是以是否有该类为为条件。我们以 springboot 自动配置 aop 的配置类做例子进行解读。
我们打开 springboot 的自动配置包 spring-boot-autoconfigure-2.7.0.jar 包，找到 AopAutoConfiguration.class，打开后有这么一段代码。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({Advice.class})
static class AspectJAutoProxyingConfiguration {
    AspectJAutoProxyingConfiguration() {
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @EnableAspectJAutoProxy(
        proxyTargetClass = true
    )
    @ConditionalOnProperty(
        prefix = "spring.aop",
        name = {"proxy-target-class"},
        havingValue = "true",
        matchIfMissing = true
    )
    static class CglibAutoProxyConfiguration {
        CglibAutoProxyConfiguration() {
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @EnableAspectJAutoProxy(
        proxyTargetClass = false
    )
    @ConditionalOnProperty(
        prefix = "spring.aop",
        name = {"proxy-target-class"},
        havingValue = "false"
    )
    static class JdkDynamicAutoProxyConfiguration {
        JdkDynamicAutoProxyConfiguration() {
        }
    }
}

我们看到在内部类 AspectJAutoProxyingConfiguration 上标注了 @ConditionalOnClass({Advice.class})
表示如果有 Advice.class 这个类则 AspectJAutoProxyingConfiguration 生效，否则就不生效。
那么我们测试以下。
首先我们测试以下没有的时候。

@SpringBootApplication
public class SpringbootFunctionApplication {

    public static void main(String[] args) {
        // 返回 IOC 容器
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootFunctionApplication.class, args);
        // 测试没有 Advice.class 的时候，是否有 AspectJAutoProxyingConfiguration 组件
        try {
            // 反射获取内部类的 Class 对象
            Class<?> clazz = Class.forName("org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$AspectJAutoProxyingConfiguration");
            System.out.println(MessageFormat.format("容器中 AspectJAutoProxyingConfiguration 类型的组件个数有：{0}", run.getBeanNamesForType(clazz).length));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

结果为：

容器中 AspectJAutoProxyingConfiguration 类型的组件个数有：0

可以看到如果没有 Advice.class 的时候，@ConditionalOnClass 标签做了拦截，没有添加 AspectJAutoProxyingConfiguration 为组件。
我们看下如果导入 Advice.class 之后会有什么现象。
我们在 pom 文件中导入 aspectj 依赖

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.19</version>
    <scope>runtime</scope>
</dependency>

最后执行我们看到的结果为：

容器中 AspectJAutoProxyingConfiguration 类型的组件个数有：1

可以看到有了 Advice.class 之后，在容器添加 AspectJAutoProxyingConfiguration 作为 bean 的时候，通过了 @ConditionalOnClass 的校验。

四、@ConditionalOnMissingClass 注解

我们说完了 @ConditionalOnClass，我们说一下它的相反意思的注解：@ConditionalOnMissingClass。
@ConditionalOnMissingClass 是如果没有这个 class 类则执行。我们同样以 springboot 自动配置 aop 的配置类做例子，不同的是我们选择了 AopAutoConfiguration.class 中的另一个内部类 ClassProxyingConfiguration。

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingClass({"org.aspectj.weaver.Advice"})
@ConditionalOnProperty(
    prefix = "spring.aop",
    name = {"proxy-target-class"},
    havingValue = "true",
    matchIfMissing = true
)
static class ClassProxyingConfiguration {
    ClassProxyingConfiguration() {
    }

    @Bean
    static BeanFactoryPostProcessor forceAutoProxyCreatorToUseClassProxying() {
        return (beanFactory) -> {
            if (beanFactory instanceof BeanDefinitionRegistry) {
                BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
                AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }

        };
    }
}

可以看到内部类 ClassProxyingConfiguration 上面标注了 @ConditionalOnMissingClass 标签，条件是 org.aspectj.weaver.Advice 字符串，代表没有该类则通过。
上面已经引入了 aspectjweaver jar 包，我们看看容器中有没有 ClassProxyingConfiguration 这个 bean。

@SpringBootApplication
public class SpringbootFunctionApplication {

    public static void main(String[] args) {
        // 返回 IOC 容器
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootFunctionApplication.class, args);
        // 测试有 Advice.class 的时候，是否有 ClassProxyingConfiguration 组件
        try {
            Class<?> clazz = Class.forName("org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration");
            System.out.println(MessageFormat.format("容器中 ClassProxyingConfiguration 类型的组件个数有：{0}", run.getBeanNamesForType(clazz).length));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

结果为：

容器中 ClassProxyingConfiguration 类型的组件个数有：0

可以看出有 Advice.class 的时候 @ConditionalOnMissingClass 注解会判断不通过，不会注册 ClassProxyingConfiguration 为 bean。
反过来如果没有 Advice.class 的时候会是什么样子呢？

容器中 ClassProxyingConfiguration 类型的组件个数有：1

五、@ConditionalOnBean 与 @ConditionalOnMissingBean

上面我们看了注解 @ConditionalOnClass、@ConditionalOnMissingClass，我们将要看的注解 @ConditionalOnBean 与 @ConditionalOnMissingBean 其实意思也是相似的，只不过前两个注解以是否有 class 类作为判断条件，后两个注解以容器中是否有组件 bean 作为判断条件。
我们看一个例子

@Bean
@ConditionalOnBean({MultipartResolver.class})
@ConditionalOnMissingBean(name = {"multipartResolver"})
public MultipartResolver multipartResolver(MultipartResolver resolver) {
    return resolver;
}

这里 @ConditionalOnBean({MultipartResolver.class}) 如果容器中有 MultipartResolver 类型的 bean 则条件通过。
@ConditionalOnMissingBean(name = {“multipartResolver”}) 则表示如果容器中没有 ID 为 multipartResolver 的 bean 则条件通过。
可以看出这段代码的功能是，如果容器中有 MultipartResolver 这个类型的 bean 但 ID 名称不是 multipartResolver，则把名称改为 multipartResolver。

六、@ConditionalOnProperty 注解

@ConditionalOnProperty 注解是以项目中的配置作为条件确定是否注册为 bean。
我们还是以 springboot 自动配置 aop 的配置类 AopAutoConfiguration.class 中的子类 AspectJAutoProxyingConfiguration 做例子进行解读。

static class AspectJAutoProxyingConfiguration {
        AspectJAutoProxyingConfiguration() {
        }

        @Configuration(
            proxyBeanMethods = false
        )
        @EnableAspectJAutoProxy(
            proxyTargetClass = true
        )
        @ConditionalOnProperty(
            prefix = "spring.aop",
            name = {"proxy-target-class"},
            havingValue = "true",
            matchIfMissing = true
        )
        static class CglibAutoProxyConfiguration {
            CglibAutoProxyConfiguration() {
            }
        }

        @Configuration(
            proxyBeanMethods = false
        )
        @EnableAspectJAutoProxy(
            proxyTargetClass = false
        )
        @ConditionalOnProperty(
            prefix = "spring.aop",
            name = {"proxy-target-class"},
            havingValue = "false"
        )
        static class JdkDynamicAutoProxyConfiguration {
            JdkDynamicAutoProxyConfiguration() {
            }
        }
    }

可以看到 @ConditionalOnProperty 注解具有4个属性 prefix（配置前缀）、name（配置名称）、havingValue（匹配的值）、matchIfMissing（如果找不到这个配置的值则返回）
在 AspectJAutoProxyingConfiguration 中有两个内部类 CglibAutoProxyConfiguration、JdkDynamicAutoProxyConfiguration。
CglibAutoProxyConfiguration 上面标注的注解 @ConditionalOnProperty 属性匹配的值为 true，如果没有该配置则默认通过。
JdkDynamicAutoProxyConfiguration 上面标注的注解 @ConditionalOnProperty 属性匹配的值为 false，没有 matchIfMissing 属性。
我们进行下面测试：

@SpringBootApplication(scanBasePackages = {"com.study.springbootfunction", "com.study.exclude"})
public class SpringbootFunctionApplication {

    public static void main(String[] args) {
        // 返回 IOC 容器
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootFunctionApplication.class, args);
        // 是否包含 CglibAutoProxyConfiguration、JdkDynamicAutoProxyConfiguration
        try {
            Class<?> a = Class.forName("org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$AspectJAutoProxyingConfiguration$CglibAutoProxyConfiguration");
            Class<?> j = Class.forName("org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$AspectJAutoProxyingConfiguration$JdkDynamicAutoProxyConfiguration");
            System.out.println(MessageFormat.format("容器中 CglibAutoProxyConfiguration 类型的组件个数有：{0}", run.getBeanNamesForType(a).length));
            System.out.println(MessageFormat.format("容器中 JdkDynamicAutoProxyConfiguration 类型的组件个数有：{0}", run.getBeanNamesForType(j).length));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

先不在项目中配置 spring.aop.proxy-target-class 运行结果为：

容器中 CglibAutoProxyConfiguration 类型的组件个数有：1
容器中 JdkDynamicAutoProxyConfiguration 类型的组件个数有：0

能够得出如果属性 matchIfMissing 不配置的话默认为 false。
在项目中配置 spring.aop.proxy-target-class=true

spring:
  aop:
    proxy-target-class: true

运行结果为：

容器中 CglibAutoProxyConfiguration 类型的组件个数有：1
容器中 JdkDynamicAutoProxyConfiguration 类型的组件个数有：0

如果在项目中配置 spring.aop.proxy-target-class=false

spring:
  aop:
    proxy-target-class: false

运行结果为：

容器中 CglibAutoProxyConfiguration 类型的组件个数有：0
容器中 JdkDynamicAutoProxyConfiguration 类型的组件个数有：1

可以看出 @ConditionalOnProperty 属性 havingValue 的值与项目中配置的值相匹配时为满足条件，如果值不匹配的时候则条件不满足。

@ConditionalOnWebApplication

如果是 web 应用，则满足条件。这个配置在 mvc 中的配置比较多，我们看下 mvc 中 DispatcherServlet 的自动配置类。

@AutoConfigureOrder(-2147483648)
@AutoConfiguration(
    after = {ServletWebServerFactoryAutoConfiguration.class}
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({DispatcherServlet.class})
public class DispatcherServletAutoConfiguration {
}

我们看到 DispatcherServletAutoConfiguration 在是 servlet 的传统项目中则成立，满足条件。

码农打工人

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【springboot】springboot 注解之 @Conditional

conditional 这个英文单词翻译过来是有条件的，所以 @Conditional 注解是作为条件存在的，如果满足配置的条件则执行，如果没有满足的话就不执行。
复制链接

扫一扫