Spring?@Conditional通過條件控制bean注冊過程

更新時(shí)間：2023年02月08日 10:16:28 作者：IT小馬哥

這篇文章主要為大家介紹了Spring?@Conditional通過條件控制bean注冊過程詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

Spring對配置類的處理主要分為2個(gè)階段

配置類解析階段

會(huì)得到一批配置類的信息，和一些需要注冊的bean

bean注冊階段

將配置類解析階段得到的配置類和需要注冊的bean注冊到spring容器中

看一下什么是配置類,類中有下面任意注解之一的就屬于配置類：

類上有@Compontent注解，@Configuration注解，@CompontentScan注解，@Import注解，@ImportResource注解以及類中有@Bean標(biāo)注的方法的都是配置類

判斷一個(gè)類是不是一個(gè)配置類，是否的是下面這個(gè)方法，有興趣的可以看一下：

org.springframework.context.annotation.ConfigurationClassUtils#isConfigurationCandidate

spring中處理這2個(gè)過程會(huì)循環(huán)進(jìn)行，直到完成所有配置類的解析及所有bean的注冊。

Spring對配置類處理過程

源碼位置

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

整個(gè)過程大致的過程

通常我們會(huì)通過new AnnotationConfigApplicationContext()傳入多個(gè)配置類來啟動(dòng)spring容器

spring對傳入的多個(gè)配置類進(jìn)行解析

配置類解析階段：這個(gè)過程就是處理配置類上面6中注解的過程，此過程中又會(huì)發(fā)現(xiàn)很多新的配置類，比如@Import導(dǎo)入的一批新的類剛好也符合配置類，而被@CompontentScan掃描到的一些類剛好也是配置類；此時(shí)會(huì)對這些新產(chǎn)生的配置類進(jìn)行同樣的過程解析

bean注冊階段：配置類解析后，會(huì)得到一批配置類和一批需要注冊的bean，此時(shí)spring容器會(huì)將這批配置類作為bean注冊到spring容器，同樣也會(huì)將這批需要注冊的bean注冊到spring容器

經(jīng)過上面第3個(gè)階段之后，spring容器中會(huì)注冊很多新的bean，這些新的bean中可能又有很多新的配置類

Spring從容器中將所有bean拿出來，遍歷一下，會(huì)過濾得到一批未處理的新的配置類，繼續(xù)交給第3步進(jìn)行處理

step3到step6，這個(gè)過程會(huì)經(jīng)歷很多次，直到完成所有配置類的解析和bean的注冊

從上面過程中可以了解到：

可以在配置類上面加上@Conditional注解，來控制是否需要解析這個(gè)配置類，配置類如果不被解析，那么這個(gè)配置上面6種注解的解析都會(huì)被跳過

可以在被注冊的bean上面加上@Conditional注解，來控制這個(gè)bean是否需要注冊到spring容器中

如果配置類不會(huì)被注冊到容器，那么這個(gè)配置類解析所產(chǎn)生的所有新的配置類及所產(chǎn)生的所有新的bean都不會(huì)被注冊到容器

一個(gè)配置類被spring處理有2個(gè)階段：配置類解析階段、bean注冊階段（將配置類作為bean被注冊到spring容器)。

如果將Condition接口的實(shí)現(xiàn)類作為配置類上@Conditional中，那么這個(gè)條件會(huì)對兩個(gè)階段都有效，此時(shí)通過Condition是無法精細(xì)的控制某個(gè)階段的，如果想控制某個(gè)階段，比如可以讓他解析，但是不能讓他注冊，此時(shí)就就需要用到另外一個(gè)接口了：ConfigurationCondition

ConfigurationCondition接口

相對于Condition接口多了一個(gè)getConfigurationPhase方法，用來指定條件判斷的階段，是在解析配置類的時(shí)候過濾還是在創(chuàng)建bean的時(shí)候過濾。

Conditional使用的3步驟

自定義一個(gè)類，實(shí)現(xiàn)Condition或ConfigurationCondition接口，實(shí)現(xiàn)matches方法

在目標(biāo)對象上使用@Conditional注解，并指定value的指為自定義的Condition類型

啟動(dòng)spring容器加載資源，此時(shí)@Conditional就會(huì)起作用了

阻止配置類的處理

在配置類上面使用@Conditional，這個(gè)注解的value指定的Condition當(dāng)有一個(gè)為false的時(shí)候，spring就會(huì)跳過處理這個(gè)配置類。

自定義一個(gè)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方法內(nèi)部我們可以隨意發(fā)揮，此處為了演示效果讀取的配置文件。

來個(gè)配置類，在配置類上面使用上面這個(gè)條件，此時(shí)會(huì)讓配置類失效，如下：

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標(biāo)注這restClient這個(gè)方法，如果這個(gè)配置類成功解析，會(huì)將restClient方法的返回值作為bean注冊到spring容器

bean不存在的時(shí)候才注冊

IService接口有兩個(gè)實(shí)現(xiàn)類Service1和Service1，這兩個(gè)類會(huì)放在2個(gè)配置類中通過@Bean的方式來注冊到容器，此時(shí)我們想加個(gè)限制，只允許有一個(gè)IService類型的bean被注冊到容器。

可以在@Bean標(biāo)注的2個(gè)方法上面加上條件限制，當(dāng)容器中不存在IService類型的bean時(shí)，才將這個(gè)方法定義的bean注冊到容器，下面來看代碼實(shí)現(xiàn)。

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&lt;String, IService&gt; serviceMap = beanFactory.getBeansOfType(IService.class);
        //判斷serviceMap是否為空
        return serviceMap.isEmpty();
    }

上面matches方法中會(huì)看容器中是否存在IService類型的bean，不存在的時(shí)候返回true

來一個(gè)配置類負(fù)責(zé)注冊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();
    }
}

再來一個(gè)配置類負(fù)責(zé)注冊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();
    }

來一個(gè)總的配置類，導(dǎo)入另外2個(gè)配置類

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

根據(jù)環(huán)境選擇配置類

平常我們做項(xiàng)目的時(shí)候，有開發(fā)環(huán)境、測試環(huán)境、線上環(huán)境，每個(gè)環(huán)境中有些信息是不一樣的，比如數(shù)據(jù)庫的配置信息，下面我們來模擬不同環(huán)境中使用不同的配置類來注冊不同的bean

自定義一個(gè)條件的注解

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 {
    //環(huán)境(測試環(huán)境、開發(fā)環(huán)境、生產(chǎn)環(huán)境)
    enum Env { //@2
        TEST, DEV, PROD
    }
    //環(huán)境
    Env value() default Env.DEV; //@3
}

@1：注意這個(gè)注解比較特別，這個(gè)注解上面使用到了@Conditional注解，這個(gè)地方使用到了一個(gè)自定義Conditione類：EnvCondition
@2：枚舉，表示環(huán)境，定義了3個(gè)環(huán)境
@3：這個(gè)參數(shù)用指定環(huán)境上面這個(gè)注解一會(huì)我們會(huì)用在不同環(huán)境的配置類上面

下面來3個(gè)配置類讓3個(gè)配置類分別在不同環(huán)境中生效，會(huì)在這些配置類上面使用上面自定義的@EnvConditional注解來做條件限定。

每個(gè)配置類中通過@Bean來定義一個(gè)名稱為name的bean，一會(huì)通過輸出這個(gè)bean來判斷哪個(gè)配置類生效了。

下面來看3個(gè)配置類的代碼

測試環(huán)境配置類

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 "我是測試環(huán)境!";
    }
}

@1指定的測試環(huán)境

開發(fā)環(huán)境配置類

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 "我是開發(fā)環(huán)境!";
    }
}

@1：指定的開發(fā)環(huán)境

生產(chǎn)環(huán)境配置類

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 "我是生產(chǎn)環(huán)境!";
    }
}

@1：指定的生產(chǎn)環(huán)境

下面來看一下條件類：EnvCondition

條件類會(huì)解析配置類上面@EnvConditional注解，得到環(huán)境信息。

然后和目前的環(huán)境對比，決定返回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) {
        //當(dāng)前需要使用的環(huán)境
        EnvConditional.Env curEnv = EnvConditional.Env.DEV; //@1
        //獲取使用條件的類上的EnvCondition注解中對應(yīng)的環(huán)境
        EnvConditional.Env env = (EnvConditional.Env) metadata.getAllAnnotationAttributes(EnvConditional.class.getName()).get("value").get(0);
        return env.equals(curEnv);
    }
}

@1：這個(gè)用來指定當(dāng)前使用的環(huán)境，此處假定當(dāng)前使用的是開發(fā)環(huán)境，這個(gè)我們以后可以任意發(fā)揮，比如將這些放到配置文件中，此處方便演示效果。

Condition指定優(yōu)先級(jí)

多個(gè)Condition按順序執(zhí)行 @Condtional中value指定多個(gè)Condtion的時(shí)候，默認(rèn)情況下會(huì)按順序執(zhí)行，還是通過代碼來看一下效果。

下面代碼中定義了3個(gè)Condition，每個(gè)Condition的matches方法中會(huì)輸出當(dāng)前類名，然后在配置類上面同時(shí)使用這3個(gè)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可以實(shí)現(xiàn)PriorityOrdered接口或者繼承Ordered接口，或者使用@Order注解，通過這些來指定這些Condition的優(yōu)先級(jí)。

排序規(guī)則：先按PriorityOrdered排序，然后按照order的值進(jìn)行排序；也就是：PriorityOrdered asc,order值 asc

下面這幾個(gè)都可以指定order的值接口：org.springframework.core.Ordered，有個(gè)getOrder方法用來返回int類型的值接口：org.springframework.core.PriorityOrdered，繼承了Ordered接口，所以也有g(shù)etOrder方法注解：org.springframework.core.annotation.Order，有個(gè)int類型的value參數(shù)指定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通過實(shí)現(xiàn)了Ordered接口來指定順序，
@3：getOrder方法返回1
@4：Condition3實(shí)現(xiàn)了PriorityOrdered接口，實(shí)現(xiàn)這個(gè)接口需要重寫getOrder方法，返回1000
@5：Condtion順序?yàn)?、2、3

ConfigurationCondition使用

ConfigurationCondition使用的比較少，很多地方對這個(gè)基本上也不會(huì)去介紹，Condition接口基本上可以滿足99%的需求了，但是springboot中卻大量用到了ConfigurationCondition這個(gè)接口。

ConfigurationCondition通過解釋比較難理解，來個(gè)案例感受一下：

來一個(gè)普通的類：Service

 public class Service {
}

來一個(gè)配置類，通過配置類注冊上面這個(gè)Service

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

再來一個(gè)配置類：BeanConfig2

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

來一個(gè)總的配置類

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

現(xiàn)在我們有個(gè)需求

當(dāng)容器中有Service這種類型的bean的時(shí)候，BeanConfig2才生效。

很簡單吧，加個(gè)Condition就行了，內(nèi)部判斷容器中是否有Service類型的bean，繼續(xù)

來個(gè)自定義的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";
    }
}

結(jié)果name永遠(yuǎn)注冊不上

為什么？在文章前面我們說過，配置類的處理會(huì)依次經(jīng)過2個(gè)階段：配置類解析階段和bean注冊階段，Condition接口類型的條件會(huì)對這兩個(gè)階段都有效，解析階段的時(shí)候，容器中是還沒有Service這個(gè)bean的，配置類中通過@Bean注解定義的bean在bean注冊階段才會(huì)被注冊到spring容器，所以BeanConfig2在解析階段去容器中是看不到Service這個(gè)bean的，所以就被拒絕了。

此時(shí)我們需要用到ConfigurationCondition了，讓條件判斷在bean注冊階段才起效。

自定義一個(gè)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注冊階段，這個(gè)條件才有效 matches方法中的內(nèi)容直接復(fù)制過來，判斷規(guī)則不變

修改BeanConfig2的類容

將
@Conditional(MyCondition1.class)
替換為
@Conditional(MyConfigurationCondition1.class)

此時(shí)name這個(gè)bean被注入了。

可以再試試將BeanConfig1中service方法上面的@Bean去掉，此時(shí)Service就不會(huì)被注冊到容器

判斷bean存不存在的問題，通常會(huì)使用ConfigurationCondition這個(gè)接口，階段為：REGISTER_BEAN，這樣可以確保條件判斷是在bean注冊階段執(zhí)行的。

對springboot比較熟悉的，它里面有很多@Conditionxxx這樣的注解，可以去看一下這些注解，很多都實(shí)現(xiàn)了ConfigurationCondition接口。

Spring中這塊的源碼 @Conditional注解是被下面這個(gè)類處理的

org.springframework.context.annotation.ConfigurationClassPostProcessor

總結(jié)

@Conditional注解可以標(biāo)注在spring需要處理的對象上（配置類、@Bean方法），相當(dāng)于加了個(gè)條件判斷，通過判斷的結(jié)果，讓spring覺得是否要繼續(xù)處理被這個(gè)注解標(biāo)注的對象

spring處理配置類大致有2個(gè)過程：解析配置類、注冊bean，這兩個(gè)過程中都可以使用@Conditional來進(jìn)行控制spring是否需要處理這個(gè)過程

Condition默認(rèn)會(huì)對2個(gè)過程都有效

ConfigurationCondition控制得更細(xì)一些，可以控制到具體那個(gè)階段使用條件判斷

以上就是Spring @Conditional通過條件控制bean注冊過程的詳細(xì)內(nèi)容，更多關(guān)于Spring @Conditional控制bean注冊的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章:

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片