开发者

SpringBoot自动装配Condition的实现

开发者 https://www.devze.com 2024-10-29 11:05 出处:网络 作者: 从零开始的-CodeNinja之路
目录一、前言二、 定义2.1 @Conditional2.2 Condition2.2.1 ConditionContext三、 使用说明3.1 创建项目3.1.1 导入依赖3.1.2 添加配置信息3.1.3 创建User类3.1.4 创建条件实现类3.1.5 修改启动类3.2 测试3.2.1 当use
目录
  • 一、前言
  • 二、 定义
    • 2.1 @Conditional
    • 2.2 Condition
      • 2.2.1 ConditionContext
  • 三、 使用说明
    • 3.1 创建项目
      • 3.1.1 导入依赖
      • 3.1.2 添加配置信息
      • 3.1.3 创建User类
      • 3.1.4 创建条件实现类
      • 3.1.5 修改启动类
    • 3.2 测试
      • 3.2.1 当user.enable=false
      • 3.2.2 当user.enable=true
    • 3.3 小结
    • 四、改进
      • 4.1 创建注解
        • 4.2 修改UserCondition
        • 五、 Spring内置条件注解

          一、前言

          @Conditional注解在Spring4.0中引入,其主要作用就是判断条件是否满足,从而决定是否初始化并向容器注册Bean。

          二、 定义

          2.1 @Conditional

          @Conditional注解定义如下:其内部只有一个参数为Class对象数组,且必须继承自Condition接口,通过重写Condition接口的matches方法来判断是否需要加载Bean

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

          2.2 Condition

          Condition接口定义如下:该接口为一个函数式接口,只有一个matches接口,形参为ConditionContext context, AnnotatedTypeMetadata metadata。ConditionContext定义如2.2.1,AnnotatedTypeMetadata见名知意,就是用来获取注解的元信息的

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

          2.2.1 ConditionContext

          ConditionContext接口定义如下:通过查看源码可以知道,从这个类中可以获取很多有用的信息

          public interface ConditionContext {
            /**
             * 返回Bean定义信息
             * Return the {@link BeanDefinitionRegistry} that will hold the bean definition
             * should the condition match.
             * @throws IllegalStateException if no registry is available (which is unusual:
             * only the case with a plain {@link ClassPathScanningCandidateComponentProvider})
             */
            BeanDefinitionRegistry getRegistry();
          
            /**
             * 返回Bean工厂
             * Return the {@link ConfigurableListableBeanFactory} that will hold the bean
             * definition should the condition match, or {@code null} if the bean factory is
             * not available (or not downcastable to {@code ConfigurableListableBeanFactory}).
             */
            @Nullable
            ConfigurableListableBeanFactory getBeanFactory();
          
            /**
             * 返回环境变量 比如在application.yaml中定义的信息
             * Return the {@link Environment} for which the current a编程客栈pplication is running.
             */
            Environment getEnvironment();
          
            /**
             * 返回资源加载器
             * Return the {@link ResourceLoader} currently being used.
             */
            ResourceLoader getResourceLoader();
          
            /**
             * 返回类加载器
             * Return the {@link ClassLoader} that should be used to load additional classes
             * (only {@code null} if even the system ClassLoader isn't Accessible).
             * @see org.springframework.util.ClassUtils#forName(String, ClassLoader)
             */
            @Nullable
            ClassLoader getClassLoader();
          }
          

          三、 使用说明

          通过一个简单的小例子测试一下@Conditional是不是真的能实现Bean的条件化注入。

          3.1 创建项目

          SpringBoot自动装配Condition的实现

          首先我们创建一个SpringBoot项目

          3.1.1 导入依赖

          这里我们除了springboot依赖,再添加个lombok依赖

          <?XML version="1.0" encoding="UTF-8"?>
          <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
              <modelVersion>4.0.0</modelVersion>
              <parent>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-parent</artifactId>
                  <version>2.5.3</version>
                  <relativePath/> <!-- lookup parent from repository -->
              </parent>
              <groupId>com.ldx</groupId>
              <artifactId>condition</artifactId>
              <version>0.0.1-SNAPSHOT</version>
              <name>condition</name>
              <description>Demo project for Spring Boot</description>
              <properties>
                  <Java.version>1.8</java.version>
              </properties>
              <dependencies>
                  <dependency>
                      <groupId>org.springframework.boot</groupId>
                      <artifactId>spring-boot-starter</artifactId>
                  </dependency>
                  <dependency>
                      <groupId>org.projectlombok</groupId>
                      <artifactId>lombok</artifactId>
                      <version>1.18.12</version>
                  </dependency>
              </dependencies>
              <build>
                  <plugins>
                      <plugin>
                          <groupId>org.springframework.boot</groupId>
                          <artifactId>spring-boot-maven-plugin</artifactId>
                      </plugin>
                  </plugins>
              </build>
          </project>
          

          3.1.2 添加配置信息

          在application.yaml 中加入配置信息

          user:
            enable: false
          

          3.1.3 创建User类

          package com.ldx.condition;
          
          import lombok.AllArgsConstructor;
          import lombok.Data;
          
          /**
           * 用户信息
           * @author ludangxin
           * @date 2021/8/1
           */
          @Data
          @AllArgsConstructor
          public class User {
             private String name;
             private Integer age;
          }
          

          3.1.4 创建条件实现类

          package com.ldx.condition;
          
          import org.springframework.context.annotation.Condition;
          import org.springframework.context.annotation.ConditionContext;
          import org.springframework.core.env.Environment;
          import org.springframework.core.type.AnnotatedTypeMetadata;
          
          /**
           * 用户bean条件判断
           * @author ludangxin
           * @date 2021/8/1
           */
          public class UserCondition implements Condition {
             @Override
             public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
                Environment environment = conditionContext.getEnvironment();
                // 获取property user.enable
                String property = environment.getProperty("user.enable");
                // 如果user.enable的值等于true 那么返回值为true,反之为false
                return "true".equals(property);
             }
          }
          

          3.1.5 修改启动类

          package com.ldx.condition;
          
          import lombok.extern.slf4j.Slf4j;
          import org.springframework.boot.SpringApplication;
          import org.springframework.boot.autoconfigure.SpringBootApplication;
          import org.springframework.context.ConfigurableApplicationContext;
          import org.springframework.context.annotation.Bean;
          import org.springframework.context.annotation.Conditional;
          
          @Slf4j
          @SpringBootApplication
          public class ConditionApplication {
          
             public static void main(String[] args) {
                ConfigurableApplicationContext applicationContext = SpringApplication.run(ConditionApplication.class, args);
                // 获取类型为User类的Bean
                User user = applicationContext.getBean(User.class);
                log.info("user bean === {}", user);
             }
          
            /**
             * 注入User类型的Bean
             */
             @Bean
             @Conditional(UserCondition.class)
             public User getUser(){
                return new User("张三",18);
             }
          
          }
          

          3.2 测试

          3.2.1 当user.enable=false

          报错找不到可用的User类型的Bean

            .   ____          _            __ _ _
           /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
          ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
           \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
            '  |____| .__|_| |_|_| |_\__, | / / / /
           =========|_|==============|___/=/_/_/_/
           :: Spring Boot ::                (v2.5.3)
          
          
          Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.ldx.condition.User' available
          	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.jpythonava:351)
          	at org.springframework.beans.factory.suphttp://www.devze.comport.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:342)
          	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1172)
          	at com.ldx.condition.ConditionApplication.main(ConditionApplication.java:16)
          
          Process finished with exit code 1
          

          3.2.2 当user.enable=true

          正常输出UserBean实例信息

            .   ____          _            __ _ _
           /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
          ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
           \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
            '  |____| .__|_| |_|_| |_\__, | / /编程客栈 / /
           =========|_|==============|___/=/_/_/_/
           :: Spring Boot ::                (v2.5.3)
          
          com.ldx.condition.ConditionApplication   : user bean === User(name=张三, age=18)
          

          3.3 小结

          上面的例子通过使用@Conditional和Condition接口,实现了spring bean的条件化注入。

          好处:

          • 可以实现某些配置的开关功能,如上面的例子,我们可以将UserBean换成开启缓存的配置,当property的值为true时,我们才开启缓存的配置

          • 当有多个同名的bean时,如何抉择的问题。

          • 实现自动化的装载。如判断当前classpath中有mysql的驱动类时(说明我们当前的系统需要使用mysql),我们就自动的读取application.yaml中的mysql配置,实现自动装载;当没有驱动时,就不加载。

          四、改进

          从上面的使用说明中我们了解到了条件注解的大概使用方法,但是代码中还是有很多硬编码的问题。比如:UserCondition中的property的key包括value都是硬编码,其实我们可以通过再扩展一个注解来实现动态的判断和绑定。

          4.1 创建注解

          import org.springframework.context.annotation.Conditional;
          import java.lang.annotation.*;
          
          /**
           * 自定义条件属性注解
           * <p>
           *   当配置的property name对应的值 与设置的 value值相等时,则注入bean
           * @author ludangxin
           * @date 2021/8/1
           */
          @Target({ElementType.TYPE, ElementType.METHOD})
          @Retention(RetentionPolicy.RUNTIME)
          @Documented
          // 指定condition的实现类
          @Conditional({UserCondition.class})
          public @interface MyConditionOnProperty {
             // 配置信息的key
             String name();
             // 配置信息key对应的值
             String value();
          }
          

          4.2 修改UserCondition

          package com.ldx.condition;
          
          import org.springframework.context.annotation.Condition;
          import org.springframework.context.annotation.ConditionContext;
          import org.springframework.core.env.Environment;
          import org.springframework.core.type.AnnotatedTypeMetadata;
          
          import java.util.Map;
          
          /**
           * 用户bean条件判断
           * @author ludangxin
           * @date 2021/8/1
           */
          public class UserCondition implements Condition {
             @Override
             public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
                Environment environment = conditionContext.getEnvironment();
                // 获取自定义的注解
                Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes("com.ldx.condition.MyConditionOnProperty");
                // 获取在注解中指定的name的property的值 如:user.enable的值
                String property = environment.getProperty(annotationAttributes.get("name").toString());
                // 获取预期的值
                String value = annotationAttributes.get("value").toString();
                return value.equals(property);
             }
          }
          

          测试后,结果符合预期。

          其实在spring中已经内置了许多常用的条件注解,其中我们刚实现的就在内置的注解中已经实现了,如下。

          五、 Spring内置条件注解

          注解 说明

          • @ConditionalOnSingleCandidate 当给定类型的bean存在并且指定为Primary的给定类型存在时,返回true
          • @ConditionalOnMissingBean 当给定的类型、类名、注解、昵称在beanFactory中不存在时返回true.各类型间是or的关系
          • @ConditionalOnBean 与上面相反,要求bean存
          • @ConditionalOnMissingClass 当给定的类名在类路径上不存在时返回true,各类型间是and的关系
          • @ConditionalOnClass 与上面相反,要求类存在
          • @ConditionalOnCloudPl编程客栈atform 当所配置的CloudPlatform为激活时返回true
          • @ConditionalOnExpression spel表达式执行为true
          • @ConditionalOnJava 运行时的java版本号是否包含给定的版本号.如果包含,返回匹配,否则,返回不匹配
          • @ConditionalOnProperty 要求配置属性匹配条件 @ConditionalOnJndi 给定的jndi的Location必须存在一个.否则,返回不匹配
          • @ConditionalOnNotWebApplication web环境不存在时
          • @ConditionalOnWebApplication web环境存在时
          • @ConditionalOnResource 要求制定的资源存在

          到此这篇关于 SpringBoot自动装配Condition的实现的文章就介绍到这了,更多相关 SpringBoot自动装配Condition内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)! 

          0

          精彩评论

          暂无评论...
          验证码 换一张
          取 消

          关注公众号