不积跬步，无以至千里。
先看一个 org.springframework.context.annotation.Condition接口，接口定义如下，定义了返回布尔类型的matches方法。
public interface Condition {
boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}
实现这个接口可以得到二个对象ConditionContext和AnnotatedTypeMetadata
，这个接口也是从spring4.0开始出现的。
再看一个@Conditional注解，这个注解也是从spring4.0出现的。
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
Class<? extends Condition>[] value();
}
这个接口和注解干嘛用的，先不详细说明，先看一个demo。
demo
定义一个接口
package com.zhihao.miao.beans;
public interface EncodingConvert {
}
其二个实现类：
package com.zhihao.miao.beans;
public class GBKEncodingConvert implements EncodingConvert{
}
package com.zhihao.miao.beans;
public class UTF8EncodingConvert implements EncodingConvert{
}
配置类，
@SpringBootConfiguration
public class MyConfig {
@Bean
public UTF8EncodingConvert createUTF8Encoding(){
return new UTF8EncodingConvert();
}
@Bean
public GBKEncodingConvert createGBKEncoding(){
return new GBKEncodingConvert();
}
}
从第一篇博客我们知道UTF8EncodingConvert对象和GBKEncodingConvert对象都会纳入到spring容器中管理。
主测试类：
package com.zhihao.miao;
import com.zhihao.miao.beans.EncodingConvert;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ConfigurableApplicationContext context =SpringApplication.run(Application.class,args);
System.out.println(context.getBeansOfType(EncodingConvert.class));
context.close();
}
}
启动，打印结果：
{createUTF8Encoding=com.zhihao.miao.beans.UTF8EncodingConvert@15043a2f, createGBKEncoding=com.zhihao.miao.beans.GBKEncodingConvert@4a83a74a}
很明显符合我们的期望。
现在有需求如下，我从配置文件中读取配置project.encoding为UTF-8时，系统自动装配UTF8EncodingConvert这个对象，读取到project.encoding为GBK时，系统自动装配GBKEncodingConvert。其实看到博客的结束就知道有更简单的实现。
定义二个类实现上面所说的Condition接口,其重写方法matches，返回布尔类型。
package com.zhihao.miao.condition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class GBKCondition implements Condition{
private Logger logger = LoggerFactory.getLogger(getClass());
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String encoding = context.getEnvironment().getProperty("project.encoding");
logger.info("encoding==="+encoding);
if(encoding != null){
return "gbk".equals(encoding.toLowerCase());
}
return false;
}
}
package com.zhihao.miao.condition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class UTF8Condition implements Condition{
private Logger logger = LoggerFactory.getLogger(getClass());
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String encoding = context.getEnvironment().getProperty("project.encoding");
logger.info("encoding==="+encoding);
if(encoding != null){
return "utf-8".equals(encoding.toLowerCase());
}
return false;
}
}
之前的MyConfig类修改如下：
package com.zhihao.miao.beans;
import com.zhihao.miao.condition.GBKCondition;
import com.zhihao.miao.condition.UTF8Condition;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
@SpringBootConfiguration
public class MyConfig {
@Bean
@Conditional(UTF8Condition.class)
public UTF8EncodingConvert createUTF8Encoding(){
return new UTF8EncodingConvert();
}
@Bean
@Conditional(GBKCondition.class)
public GBKEncodingConvert createGBKEncoding(){
return new GBKEncodingConvert();
}
}
@Conditional的参数是一个实现Condition接口的实现类，如果实现类返回true表示自动装配这个@Conditional注解修改的方法的对象，反之亦然。
当然@Conditional注解也可以在修改类，比如说修饰当前类MyConfig，那么当注解参数返回true的时候，则当前类下的所有对象都会自动装配，反之亦然。
配置文件application.properties如果配置了
project.encoding=utf-8
则打印结果为
{createUTF8Encoding=com.zhihao.miao.beans.UTF8EncodingConvert@4c60d6e9}
如果application.properties如果配置为
project.encoding=gbk
则打印结果为：
{createGBKEncoding=com.zhihao.miao.beans.GBKEncodingConvert@72cc7e6f}
springboot依赖提供的一些自动装配的@Conditional
上面自定义了@Conditional实现，也就说当某种情况下满足时去自动装配对象。自定义类实现org.springframework.context.annotation.Condition接口，然后配置@Conditional注解进行根据条件来自动装配。
springboot提供的@Conditional**注解
spring-boot-autoconfigure依赖的condition包下提供了一些默认实现好的的@Conditional**注解，
org.springframework.boot.autoconfigure.condition.ConditionalOnBean:
存在某个bean已经被spring 容器装配的时候，当前bean也自动装配。
org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean:
某个bean没有被spring容器装配的时候自定装配当前类。
org.springframework.boot.autoconfigure.condition.ConditionalOnClass:
当classpath路径下有这个类依赖的时候自动装配，没有的时候不装配
org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass与上面相反
org.springframework.boot.autoconfigure.condition.ConditionalOnExpression ：
当指定的SpEL表达式返回true的时候自动装配，
org.springframework.boot.autoconfigure.condition.ConditionalOnJava：
当前jvm的版本号是**的时候进行自动装配。
org.springframework.boot.autoconfigure.condition.ConditionalOnNotWebApplication：
当前环境不是web环境的时候装配
org.springframework.boot.autoconfigure.conditionConditionalOnWebApplication：
当前环境是web环境的时候自动装配.
org.springframework.boot.autoconfigure.condition.ConditionalOnResource：
当某个资源存在的时候自动装配。
org.springframework.boot.autoconfigure.condition.ConditionalOnProperty：
当配置文件存在的时候，或者当配置文件等于某个值的时候自动装配。
写一个demo测试一下：
@ConditionalOnProperty
定义一普通类UserConfig
@SpringBootConfiguration
public class UserConfig {
/**
* 表示在application.properties中配置的属性等于某个值的时候（havingValue配置的值），Runnable这个类自动状态，
* 实例名为createRunnable，缺省（matchIfMissing）的时候也自动装套
*/
@Bean
@ConditionalOnProperty(name="runnable.enabled",havingValue = "true",matchIfMissing = true)
public Runnable createRunnable(){
return () -> {};
}
}
在application.properties中配置了runnable.enabled属性，
runnable.enabled=true
启动Application类，
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ConfigurableApplicationContext context =SpringApplication.run(Application.class,args);
System.out.println(context.getBeansOfType(Runnable.class));
context.close();
}
}
打印结果：
{createRunnable=com.zhihao.miao.config.UserConfig$$Lambda$7/510276116@79207381}
@ConditionalOnClass
定义一普通类UserConfig
@SpringBootConfiguration
public class UserConfig {
/**
* 表示classpath中是否存在某个类的时候就会自动装配,当我们在pom文件中加入了Gson的依赖就自定装配了此对象（实例名为createGsonRunnable）
* @return
*/
@Bean
@ConditionalOnClass(name="com.google.gson.Gson")
public Runnable createGsonRunnable(){
return () -> {};
}
}
当pom文件中加入依赖：
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.1</version>
</dependency>
启动Application类，控制台打印：
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ConfigurableApplicationContext context =SpringApplication.run(Application.class,args);
System.out.println(context.getBeansOfType(Runnable.class));
context.close();
}
}
{createGsonRunnable=com.zhihao.miao.config.UserConfig$$Lambda$8/121167003@491b9b8}
ConditionalOnBean
定义一普通类UserConfig
@SpringBootConfiguration
public class UserConfig {
/**
* 当spring容器中有user对象的时候，自动装配对象为createBeanRunnable的Runnable实例
*/
@Bean
@ConditionalOnBean(name = "user")
public Runnable createBeanRunnable(){
return () -> {};
}
}
定义一User类，并纳入到spring容器中管理
@Component("user")
public class User {
private String username;
private String password;
}
启动Application类，控制台打印：
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ConfigurableApplicationContext context =SpringApplication.run(Application.class,args);
System.out.println(context.getBeansOfType(Runnable.class));
context.close();
}
}
createBeanRunnable=com.zhihao.miao.config.UserConfig$$Lambda$9/1014486152@1a4927d6
其实熟悉使用springboot框架的开发者就会知道，官网或者开源组织提供的各种starter依赖（在pom文件加入依赖），然后在配置文件中配置一些属性，比如如果我们使用mongodb的时候，会自动装配一些类来使得我们连接mongodb服务，我们只需要配置一些mongodb的一些服务信息，，而不需要以前在配置文件中进行spring和mongodb的整合
看org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration大量使用官方提供的这些@Conditional**注解，下面截取一段说明一下。
@Bean
@ConditionalOnMissingBean(MongoDbFactory.class)
public SimpleMongoDbFactory mongoDbFactory(MongoClient mongo) throws Exception {
String database = this.properties.getMongoClientDatabase();
return new SimpleMongoDbFactory(mongo, database);
}
@Bean
@ConditionalOnMissingBean
public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory,
MongoConverter converter) throws UnknownHostException {
return new MongoTemplate(mongoDbFactory, converter);
}
@Bean
@ConditionalOnMissingBean(MongoConverter.class)
public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory,
MongoMappingContext context, BeanFactory beanFactory,
CustomConversions conversions) {
DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver,
context);
mappingConverter.setCustomConversions(conversions);
return mappingConverter;
}
关于自动装配下面的博客会大量使用到此种特性，这也是springboot配置少的根本原因。
