Spring @Conditional通过条件控制bean注册过程

作者:IT小马哥 时间:2023-08-06 10:00:11 

Spring对配置类的处理主要分为2个阶段

配置类解析阶段

会得到一批配置类的信息,和一些需要注册的bean

bean注册阶段

将配置类解析阶段得到的配置类和需要注册的bean注册到spring容器中

看一下什么是配置类,类中有下面任意注解之一的就属于配置类:

类上有@Compontent注解,@Configuration注解,@CompontentScan注解,@Import注解,@ImportResource注解以及类中有@Bean标注的方法 的都是配置类

判断一个类是不是一个配置类,是否的是下面这个方法,有兴趣的可以看一下:

org.springframework.context.annotation.ConfigurationClassUtils#isConfigurationCandidate

spring中处理这2个过程会循环进行,直到完成所有配置类的解析及所有bean的注册。

Spring对配置类处理过程

源码位置

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

整个过程大致的过程

通常我们会通过new AnnotationConfigApplicationContext()传入多个配置类来启动spring容器

spring对传入的多个配置类进行解析

配置类解析阶段:这个过程就是处理配置类上面6中注解的过程,此过程中又会发现很多新的配置类,比如@Import导入的一批新的类刚好也符合配置类,而被@CompontentScan扫描到的一些类刚好也是配置类;此时会对这些新产生的配置类进行同样的过程解析

bean注册阶段:配置类解析后,会得到一批配置类和一批需要注册的bean,此时spring容器会将这批配置类作为bean注册到spring容器,同样也会将这批需要注册的bean注册到spring容器

经过上面第3个阶段之后,spring容器中会注册很多新的bean,这些新的bean中可能又有很多新的配置类

Spring从容器中将所有bean拿出来,遍历一下,会过滤得到一批未处理的新的配置类,继续交给第3步进行处理

step3到step6,这个过程会经历很多次,直到完成所有配置类的解析和bean的注册

从上面过程中可以了解到:

可以在配置类上面加上@Conditional注解,来控制是否需要解析这个配置类,配置类如果不被解析,那么这个配置上面6种注解的解析都会被跳过

可以在被注册的bean上面加上@Conditional注解,来控制这个bean是否需要注册到spring容器中

如果配置类不会被注册到容器,那么这个配置类解析所产生的所有新的配置类及所产生的所有新的bean都不会被注册到容器

一个配置类被spring处理有2个阶段:配置类解析阶段、bean注册阶段(将配置类作为bean被注册到spring容器)。

如果将Condition接口的实现类作为配置类上@Conditional中,那么这个条件会对两个阶段都有效,此时通过Condition是无法精细的控制某个阶段的,如果想控制某个阶段,比如可以让他解析,但是不能让他注册,此时就就需要用到另外一个接口了:ConfigurationCondition

ConfigurationCondition接口

相对于Condition接口多了一个getConfigurationPhase方法,用来指定条件判断的阶段,是在解析配置类的时候过滤还是在创建bean的时候过滤。

Conditional使用的3步骤

自定义一个类,实现Condition或ConfigurationCondition接口,实现matches方法

在目标对象上使用@Conditional注解,并指定value的指为自定义的Condition类型

启动spring容器加载资源,此时@Conditional就会起作用了

阻止配置类的处理

在配置类上面使用@Conditional,这个注解的value指定的Condition当有一个为false的时候,spring就会跳过处理这个配置类。

自定义一个Condition类:

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
* 自定义控制器
*
* @author maruifu
* @date 2022-12-07
*/
@Configuration
public class DslLogCondition implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       // 读取配置文件application.yml中 spring.elasticsearch.dslLog: true 配置
       YamlPropertiesFactoryBean y=new YamlPropertiesFactoryBean();
       y.setResources(new ClassPathResource("application.yml"));
       return (Boolean) y.getObject().get("spring.elasticsearch.dslLog");
    }
}

matches方法内部我们可以随意发挥,此处为了演示效果读取的配置文件。

来个配置类,在配置类上面使用上面这个条件,此时会让配置类失效,如下:

import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
/**
* 用于打印dsl语句
*/
@Configuration
public class EsConfig {
   @Value("${spring.elasticsearch.rest.uris}")
   private String elasticsearchHost;
   @Conditional(DslLogCondition.class)
   @Bean(destroyMethod = "close")
   public RestHighLevelClient restClient() {
       ClientConfiguration clientConfiguration = ClientConfiguration.builder().connectedTo(elasticsearchHost).build();
       RestHighLevelClient client = RestClients.create(clientConfiguration).rest();
        return client;
   }
}

1:使用了自定义的条件类

2:通过@Bean标注这restClient这个方法,如果这个配置类成功解析,会将restClient方法的返回值作为bean注册到spring容器

bean不存在的时候才注册

IService接口有两个实现类Service1和Service1,这两个类会放在2个配置类中通过@Bean的方式来注册到容器,此时我们想加个限制,只允许有一个IService类型的bean被注册到容器。

可以在@Bean标注的2个方法上面加上条件限制,当容器中不存在IService类型的bean时,才将这个方法定义的bean注册到容器,下面来看代码实现。

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.ConfigurationCondition;
import org.springframework.core.type.AnnotatedTypeMetadata;
import java.util.Map;
public class OnMissingBeanCondition implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       //获取bean工厂
       ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
       //从容器中获取IService类型bean
       Map<String, IService> serviceMap = beanFactory.getBeansOfType(IService.class);
       //判断serviceMap是否为空
       return serviceMap.isEmpty();
   }

上面matches方法中会看容器中是否存在IService类型的bean,不存在的时候返回true

来一个配置类负责注册Service1到容器

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig1 {
   @Conditional(OnMissingBeanCondition.class) //@1
   @Bean
   public IService service1() {
       return new Service1();
   }
}

再来一个配置类负责注册Service2到容器

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig2 {
   @Conditional(OnMissingBeanCondition.class)//@1
   @Bean
   public IService service2() {
       return new Service2();
   }

来一个总的配置类,导入另外2个配置类

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import({BeanConfig1.class,BeanConfig2.class})
public class MainConfig {
}

根据环境选择配置类

平常我们做项目的时候,有开发环境、测试环境、线上环境,每个环境中有些信息是不一样的,比如数据库的配置信息,下面我们来模拟不同环境中使用不同的配置类来注册不同的bean

自定义一个条件的注解

import org.springframework.context.annotation.Conditional;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Conditional(EnvCondition.class) //@1
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnvConditional {
   //环境(测试环境、开发环境、生产环境)
   enum Env { //@2
       TEST, DEV, PROD
   }
   //环境
   Env value() default Env.DEV; //@3
}
  • @1:注意这个注解比较特别,这个注解上面使用到了@Conditional注解,这个地方使用到了一个自定义Conditione类:EnvCondition

  • @2:枚举,表示环境,定义了3个环境

  • @3:这个参数用指定环境 上面这个注解一会我们会用在不同环境的配置类上面

下面来3个配置类 让3个配置类分别在不同环境中生效,会在这些配置类上面使用上面自定义的@EnvConditional注解来做条件限定。

每个配置类中通过@Bean来定义一个名称为name的bean,一会通过输出这个bean来判断哪个配置类生效了。

下面来看3个配置类的代码

测试环境配置类

package com.javacode2018.lesson001.demo25.test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnvConditional(EnvConditional.Env.TEST)//@1
public class TestBeanConfig {
   @Bean
   public String name() {
       return "我是测试环境!";
   }
}
  • @1指定的测试环境

开发环境配置类

package com.javacode2018.lesson001.demo25.test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnvConditional(EnvConditional.Env.DEV) //@1
public class DevBeanConfig {
   @Bean
   public String name() {
       return "我是开发环境!";
   }
}
  • @1:指定的开发环境

生产环境配置类

package com.javacode2018.lesson001.demo25.test2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnvConditional(EnvConditional.Env.PROD) //@1
public class ProdBeanConfig {
   @Bean
   public String name() {
       return "我是生产环境!";
   }
}
  • @1:指定的生产环境

下面来看一下条件类:EnvCondition

条件类会解析配置类上面@EnvConditional注解,得到环境信息。

然后和目前的环境对比,决定返回true还是false,如下:

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class EnvCondition implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       //当前需要使用的环境
       EnvConditional.Env curEnv = EnvConditional.Env.DEV; //@1
       //获取使用条件的类上的EnvCondition注解中对应的环境
       EnvConditional.Env env = (EnvConditional.Env) metadata.getAllAnnotationAttributes(EnvConditional.class.getName()).get("value").get(0);
       return env.equals(curEnv);
   }
}

@1:这个用来指定当前使用的环境,此处假定当前使用的是开发环境,这个我们以后可以任意发挥,比如将这些放到配置文件中,此处方便演示效果。

Condition指定优先级

多个Condition按顺序执行 @Condtional中value指定多个Condtion的时候,默认情况下会按顺序执行,还是通过代码来看一下效果。

下面代码中定义了3个Condition,每个Condition的matches方法中会输出当前类名,然后在配置类上面同时使用这3个Condition

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.AnnotatedTypeMetadata;
class Condition1 implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
}
class Condition2 implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
}
class Condition3 implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
}
@Configuration
@Conditional({Condition1.class, Condition2.class, Condition3.class})
public class MainConfig5 {
}

指定Condition的顺序 自定义的Condition可以实现PriorityOrdered接口或者继承Ordered接口,或者使用@Order注解,通过这些来指定这些Condition的优先级。

排序规则:先按PriorityOrdered排序,然后按照order的值进行排序;也就是:PriorityOrdered asc,order值 asc

下面这几个都可以指定order的值 接口:org.springframework.core.Ordered,有个getOrder方法用来返回int类型的值 接口:org.springframework.core.PriorityOrdered,继承了Ordered接口,所以也有getOrder方法 注解:org.springframework.core.annotation.Order,有个int类型的value参数指定Order的大小

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.annotation.Order;
import org.springframework.core.type.AnnotatedTypeMetadata;
@Order(1) //@1
class Condition1 implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
}
class Condition2 implements Condition, Ordered { //@2
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
   @Override
   public int getOrder() { //@3
       return 0;
   }
}
class Condition3 implements Condition, PriorityOrdered { //@4
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       System.out.println(this.getClass().getName());
       return true;
   }
   @Override
   public int getOrder() {
       return 1000;
   }
}
@Configuration
@Conditional({Condition1.class, Condition2.class, Condition3.class})//@5
public class MainConfig6 {
}
  • @1:Condition1通过@Order指定顺序,值为1

  • @2:Condition2通过实现了Ordered接口来指定顺序,

  • @3:getOrder方法返回1

  • @4:Condition3实现了PriorityOrdered接口,实现这个接口需要重写getOrder方法,返回1000

  • @5:Condtion顺序为1、2、3

ConfigurationCondition使用

ConfigurationCondition使用的比较少,很多地方对这个基本上也不会去介绍,Condition接口基本上可以满足99%的需求了,但是springboot中却大量用到了ConfigurationCondition这个接口。

ConfigurationCondition通过解释比较难理解,来个案例感受一下:

来一个普通的类:Service

public class Service {
}

来一个配置类,通过配置类注册上面这个Service

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig1 {
   @Bean
   public Service service() {
       return new Service();
   }
}

再来一个配置类:BeanConfig2

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfig2 {
   @Bean
   public String name() {
       return "路人甲Java";
   }
}

来一个总的配置类

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import({BeanConfig1.class, BeanConfig2.class})
public class MainConfig7 {
}

现在我们有个需求

当容器中有Service这种类型的bean的时候,BeanConfig2才生效。

很简单吧,加个Condition就行了,内部判断容器中是否有Service类型的bean,继续

来个自定义的Condition

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class MyCondition1 implements Condition {
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       //获取spring容器
       ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
       //判断容器中是否存在Service类型的bean
       boolean existsService = !beanFactory.getBeansOfType(Service.class).isEmpty();
       return existsService;
   }
}

上面代码很简单,判断容器中是否有IService类型的bean。

@Configuration
@Conditional(MyCondition1.class)
public class BeanConfig2 {
   @Bean
   public String name() {
       return "路人甲Java";
   }
}

结果name永远注册不上

为什么? 在文章前面我们说过,配置类的处理会依次经过2个阶段:配置类解析阶段和bean注册阶段,Condition接口类型的条件会对这两个阶段都有效,解析阶段的时候,容器中是还没有Service这个bean的,配置类中通过@Bean注解定义的bean在bean注册阶段才会被注册到spring容器,所以BeanConfig2在解析阶段去容器中是看不到Service这个bean的,所以就被拒绝了。

此时我们需要用到ConfigurationCondition了,让条件判断在bean注册阶段才起效。

自定义一个ConfigurationCondition类

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.ConfigurationCondition;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class MyConfigurationCondition1 implements ConfigurationCondition {
   @Override
   public ConfigurationPhase getConfigurationPhase() {
       return ConfigurationPhase.REGISTER_BEAN; //@1
   }
   @Override
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       //获取spring容器
       ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
       //判断容器中是否存在Service类型的bean
       boolean existsService = !beanFactory.getBeansOfType(Service.class).isEmpty();
       return existsService;
   }
}
  • @1:指定条件在bean注册阶段,这个条件才有效 matches方法中的内容直接复制过来,判断规则不变

修改BeanConfig2的类容


@Conditional(MyCondition1.class)
替换为
@Conditional(MyConfigurationCondition1.class)

此时name这个bean被注入了。

可以再试试将BeanConfig1中service方法上面的@Bean去掉,此时Service就不会被注册到容器

判断bean存不存在的问题,通常会使用ConfigurationCondition这个接口,阶段为:REGISTER_BEAN,这样可以确保条件判断是在bean注册阶段执行的。

对springboot比较熟悉的,它里面有很多@Conditionxxx这样的注解,可以去看一下这些注解,很多都实现了ConfigurationCondition接口。

Spring中这块的源码 @Conditional注解是被下面这个类处理的

org.springframework.context.annotation.ConfigurationClassPostProcessor

来源:https://cloud.tencent.com/developer/article/2198818?areaSource=104001.4&traceId=fC4WkNkYiIo8FIE7FXUF8

标签:Spring,@Conditional,bean,条件控制,注册
0
投稿

猜你喜欢

  • C# 重写ComboBox实现下拉任意组件的方法

    2022-01-24 03:07:29
  • Android互联网访问图片并在客户端显示的方法

    2021-12-26 21:25:10
  • 从dubbo zookeeper注册地址提取出zookeeper地址的方法

    2023-04-29 18:51:16
  • java贪吃蛇游戏编写代码

    2023-06-16 02:41:10
  • Java进阶:Struts多模块的技巧

    2023-06-18 09:40:47
  • Android使用CircleImageView实现圆形头像的方法

    2022-04-08 19:06:34
  • Android实现的仿淘宝购物车demo示例

    2023-09-04 08:59:19
  • Dwr3.0纯注解(纯Java Code配置)配置与应用浅析一之零配置文件化

    2022-06-05 05:20:17
  • 聊聊Controller中RequestMapping的作用

    2021-12-08 20:48:45
  • Java几个实例带你进阶升华下篇

    2021-06-11 01:19:46
  • 如何完成spring的最小化XML配置

    2022-02-12 11:33:58
  • Java实现滑动验证码生成(后端工具类)

    2022-02-07 01:26:37
  • Android使用Intent.ACTION_SEND分享图片和文字内容的示例代码

    2023-12-17 02:57:28
  • C#画笔使用复合数组绘制单个矩形的方法

    2022-03-20 01:41:09
  • Java操作redis设置第二天凌晨过期的解决方案

    2022-11-15 11:40:10
  • C语言中下标与指针的转换以及指向指针的指针的例子

    2023-05-15 23:46:49
  • springboot使用redisRepository和redistemplate操作redis的过程解析

    2023-10-11 06:57:03
  • Android仿微信之界面导航篇(1)

    2022-07-06 06:59:50
  • Java实现人机猜拳游戏

    2023-10-16 08:47:56
  • C#判断日期是否到期的方法

    2021-09-10 14:40:00
  • asp之家 软件编程 m.aspxhome.com