时间戳

首页 > 技术文章 > springboot情操陶冶-@ConfigurationProperties注解解析

springboot情操陶冶-@ConfigurationProperties注解解析

question-sky 2018-08-13 17:16 原文

承接前文springboot情操陶冶-@Configuration注解解析，本文将在前文的基础上阐述@ConfigurationProperties注解的使用

@ConfigurationProperties

此注解多用于对配置文件的加载以及映射对应值至相应的java属性中，样例如下

1.配置属性指定application.properties

# user custom
user.custom.username=demo_jing
user.custom.nickname=nanco
user.custom.email=questionsky1211@gmail.com
user.custom.password=demo1234
user.custom.job=programmer

2.属性映射类(使用@ConfigurationProperties注解)UserProperty.java

package com.example.demo.bootbase;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author nanco
 * @create 2018/8/13
 **/
@ConfigurationProperties(prefix = "user.custom")
public class UserProperty {

    private String username;

    private String nickname;

    private String email;

    private String password;

    private String job;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "UserProperty{" +
                "username='" + username + '\'' +
                ", nickname='" + nickname + '\'' +
                ", email='" + email + '\'' +
                ", password='" + password + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}

3.属性映射开启(使用@EnableConfigurationProperties注解)UserPropertiesAutoConfiguration.java

package com.example.demo.bootbase;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @author nanco
 * @create 2018/8/13
 **/
@Configuration
@EnableConfigurationProperties(value = UserProperty.class)
public class UserPropertiesAutoConfiguration {
}

4.上述注解生效入口META-INF\spring.fatories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.demo.bootbase.UserPropertiesAutoConfiguration

5.结果检验

package com.example.demo;

import com.example.demo.bootbase.UserProperty;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoSpringbootApplication {

    public static void main(String[] args) {
        ApplicationContext demoApplicationContext = SpringApplication.run(DemoSpringbootApplication.class, args);

        UserProperty userProperty = demoApplicationContext.getBean(UserProperty.class) ;

        System.out.println(userProperty);
    }
}

输出结果如下

...
...
2018-08-13 14:37:05.537  INFO 17384 --- [           main] o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 2147483647
2018-08-13 14:37:05.546  INFO 17384 --- [           main] c.e.demo.DemoSpringbootApplication       : Started DemoSpringbootApplication in 2.611 seconds (JVM running for 3.756)
UserProperty{username='demo_jing', nickname='nanco', email='questionsky1211@gmail.com', password='demo1234', job='programmer'}

出现的结果与我们预知的一样，属性都进行了相应的赋予。下面笔者开展下源码层的解析以解开其中的绑定小谜团

@EnableConfigurationProperties

要想上述的结果运行成功，必须在相应的启动类使用@EnableConfigurationProperties注解，我们先看下其源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EnableConfigurationPropertiesImportSelector.class)
public @interface EnableConfigurationProperties {

	/**
	 * Convenient way to quickly register {@link ConfigurationProperties} annotated beans
	 * with Spring. Standard Spring Beans will also be scanned regardless of this value.
	 * @return {@link ConfigurationProperties} annotated beans to register
	 */
	Class<?>[] value() default {};

}

其中的value属性便是扫描的属性class，并且会将指定的class属性注册至bean工厂。通过前文分析可得，最终的解析是通过@Import引入的EnableConfigurationPropertiesImportSelector.class来实现的

EnableConfigurationPropertiesImportSelector

直接查看其复写的selectImports()方法

	private static final String[] IMPORTS = {
			// 属性类注册
			ConfigurationPropertiesBeanRegistrar.class.getName(),
			// 属性类绑定处理
			ConfigurationPropertiesBindingPostProcessorRegistrar.class.getName() };

	@Override
	public String[] selectImports(AnnotationMetadata metadata) {
		return IMPORTS;
	}

将导入两个类去处理属性的关系，我们按照顺序来分析

ConfigurationPropertiesBeanRegistrar
直接去看其复写的方法

		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata,
				BeanDefinitionRegistry registry) {
			// 读取被注解类上的EnableConfigurationProperties上的value属性并进行注入至bean工厂
			getTypes(metadata).forEach((type) -> register(registry,
					(ConfigurableListableBeanFactory) registry, type));
		}

具体的代码就不贴出来了，笔者此处作下小的总结

  1. 优先读取被注解类上@EnableConfigurationProperties的value属性

  2. 在将上述的value属性指定的class集合注入至bean工厂前，优先判断是否被@ConfigurationProperties注解修饰过，没有则会报错

  3. 将指定的class集合注册至bean工厂

ConfigurationPropertiesBindingPostProcessorRegistrar
直接查看复写的方法

	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
			BeanDefinitionRegistry registry) {
		if (!registry.containsBeanDefinition(
				ConfigurationPropertiesBindingPostProcessor.BEAN_NAME)) {
			// ConfigurationPropertiesBindingPostProcessor注册
			registerConfigurationPropertiesBindingPostProcessor(registry);
			// ConfigurationBeanFactoryMetadata注册
			registerConfigurationBeanFactoryMetadata(registry);
		}
	}

主要注册了两个beanDefinition，分别是ConfigurationPropertiesBindingPostProcessor类和ConfigurationBeanFactoryMetadata类。
看来具体的属性绑定就是这两个类来处理了，笔者继续往下分析

ConfigurationBeanFactoryMetadata

根据spring的bean的生命周期，实现BeanFactoryPostProcessor接口类中的postProcessBeanFactory()方法优先执行

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
			throws BeansException {
		this.beanFactory = beanFactory;
		for (String name : beanFactory.getBeanDefinitionNames()) {
			BeanDefinition definition = beanFactory.getBeanDefinition(name);
			String method = definition.getFactoryMethodName();
			String bean = definition.getFactoryBeanName();
			if (method != null && bean != null) {
				this.beansFactoryMetadata.put(name, new FactoryMetadata(bean, method));
			}
		}
	}

其主要用于获取bean工厂上实现被@Bean注解修饰的方法的bean对象，表明@ConfigurationProperties也可以用于修饰method方法上用于动态注入

ConfigurationPropertiesBindingPostProcessor

根据spring的bean的生命周期，首先我们看下其afterPropertiesSet()实现方法

	@Override
	public void afterPropertiesSet() throws Exception {
		// 获取ConfigurationBeanFactoryMetadata实体类
		this.beanFactoryMetadata = this.applicationContext.getBean(
				ConfigurationBeanFactoryMetadata.BEAN_NAME,
				ConfigurationBeanFactoryMetadata.class);
		// 创建属性绑定类
		this.configurationPropertiesBinder = new ConfigurationPropertiesBinder(
				this.applicationContext, VALIDATOR_BEAN_NAME);
	}

再而我们看下其postProcessBeforeInitialization()方法

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		// 查找是否bean上对应的class上含有ConfigurationProperties注解
		ConfigurationProperties annotation = getAnnotation(bean, beanName,
				ConfigurationProperties.class);
		if (annotation != null) {
			// 开始绑定操作
			bind(bean, beanName, annotation);
		}
		return bean;
	}

Ok，我们继续往下追踪bind()方法

	private void bind(Object bean, String beanName, ConfigurationProperties annotation) {
		ResolvableType type = getBeanType(bean, beanName);
		// 查看类上是否含有@Validated注解
		Validated validated = getAnnotation(bean, beanName, Validated.class);
		Annotation[] annotations = (validated != null
				? new Annotation[] { annotation, validated }
				: new Annotation[] { annotation });
		// class/实例/注解 三个绑定在一起供下述调用
		Bindable<?> target = Bindable.of(type).withExistingValue(bean)
				.withAnnotations(annotations);
		try {
			this.configurationPropertiesBinder.bind(target);
		}
		catch (Exception ex) {
			throw new ConfigurationPropertiesBindException(beanName, bean, annotation,
					ex);
		}
	}

最终的如何绑定本文就不讲解了，主要会读取Environment的属性然后进行对比绑定。
涉及的代码很多，有兴趣的读者可自行分析。

所以基于上述的此加工类的作用，用户也可以直接通过@Bean注解创建Bean

// 直接返回实例，具体的内部属性的绑定则会由ConfigurationPropertiesBindingPostProcessor加工类完成
@Bean
public UserProperty userProperty(){
	return new UserProperty();
}

小结

如果想在springboot中使用外部源的属性值有两个方法

  1. @PropertySource注解加载外部源，然后通过@Value注解来进行注入即可

  2. @ConfigurationProperties注解修饰javabean，其prefix属性是必须配置的，javabean的内部属性与配置文件指定的属性须一致，并且setter方法必须配置，这样可确保属性设置能成功

推荐阅读