springboot注解之@Conditional使用解析_开发_开发者

前言

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() defauLrGrJENlt {};

    String[] name() default {};

    SearchStrategy search() default SearchStrategy.ALL;

    Class<?>[] parameterizedContaine编程客栈r() 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();
        }
    }

}

结果为：

容器中 ClassProxying编程Configuration 类型的组件个数有：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.print编程客栈ln(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 的传统项目中则成立，满足条件。

到此这篇关于springboot注解之@Conditionapythonl使用解析的文章就介绍到这了,更多相关springboot注解@Conditional内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！