Spring Boot中的那些條件判斷

時間  2019-12-05
標籤 spring boot 那些 條件 判斷 欄目 Spring 简体版
原文   原文鏈接

Spring Boot中的那些Conditional

spring boot中爲咱們提供了豐富的Conditional來讓咱們得以很是方便的在項目中向容器中添加Bean。本文主要是對各個註解進行解釋並輔以代碼說明其用途。java

全部ConditionalOnXXX的註解均可以放置在class或是method上，若是方式在class上，則會決定該class中全部的@Bean註解方法是否執行。web

@Conditional

下面其餘的Conditional註解均是語法糖，能夠經過下面的方法自定義ConditionalOnXXX
Conditional註解定義以下，接收實現Condition接口的class數組。spring

public @interface Conditional {
    Class<? extends Condition>[] value();
}

而Condition接口只有一個matchs方法，返回是否匹配的結果。數組

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

經過操做系統進行條件判斷，從而進行Bean配置。當Window時，實例化Bill的Person對象，當Linux時，實例化Linus的Person對象。app

//LinuxCondition,爲方便起見，去掉判斷代碼，直接返回true了
public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return true;
    }
}
//WindowsCondition,爲方便起見，去掉判斷代碼，直接返回false了
public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
        return false;
    }
}
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
}
//配置類
@Configuration
public class BeanConfig {

    @Bean(name = "bill")
    @Conditional({WindowsCondition.class})
    public Person person1(){
        return new Person("Bill Gates",62);
    }

    @Bean("linus")
    @Conditional({LinuxCondition.class})
    public Person person2(){
        return new Person("Linus",48);
    }
}
public class AppTest {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);

    @Test
    public void test(){
        String osName = applicationContext.getEnvironment().getProperty("os.name");
        System.out.println("當前系統爲：" + osName);
        Map<String, Person> map = applicationContext.getBeansOfType(Person.class);
        System.out.println(map);
    }
}

輸出的結果：ide

當前系統爲：Mac OS X
{linus=Person(name=Linus, age=48)}

@ConditionalOnBean & @ConditionalOnMissingBean

這兩個註解會對Bean容器中的Bean對象進行判斷，使用的例子是配置的時候，若是發現若是沒有Computer實例，則實例化一個備用電腦。測試

@Data
@AllArgsConstructor
@ToString
public class Computer {
    private String name;
}
@Configuration
public class BeanConfig {
    @Bean(name = "notebookPC")
    public Computer computer1(){
        return new Computer("筆記本電腦");
    }

    @ConditionalOnMissingBean(Computer.class)
    @Bean("reservePC")
    public Computer computer2(){
        return new Computer("備用電腦");
    }
}
public class TestApp {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
    @Test
    public void test1(){
        Map<String,Computer> map = applicationContext.getBeansOfType(Computer.class);
        System.out.println(map);
    }
}

修改BeanConfig,若是註釋掉第一個@Bean,會實例化備用電腦，不然就不會實例化備用電腦spa

@ConditionalOnClass & @ConditionalOnMissingClass

這個註解會判斷類路徑上是否有指定的類，一開始看到的時候比較困惑，類路徑上若是沒有指定的class,那編譯也經過不了啊...這個主要用於集成相同功能的第三方組件時用，只要類路徑上有該組件的類，就進行自動配置，好比spring boot web在自動配置視圖組件時，是用Velocity，仍是Thymeleaf,或是freemaker時，使用的就是這種方式。
例子是兩套盔甲A(光明套裝)和B(暗黑套裝)，若是A不在則配置B。操作系統

public interface Fighter {
    void fight();
}
public class FighterA implements Fighter {
    @Override
    public void fight() {
        System.out.println("使用光明套裝");
    }
}
public class FighterB implements Fighter {
    @Override
    public void fight() {
        System.out.println("使用暗黑套裝");
    }
}

Van是武士，使用套裝進行戰鬥code

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Van {
    private Fighter fighter;
    public void fight(){
        fighter.fight();
    }
}

VanConfigA/B實例化武士

@Configuration
@ConditionalOnClass({FighterA.class})
public class VanConfigA {
    @Primary
    @Bean
    public Van vanA(){
        return new Van(new FighterA());
    }
}
@Configuration
@ConditionalOnClass({FighterB.class})
public class VanConfigB {
    @Bean
    public Van vanB(){
        return new Van(new FighterB());
    }
}

測試類,默認狀況，若是套裝AB都在類路徑上，兩套都會加載，A會設置爲PRIMARY，若是在target class中將FightA.class刪除，則只會加載套裝B。

@SpringBootApplication
public class TestApp implements CommandLineRunner {
    @Autowired
    private Van van;
    public static void main(String[] args) {
        SpringApplication.run(TestApp.class, args);
    }
    @Override
    public void run(String... args) throws Exception {
        //do something
       van.fight();
    }
}

另外，嘗試將兩個VanConfigA/B合併，將註解ConditionalOnClass放到方法上，若是刪除一個套裝就會運行出錯。

@ConditionalOnExpress

依據表達式進行條件判斷，這個做用和@ConditionalOnProperty大部分狀況能夠通用，表達式更靈活一點,由於可使用SpEL。例子中會判斷properties中test.enabled的值進行判斷。BeanConfig分別對布爾，字符串和數字三種類型進行判斷。數字嘗試了不少其餘的方式均不行，好比直接使用==，貌似配置的屬性都會當成字符串來處理。

@Data
public class TestBean {
    private String name;
}
@Configuration
@ConditionalOnExpression("#{${test.enabled:true} }")
//@ConditionalOnExpression("'zz'.equalsIgnoreCase('${test.name2}')")
//@ConditionalOnExpression("new Integer('${test.account}')==1")
public class BeanConfig {
    @Bean
    public TestBean testBean(){
        return new TestBean("我是美猴王");
    }
}
@SpringBootApplication
public class TestAppCommand implements CommandLineRunner {
    @Autowired
    private TestBean testBean;

    public static void main(String[] args) {
        SpringApplication.run(TestAppCommand.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(testBean.getName());
    }
}

@ConditionalOnProperty

適合對單個Property進行條件判斷，而上面的@ConditionalOnExpress適合面對較爲複雜的狀況，好比多個property的關聯比較。這個例子也給了三種基本類型的條件判斷，不過貌似均當成字符串就能夠...

@Data
@AllArgsConstructor
@NoArgsConstructor
public class TestBean {
    private String name;
}
@Configuration
@ConditionalOnProperty(prefix = "test", name="enabled", havingValue = "true",matchIfMissing = false)
//@ConditionalOnProperty(prefix = "test", name="account", havingValue = "1",matchIfMissing = false)
//@ConditionalOnProperty(prefix = "test", name="name1", havingValue = "zz",matchIfMissing = false)
public class BeanConfig {

    @Bean
    public TestBean testBean(){
        return new TestBean("我是美猴王");
    }
}
@SpringBootApplication
public class TestAppCommand implements CommandLineRunner {
    @Autowired
    private TestBean testBean;
    public static void main(String[] args) {
        SpringApplication.run(TestAppCommand.class, args);
    }
    @Override
    public void run(String... args) throws Exception {
        System.out.println(testBean.getName());

    }
}

@ConditionalOnJava

能夠經過java的版本進行判斷。

@Data
public class TestBean {
}
@Configuration
@ConditionalOnJava(JavaVersion.EIGHT)
public class BeanConfig {

    @Bean
    public TestBean testBean(){
        return new TestBean();
    }
}
public class TestApp {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
    @Test
    public void test(){
        Map<String,TestBean> map = context.getBeansOfType(TestBean.class);
        System.out.println(map);
    }
}

@ConditionalOnResource

經過指定的資源文件是否存在進行條件判斷，好比判斷ehcache.properties來決定是否自動裝配ehcache組件。

@Data
public class TestBean {
}
@Configuration
@ConditionalOnResource(resources = "classpath:application.yml")
public class BeanConfig {

    @Bean
    public TestBean testBean(){
        return new TestBean();
    }
}
public class TestApp {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);

    @Test
    public void test(){
        Map<String,TestBean> map = context.getBeansOfType(TestBean.class);
        System.out.println(map);
    }
}

@ConditionalOnSingleCandidate

這個尚未想到應用場景，條件經過的條件是：1 對應的bean容器中只有一個 2.對應的bean有多個，可是已經制定了PRIMARY。例子中，BeanB裝配的時候須要看BeanA的裝配狀況，因此BeanBConfig要排在BeanAConfig以後.能夠修改BeanAConfig,將@Primary註解去掉，或者把三個@Bean註解去掉，BeanB就不會實例化了。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BeanA {
    private String name;
}
@Configuration
public class BeanAConfig {

    @Bean
    @Primary
    public BeanA bean1(){
        return new BeanA("bean1");
    }
    @Bean(autowireCandidate = false)
    public BeanA bean2(){
        return new BeanA("bean2");
    }
    //@Bean(autowireCandidate = false)
    public BeanA bean3(){
        return new BeanA("bean3");
    }
}
@Data
public class BeanB {
}
@Configuration
@AutoConfigureAfter(BeanAConfig.class)
@ConditionalOnSingleCandidate(BeanA.class)
public class BeanBConfig {

    @Bean
    public BeanB targetBean(){
        return new BeanB();
    }
}
public class TestApp {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanAConfig.class, BeanBConfig.class);

    @Test
    public void test(){
        Map<String,BeanA> map = context.getBeansOfType(BeanA.class);
        System.out.println(map);
        Map<String,BeanB> map2 = context.getBeansOfType(BeanB.class);
        System.out.println(map2);
    }
}

@ConditionalOnNotWebApplication & @ConditionalOnWebApplication

判斷當前環境是不是Web應用。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程