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

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

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

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

配置類解析階段

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

bean注冊階段

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

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

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

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

org.springframework.context.annotation.ConfigurationClassUtils#isConfigurationCandidate

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

Spring對配置類處理過程

源碼位置

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

整個過程大致的過程

通常我們會通過new AnnotationConfigApplicationContext()傳入多個配置類來啟動spring容器

spring對傳入的多個配置類進行解析

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

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

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

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

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

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

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

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

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

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

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

ConfigurationCondition接口

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

Conditional使用的3步驟

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

來個配置類，在配置類上面使用上面這個條件，此時會讓配置類失效，如下：

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接口有兩個實現(xiàn)類Service1和Service1，這兩個類會放在2個配置類中通過@Bean的方式來注冊到容器，此時我們想加個限制，只允許有一個IService類型的bean被注冊到容器。

可以在@Bean標注的2個方法上面加上條件限制，當容器中不存在IService類型的bean時，才將這個方法定義的bean注冊到容器，下面來看代碼實現(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方法中會看容器中是否存在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 {
}

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

平常我們做項目的時候，有開發(fā)環(huán)境、測試環(huán)境、線上環(huán)境，每個環(huán)境中有些信息是不一樣的，比如數(shù)據(jù)庫的配置信息，下面我們來模擬不同環(huán)境中使用不同的配置類來注冊不同的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 {
    //環(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：注意這個注解比較特別，這個注解上面使用到了@Conditional注解，這個地方使用到了一個自定義Conditione類：EnvCondition
@2：枚舉，表示環(huán)境，定義了3個環(huán)境
@3：這個參數(shù)用指定環(huán)境上面這個注解一會我們會用在不同環(huán)境的配置類上面

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

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

下面來看3個配置類的代碼

測試環(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

條件類會解析配置類上面@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) {
        //當前需要使用的環(huán)境
        EnvConditional.Env curEnv = EnvConditional.Env.DEV; //@1
        //獲取使用條件的類上的EnvCondition注解中對應的環(huán)境
        EnvConditional.Env env = (EnvConditional.Env) metadata.getAllAnnotationAttributes(EnvConditional.class.getName()).get("value").get(0);
        return env.equals(curEnv);
    }
}

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

Condition指定優(yōu)先級

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

下面代碼中定義了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可以實現(xiàn)PriorityOrdered接口或者繼承Ordered接口，或者使用@Order注解，通過這些來指定這些Condition的優(yōu)先級。

排序規(guī)則：先按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參數(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通過實現(xiàn)了Ordered接口來指定順序，
@3：getOrder方法返回1
@4：Condition3實現(xiàn)了PriorityOrdered接口，實現(xiàn)這個接口需要重寫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 {
}

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

當容器中有Service這種類型的bean的時候，BeanConfig2才生效。

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

來個自定義的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永遠注冊不上

為什么？在文章前面我們說過，配置類的處理會依次經(jīng)過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方法中的內(nèi)容直接復制過來，判斷規(guī)則不變

修改BeanConfig2的類容

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

此時name這個bean被注入了。

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

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

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

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

org.springframework.context.annotation.ConfigurationClassPostProcessor

總結

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

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

Condition默認會對2個過程都有效

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

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

您可能感興趣的文章:

SpringBoot單元測試沒有執(zhí)行的按鈕問題及解決
這篇文章主要介紹了SpringBoot單元測試沒有執(zhí)行的按鈕問題及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2022-01-01
Springboot 整合 Java DL4J 實現(xiàn)農(nóng)產(chǎn)品質量檢測系統(tǒng)(推薦)
本文詳細介紹了系統(tǒng)的搭建過程,包括技術選型、數(shù)據(jù)處理、模型訓練和評估等關鍵步驟,系統(tǒng)采用卷積神經(jīng)網(wǎng)絡,對水果成熟度和缺陷進行識別,有效解決了傳統(tǒng)方法成本高、效率低的問題,有助于提升農(nóng)產(chǎn)品檢測的科技含量和自動化水平
2024-10-10
JAVA多線程Thread和Runnable的實現(xiàn)
java中實現(xiàn)多線程有兩種方法：一種是繼承Thread類，另一種是實現(xiàn)Runnable接口。
2013-03-03
利用java反射機制調用類的私有方法(推薦)
下面小編就為大家?guī)硪黄胘ava反射機制調用類的私有方法(推薦)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2016-08-08
Java反射如何獲取字段屬性值
這篇文章主要介紹了Java反射如何獲取字段屬性值，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2022-07-07
Java 多線程并發(fā)AbstractQueuedSynchronizer詳情
這篇文章主要介紹了Java 多線程并發(fā)AbstractQueuedSynchronizer詳情，文章圍繞主題展開想象的內(nèi)容介紹，具有一定的參考價值，感興趣的小伙伴可以參考一下
2022-06-06
java獲取本地文件的多種方式實現(xiàn)與比較
這篇文章主要為大家詳細介紹了java獲取本地文件的多種方式實現(xiàn)與結果比較,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
2023-11-11
Java的Flowable工作流之加簽轉簽詳解
這篇文章主要介紹了Java的Flowable工作流之加簽轉簽詳解,Flowable是一個開源的工作流引擎,它提供了一套強大的工具和功能,用于設計、執(zhí)行和管理各種類型的工作流程,需要的朋友可以參考下
2023-11-11
Idea中maven項目實現(xiàn)登錄驗證碼功能
這篇文章主要介紹了Idea中maven項目實現(xiàn)登錄驗證碼功能,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2020-12-12
詳解如何在SpringBoot項目中使用全局異常處理
在完整的項目開發(fā)中，異常的出現(xiàn)幾乎是無法避免的；如果凡是有可能出現(xiàn)異常的地方，我們都手動的使用try-catch將其捕獲的話，會使得代碼顯得十分臃腫并且后期不好維護。本文介紹了pringBoot項目中使用全局異常處理的方法，需要的可以參考一下
2022-10-10