springboot对条件接口Condition的扩展和使用

一时失言乱红尘 2022-10-27 01:33 219阅读 0赞

## 写在前面 ##

对于Condition的基础使用，可以参考[这里][Link 1]。  
开始学习吧！！！

## 1：springboot的基础实现类 ##

类`org.springframework.boot.autoconfigure.condition.SpringBootCondition`是spring boot扩展spring的`org.springframework.context.annotation.Condition`的抽象基础类，主要是提供了自动配置类加载的日志信息，类签名如下：

// 在springboot中使用的条件类的基类，主要提供哪些自动配置类被加载的日志信息
    public abstract class SpringBootCondition implements Condition { }

我们知道，具体实现类最终也需要使用在具体的注解上，也就是`Condition实现类+注解`是成对出现的，需要注意的是具体的实现类并非直接集成`org.springframework.boot.autoconfigure.condition.SpringBootCondition`,而是继承自`org.springframework.boot.autoconfigure.condition.FilteringSpringBootCondition`,springboot中常用的如下：

容器中有指定bean的时候为true：
    	注解：ConditionalOnBean
    	条件类：OnBeanCondition
    容器中没有指定bean的时候为true：
    	注解：ConditionalOnMissingBean
    	条件类：OnBeanCondition
    容器中指定的bean只有一个时为true：
    	注解：ConditionalOnSingleCandidate
    	条件类：OnBeanCondition
    当类路径下有指定类的时候为true：
    	注解：ConditionalOnClass
    	条件类：OnClassCondition
    当类路径下没有指定类的时候为true：
    	注解：ConditionalOnMissingClass
    	条件类：OnClassCondition
    当指定的属性有指定的值的时候为true：
    	注解：ConditionalOnProperty
    	条件类：OnPropertyCondition
    类路径有指定的值的时候为true：
    	注解：ConditionalOnResource
    	条件类：OnResourceCondition
    基于springEL表达式判断是否为true：
    	注解：ConditionalOnExpression
    	条件类：OnExpressionCondition
    基于Java版本进行判断，满足版本要求为true：
    	注解：ConditionalOnJava
    	条件类：OnJavaCondition
    当项目不是web项目的条件下为true：
    	注解：ConditionalOnNotWebApplication
    	条件类：OnWebApplicationCondition
    当项目时web项目的条件下为true：
    	注解：ConditionalOnWebApplication
    	条件类：OnWebApplicationCondition

可以看到对于注解的格式是`ConditionalOnXXX`，而条件类的格式是`OnXXXCondition`,我们在扩展自己的注解和条件类的时候也可以参考这个`规范格式`。

## 2：@Conditional注解 ##

`@Conditional`注解源码如下：

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Conditional { 
    	Class<? extends Condition>[] value();
    }

从源码中我们可以得到如下几个信息：

1：注解可以使用在类上，方法上
    2：注解会在运行时起作用
    3：注解需要一个类型为Condition的Class的数组

一般的，我们是将该注解和`@Configuration`注解一起配合使用，其实只要是标注为一个`spring bean`的注解都可以配合该注解一起使用，如下定义条件类：

public class OnCreateHelloControllerCondition implements Condition { 
    
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
        	// return true;
            return false;
        }
    }

然后定义一个controller：

@Controller
    @Conditional(OnCreateHelloControllerCondition.class)
    public class HelloController { 
    
        @Resource
        private AService aService;
    
        @ResponseBody
        @RequestMapping("/hello")
        public String hello() { 
            aService.sayHi();
            return "Hello World!";
        }
    }

注意其中的`@Conditional(OnCreateHelloControllerCondition.class)`，因为我们定义`OnCreateHelloControllerCondition#matches`方法返回的是false，所以不会加载`HelloController`，如下代码测试：

@SpringBootApplication
    public class HelloWorldMainApplication { 
    
        public static void main(String[] args) throws URISyntaxException, IOException { 
            ConfigurableApplicationContext run = SpringApplication.run(HelloWorldMainApplication.class, args);
            HelloController bean = run.getBean(HelloController.class);
            System.out.println(bean);
        }
    }

运行：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]  
修改`OnCreateHelloControllerCondition #matches`返回true，测试：

2021-02-04 16:57:06.491  INFO 71644 --- [           main] dongshi.daddy.HelloWorldMainApplication  : Started HelloWorldMainApplication in 1.02 seconds (JVM running for 1.414)
    dongshi.daddy.controller.HelloController@6bd51ed8

## 3：SpringBootCondition抽象类 ##

该抽象类是springboot扩展Condition的抽象基类，springboot中的条件类都是继承自该类，该类源码如下：

public abstract class SpringBootCondition implements Condition { 
    
    	private final Log logger = LogFactory.getLog(getClass());
    
    	@Override
    	public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    		// <1>
    		String classOrMethodName = getClassOrMethodName(metadata);
    		try { 
    			// <2>
    			ConditionOutcome outcome = getMatchOutcome(context, metadata);
    			// <3>
    			logOutcome(classOrMethodName, outcome);
    			// <4>
    			recordEvaluation(context, classOrMethodName, outcome);
    			// <5>
    			return outcome.isMatch();
    		}
    		catch (NoClassDefFoundError ex) { 
    			...
    		}
    		catch (RuntimeException ex) { 
    			...
    		}
    	}
    }

`<1>`处代码是获取使用了条件注解的类或者是方法的全限定名称，使用条件变量`"org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration".equals(classOrMethodName)`debug，查看springmvc自动配置类`WebMvcAutoConfiguration`情况时的值：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]  
`<2>`处调用方法是一个抽象方法，强制子类实现，源码如下：

public abstract ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata);

具体子类根据各自具体情况实现条件类返回`ConditionOutcome`对象。`<3>`处代码打印日志，辅助开发人员确定哪些类被自动加载。`<4>`记录相关信息，不做深究，`<5>`处返回最终是否匹配的结果。该抽象类的主要作用就是打印最终匹配的结果信息，主要的类是`ConditionOutcome`和`ConditionMessage`。二者的源码不是特别复杂如下：

org.springframework.boot.autoconfigure.condition.ConditionOutcome
    public class ConditionOutcome { 
    	// 条件是否匹配的结果
    	private final boolean match;
    	// 条件的匹配结果的信息对象
    	private final ConditionMessage message;
    }

org.springframework.boot.autoconfigure.condition.ConditionMessage
    public final class ConditionMessage { 
    	// 匹配结果的消息
    	private String message;
    }

下面我们来测试下日志输出的信息。

### 3.1：测试匹配结果日志 ###

为了能够看到日志，我们先在`application.properties`配置文件中修改`org.springframework`包日志的隔离级别为`trace`：  
`logging.level.org.springframework=trace`。为了测试更加有针对性，我们使用条件变量`this.getClass().equals(OnWebApplicationCondition.class) && "org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration".equals(classOrMethodName)`来测试`WebMvcAutoConfiguration`类的日志输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]  
另外对于多条件匹配的情况，SpringBootCondition也提供了`anyMatches`方法，用来从多个条件中匹配任意的一个。

## 4：@ConditionalOnProperty ##

在前面已经提到，该注解的作用的`当指定的属性有指定的值的时候为true`，即，只有配置文件中有指定的属性的时候，配置才会生效，我们先来看下源码：

@Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.TYPE, ElementType.METHOD})
    @Documented
    @Conditional({ OnPropertyCondition.class})
    public @interface ConditionalOnProperty { 
        String[] value() default { };
    
        String prefix() default "";
    
        String[] name() default { };
    
        String havingValue() default "";
    
        boolean matchIfMissing() default false;
    }

其中`prefix`用来社设置属性的前缀，`name`用来设置属性的名称数组，`havingValue`代表`prefix+name`组合的属性要有指定的值，最后`value`同`name`二选其一使用即可，不可同时使用，例如如下的配置:

@ConditionalOnProperty(prefix="people",name = "hobbies", havingValue = "basketball")

就代表`people.hobbies`配置项的值中要有`basketball`。下面我们通过实例来看下。

### 4.1：定义配置类 ###

@Configuration
    @ConditionalOnProperty(prefix = "people", name = "hobbies", havingValue = "basketball")
    public class TestConditionalOnPropertyConfiguration { 
    }

### 4.2：定义启动类 ###

@SpringBootApplication
    public class HelloWorldMainApplication { 
    
        public static void main(String[] args) throws URISyntaxException, IOException { 
            ConfigurableApplicationContext run = SpringApplication.run(HelloWorldMainApplication.class, args);
            TestConditionalOnPropertyConfiguration bean = run.getBean(TestConditionalOnPropertyConfiguration.class);
            System.out.println(bean);
        }
    }

不配置指定属性，测试：

2021-02-05 11:54:35.068  INFO 52932 --- [           main] dongshi.daddy.HelloWorldMainApplication  : Started HelloWorldMainApplication in 1.219 seconds (JVM running for 1.794)
    Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'dongshi.daddy.myconfiguration.TestConditionalOnPropertyConfiguration' available
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:351)
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:342)
    	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1123)
    	at dongshi.daddy.HelloWorldMainApplication.main(HelloWorldMainApplication.java:16)

配置：

people.hobbies=basketball

启动：

2021-02-05 11:57:35.755  INFO 71760 --- [           main] dongshi.daddy.HelloWorldMainApplication  : Started HelloWorldMainApplication in 1.172 seconds (JVM running for 1.748)
    dongshi.daddy.myconfiguration.TestConditionalOnPropertyConfiguration$$EnhancerBySpringCGLIB$$c1791150@5b9396d3

修改为不是`havingValue`指定的值`people.hobbies=football`，测试：

2021-02-05 11:58:44.722  INFO 68468 --- [           main] dongshi.daddy.HelloWorldMainApplication  : Started HelloWorldMainApplication in 1.163 seconds (JVM running for 1.661)
    Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'dongshi.daddy.myconfiguration.TestConditionalOnPropertyConfiguration' available
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:351)
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:342)
    	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1123)
    	at dongshi.daddy.HelloWorldMainApplication.main(HelloWorldMainApplication.java:16)

### 4.3：源码分析 ###

从注解`ConditionalOnProperty`的源码可以看出，其使用的条件类是`OnPropertyCondition`，该类主要源码如下：

class OnPropertyCondition extends SpringBootCondition { 
    	@Override
    	public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    		...
    	}
    }

继承了`SpringBootCondition`,因此首先会调用`org.springframework.boot.autoconfigure.condition.SpringBootCondition#matches()`该方法源码如下：

@Override
    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    	String classOrMethodName = getClassOrMethodName(metadata);
    	try { 
    		//<1> 该处相当于this.getMatchOutcome,因此会调用具体实现类方法
    		ConditionOutcome outcome = getMatchOutcome(context, metadata);
    		...
    	}
    	catch (NoClassDefFoundError ex) { 
    		...
    	}
    }

通过`<1>`处代码会调用`org.springframework.boot.autoconfigure.condition.OnPropertyCondition#getMatchOutcome`,那么我们就从这里开始分析下源码，为了方便调试，我们在方法的第一行增加条件变量`allAnnotationAttributes.get(0).getString("havingValue").equals("basketball")`,如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]  
方法源码如下：

@Override
    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    	// <1>
    	List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
    			metadata.getAllAnnotationAttributes(ConditionalOnProperty.class.getName()));
    	// <2>
    	List<ConditionMessage> noMatch = new ArrayList<>();
    	List<ConditionMessage> match = new ArrayList<>();
    	// <3>
    	for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) { 
    		// <4>
    		ConditionOutcome outcome = determineOutcome(annotationAttributes, context.getEnvironment());
    		(outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
    	}
    	// <5>
    	if (!noMatch.isEmpty()) { 
    		return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
    	}
    	// <6>
    	return ConditionOutcome.match(ConditionMessage.of(match));
    }

`<1>`处代码获取在`@ConditionalOnProperty`注解定义的属性，这里可以认为只有一个，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 4]  
`<2>`处是存储匹配和不匹配的`ConditionMessage`消息集合。这里只会有一个有一条数据。`<3>`处循环处理所有的注解属性。`<4>`处执行匹配，源码如下：

private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, PropertyResolver resolver) { 
    	// Spec是一个封装属性信息的对象，后续匹配就通过该类完成
    	Spec spec = new Spec(annotationAttributes);
    	List<String> missingProperties = new ArrayList<>();
    	List<String> nonMatchingProperties = new ArrayList<>();
    	// <determineOutcome_1> 执行具体的匹配，将缺失的属性名称和不匹配的属性名称设置
    	// 到对应的集合中，这两种情况都会导致最终不匹配
    	spec.collectProperties(resolver, missingProperties, nonMatchingProperties);
    	// 如果是缺失属性集合不为空则说明不匹配
    	if (!missingProperties.isEmpty()) { 
    		return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
    				.didNotFind("property", "properties").items(Style.QUOTE, missingProperties));
    	}
    	// 如果是不匹配集合不为空，则说明不匹配
    	if (!nonMatchingProperties.isEmpty()) { 
    		return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
    				.found("different value in property", "different value in properties")
    				.items(Style.QUOTE, nonMatchingProperties));
    	}
    	// 到这里了则说明匹配成功
    	return ConditionOutcome
    			.match(ConditionMessage.forCondition(ConditionalOnProperty.class, spec).because("matched"));
    }

`<determineOutcome_1>`处源码如下：

private void collectProperties(PropertyResolver resolver, List<String> missing, List<String> nonMatching) { 
    	for (String name : this.names) { 
    		String key = this.prefix + name;
    		if (resolver.containsProperty(key)) { 
    			if (!isMatch(resolver.getProperty(key), this.havingValue)) { 
    				nonMatching.add(name);
    			}
    		}
    		else { 
    			if (!this.matchIfMissing) { 
    				missing.add(name);
    			}
    		}
    	}
    }

debug如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 5]  
我们再来看一个当不匹配的debug结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 6]

[Link 1]: https://blog.csdn.net/wang0907/article/details/113480884
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221024/d720493d0a7c47f2befdd0d87df60aaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]: /images/20221024/379f35a2496d46c498533c98278a2aa9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 2]: /images/20221024/c54401a7f2074c8b9f1fc7d20d087ef0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 3]: /images/20221024/d6fb9bb950d04d7d9d8f5cc398b1a5fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 4]: /images/20221024/d1a2218a305a49eab1dd924237613285.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 5]: /images/20221024/afcd2ec87eed463b85f92d69969ec20f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 6]: /images/20221024/f87fa279ac6440d99d9f164d05124445.png