关于 @Conditional 注解

背景

在我们项目中，有时候需要实现这样的需求。我有个接口I，接口的实现类有A、B，我需要的效果是通过不同的配置，实例化具体某个实现类，即可以选择实例化A或B

在spring中，有个注解 @Conditional 可以实现这个要求。我们先来最简单的例子1

1、例子1

接口1个

public interface PrinterService {
    String print(String content);
}

具体实现2个

@Service
@Conditional(PrinterServiceConditional.InkCondition.class)
public class InkPrinterServiceImpl implements PrinterService {
    @Override
    public String print(String content) {
        return "喷墨打印机打印：" + content;
    }
}

@Service
@Conditional(PrinterServiceConditional.LaserCondition.class)
public class LaserPrinterServiceImpl implements PrinterService {
    @Override
    public String print(String content) {
        return "激光打印机打印：" + content;
    }
}

最关键的配置

package com.wyf.test.conditionalspring.config.conditaional;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Arrays;

/**
 * 判断要初始化哪个具体你的实现类（写在一个类里，用内部类，比较清爽）
 *
 * @author Stone
 * @version V1.0.0
 * @date 2020/3/3
 */
public class PrinterServiceConditional {

    public static class InkCondition implements Condition {

        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            return isInkPrinter(context, metadata);
        }
    }

    public static class LaserCondition implements Condition {

        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            return isLaserPrinter(context, metadata);
        }
    }


    private static String getPrinter(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String myPrinter = context.getEnvironment().getProperty("my.printer");
        if (!Arrays.asList("ink", "laser").contains(myPrinter)) {
            throw new RuntimeException("Invalid config");
        }
        return myPrinter;
    }

    /**
     * 判断是否喷墨打印机
     *
     * @param context
     * @param metadata
     * @return
     */
    public static boolean isInkPrinter(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return "ink".equals(getPrinter(context, metadata));
    }

    /**
     * 判断是否激光打印机
     *
     * @param context
     * @param metadata
     * @return
     */
    public static boolean isLaserPrinter(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return "laser".equals(getPrinter(context, metadata));
    }
}

测试类，通过请求接口或者其他方式判断究竟初始化了哪个

@RestController
public class PrinterController {
    /**
     * 这里红色提示找不到bean，原因是用了@Conditional，导致 IDEA 无法识别到有注入
     */
    @Autowired
    private PrinterService printerService;

    @GetMapping("/test")
    public String test() {
        return printerService.print("hello world");
    }
}

配置文件

# 取值ink和laser，初始化对应的值
my.printer=ink

2、例子2

上面的例子不够优雅，我们改一改，其实有个 @ConditionalOnProperty

把上述2个实现类改成如下即可

@Service
@ConditionalOnProperty(value = "my.printer", havingValue = "ink", matchIfMissing = true)
public class InkPrinterServiceImpl implements PrinterService {
    @Override
    public String print(String content) {
        return "喷墨打印机打印：" + content;
    }
}

@Service
@ConditionalOnProperty(value = "my.printer", havingValue = "laser")
public class LaserPrinterServiceImpl implements PrinterService {
    @Override
    public String print(String content) {
        return "激光打印机打印：" + content;
    }
}

细节：havingValue是说配置值要等于这个才会实例化，matchIfMissing是说如果找不到这个配置默认实例化当前这个类，注意肯定不能有超过1个的 matchIfMissing=true。

3、例子3

我们来展示更加多好玩的注解 @Conditional 家族

说明

研究各式各样的Conditional注解

• @Conditional
• @ConditionalOnProperty
• @ConditionalOnClass
• @ConditionalOnBean
• @ConditionalOnMissingClass
• @ConditionalOnMissingBean
• @ConditionalOnExpression
• @ConditionalOnWebApplication：怎么区分web启动和非web启动，详细查看com.wyf.test.conditionalspring.NotWebStartApplication
• @ConditionalOnNotWebApplication

具体详细查看 com.wyf.test.conditionalspring.config.conditional.Config

Config类：上述注解可以写在类上，表示类的所有方法，也可以写在方法上。下面的例子演示了上述所有注解的使用方法，在什么情况下实例化就会打印出对应的日志。其中比较难理解的是否web应用后文会讨论

package com.wyf.test.conditionalspring.config.conditional;

import org.springframework.boot.autoconfigure.condition.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * Created by wuweifeng on 2017/10/11.
 */
@Configuration
public class Config {

    /**
     * 自定义的condition的match方法返回值为true时，才会进入该方法创建bean
     *
     * @return
     */
    @Conditional(MyCondition.class)
    @Bean
    public String conditional() {
        System.out.println("@Conditional");
        return "";
    }

    /**
     * property的值符合预期的时候才会创建bean
     */
    @ConditionalOnProperty(value = "abc.property", havingValue = "true")
    @Bean
    public String conditionalOnProperty() {
        System.out.println("@ConditionalOnProperty");
        return "";
    }

    /**
     * 指定 class 位于类路径上时
     */
    @ConditionalOnClass(name = "com.wyf.test.conditionalspring.config.conditional.MyClass")
    @Bean
    public String conditionalOnClass() {
        System.out.println("@ConditionalOnClass");
        return "";
    }

    /**
     * 指定 class 不在类路径上时
     *
     * @return
     */
    @ConditionalOnMissingClass("com.wyf.test.conditionalspring.config.conditional.MyClass")
    @Bean
    public String conditionalOnMissingClass() {
        System.out.println("@ConditionalOnMissingClass");
        return "";
    }

    /**
     * 当spring容器存在指定的bean时，才初始化这个
     */
    @ConditionalOnBean(MyBean.class)
    @Bean
    public String conditionalOnBean() {
        System.out.println("@ConditionalOnBean");
        return "";
    }

    /**
     * 当spring容器不存在指定的bean时，才初始化这个
     *
     * @return
     */
    @ConditionalOnMissingBean(MyBean.class)
    @Bean
    public String conditionalOnMissingBean() {
        System.out.println("@ConditionalOnMissingBean");
        return "";
    }

    /**
     * 当表达式是true时才实例化bean
     */
    @ConditionalOnExpression(value = "true")
    @Bean
    public String conditionalOnExpression() {
        System.out.println("@ConditionalOnExpression");
        return "";
    }


    /**
     * 当是 web 应用 时。（可能当前这个project可以用非web的方式启动，那就是非web应用，否则则是web应用）
     */
    @ConditionalOnWebApplication
    @Bean
    public String conditionalOnWebApplication() {
        System.out.println("@ConditionalOnWebApplication");
        return "";
    }


    /**
     * 当是非web应用时
     *
     * @return
     */
    @ConditionalOnNotWebApplication
    @Bean
    public String conditionalOnNotWebApplication() {
        System.out.println("@ConditionalOnNotWebApplication");
        return "";
    }

}

怎么样模拟web启动和非web启动，其实springboot不是一定要用web方式启动的，如下就展示了

package com.wyf.test.conditionalspring;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

/**
 * 演示了非web方式启动的方法
 *
 * @author Stone
 * @version V1.0.0
 * @date 2020/3/3
 */
@SpringBootApplication
public class NotWebStartApplication implements CommandLineRunner {
    public static void main(String[] args) {
        // 以下两种分别是非web启动和web启动的方法


        // 非web方式启动，ConditionalOnWebApplication 不被执行，ConditionalOnNotWebApplication 被执行
        new SpringApplicationBuilder(NotWebStartApplication.class)
                .web(WebApplicationType.NONE)
                .run(args);

        // web方式启动
        //SpringApplication.run(NotWebStartApplication.class, args);
    }

    /**
     * spring boot启动后，会进入该方法
     */
    @Override
    public void run(String... args) throws Exception {
        init();
    }

    /**
     * 初始化信息
     */
    @SuppressWarnings("unused")
    private void init() {
        System.out.println("init.........");
    }
}