Spring Boot @ConfigurationProperties（原理）

上一篇讲用法：https://blog.csdn.net/qq_32868023/article/details/123390627
.properties到Bean的属性绑定是在Bean的实例化阶段由ConfigurationPropertiesBindingPostProcessor处理Bean实现的。首先介绍@EnableConfigurationProperties和@ConfigurationPropertiesScan注解输入注册Bean的，然后介绍ConfigurationPropertiesBindingPostProcessor到Binder的调用链路、属性绑定涉及到的重要的类，最后介绍属性绑定核心类Binder。

Bean的注册 1、@EnableConfigurationProperties

@EnableConfigurationProperties通过import EnableConfigurationPropertiesRegistrar这个类来注册Bean，EnableConfigurationPropertiesRegistrar是一个importBeanDefinitionRegistrar，看一下registerBeanDefinitions

	public void registerBeanDefinitions(Annotationmetadata metadata, BeanDefinitionRegistry registry) {
		registerInfrastructureBeans(registry);
		registerMethodValidationExcludeFilter(registry);
		ConfigurationPropertiesBeanRegistrar beanRegistrar = new ConfigurationPropertiesBeanRegistrar(registry);
		getTypes(metadata).forEach(beanRegistrar::register);
	}

这里面做了两个事情
1、registerInfrastructureBeans注册了一些基础设施

	static void registerInfrastructureBeans(BeanDefinitionRegistry registry) {
		ConfigurationPropertiesBindingPostProcessor.register(registry);
		BoundConfigurationProperties.register(registry);
	}

其实就是注册了ConfigurationPropertiesBindingPostProcessor和BoundConfigurationProperties，ConfigurationPropertiesBindingPostProcessor会在bean实例化阶段进行属性绑定；BoundConfigurationProperties作用后面介绍
为什么@Bean+@Component方式时，beanFactory里也会存在ConfigurationPropertiesBindingPostProcessor？
因为有ConfigurationPropertiesAutoConfiguration自动配置类，通过@EnableConfigurationProperties注册了ConfigurationPropertiesBindingPostProcessor

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties
public class ConfigurationPropertiesAutoConfiguration {
}

2、new了一个ConfigurationPropertiesBeanRegistrar，将@EnableConfigurationProperties指定的类注册到beanFactory，看一下bean注册过程

final class ConfigurationPropertiesBeanRegistrar {
    
	void register(Class type) {
		MergedAnnotation annotation = MergedAnnotations
				.from(type, SearchStrategy.TYPE_HIERARCHY).get(ConfigurationProperties.class);
		register(type, annotation);
	}

	void register(Class type, MergedAnnotation annotation) {
		String name = getName(type, annotation);
		if (!containsBeanDefinition(name)) {
			registerBeanDefinition(name, type, annotation);
		}
	}

	private void registerBeanDefinition(String beanName, Class type,
			MergedAnnotation annotation) {
		Assert.state(annotation.isPresent(), () -> "No " + ConfigurationProperties.class.getSimpleName()
				+ " annotation found on  '" + type.getName() + "'.");
		this.registry.registerBeanDefinition(beanName, createBeanDefinition(beanName, type));
	}
}

其实就是创建了BeanDefinition，注册到BeanFactory里，beanName逻辑就是prefix-类全限定名，如下

	private String getName(Class type, MergedAnnotation annotation) {
		String prefix = annotation.isPresent() ? annotation.getString("prefix") : "";
		return (StringUtils.hasText(prefix) ? prefix + "-" + type.getName() : type.getName());
	}

BeanDefinition的创建逻辑，如果bindMethod == BindMethod.VALUE_OBJECT，提供一个InstanceSupplier，这里面调用了Binder#bindOrCreate来绑定bean的属性，这种情况下ConfigurationPropertiesBindingPostProcessor将不会处理这个bean

	private BeanDefinition createBeanDefinition(String beanName, Class type) {
		BindMethod bindMethod = BindMethod.forType(type);
		RootBeanDefinition definition = new RootBeanDefinition(type);
		definition.setAttribute(BindMethod.class.getName(), bindMethod);
		if (bindMethod == BindMethod.VALUE_OBJECT) {
			definition.setInstanceSupplier(() -> createvalueObject(beanName, type));
		}
		return definition;
	}

	private Object createvalueObject(String beanName, Class beanType) {
		ConfigurationPropertiesBean bean = ConfigurationPropertiesBean.forValueObject(beanType, beanName);
		ConfigurationPropertiesBinder binder = ConfigurationPropertiesBinder.get(this.beanFactory);
		try {
			return binder.bindOrCreate(bean);
		}
		catch (Exception ex) {
			throw new ConfigurationPropertiesBindException(bean, ex);
		}
	}

BindMethod是什么呢？

	public enum BindMethod {

		
		JAVA_BEAN,

		
		VALUE_OBJECT;

		static BindMethod forType(Class type) {
			return (ConfigurationPropertiesBindConstructorProvider.INSTANCE.getBindConstructor(type, false) != null)
					? VALUE_OBJECT : JAVA_BEAN;
		}
	}

BindMethod是个枚举，JAVA_BEAN表示用getter、setter来绑定值，VALUE_OBJECT表示用构造器绑定，判断一个类是JAVA_BEAN还是VALUE_BEAN就看有没有@ConstructorBinding注解

2、@ConfigurationPropertiesScan

@ConfigurationPropertiesScan import了ConfigurationPropertiesScanRegistrar，是importBeanDefinitionRegistrar接口的实现。它的逻辑也很简单，就是拿到要扫描的包名，通过ClassPathScanningCandidateComponentProvider这个Scanner去扫描带有ConfigurationProperties的类，然后通过ConfigurationPropertiesBeanRegistrar将扫描到的bean注册到beanFactory

	@Override
	public void registerBeanDefinitions(Annotationmetadata importingClassmetadata, BeanDefinitionRegistry registry) {
		Set packagesToScan = getPackagesToScan(importingClassmetadata);
		scan(registry, packagesToScan);
	}

调用链路分析

有@ConstructorBinding注解和没有该注解时，bean的处理逻辑是不同的，没有该注解的话，BindMethod为JAVA_BEAN，ConfigurationPropertiesBindingPostProcessor会进行属性绑定；有该注解的话，BindMethod为VALUE_OBJECT，ConfigurationPropertiesBindingPostProcessor不会处理，但是BeanDefinition有instanceSupplier，这里面会进行属性绑定。两者都会通过ConfigurationPropertiesBinder进行属性绑定，而ConfigurationPropertiesBinder处理BindHandler、Validator等逻辑，最终调用Binder进行绑定

1、JAVA_BEAN的属性绑定

ConfigurationPropertiesBindingPostProcessor处理JAVA_BEAN的属性绑定，关键代码如下，逻辑就是为每个需要绑定的bean构造了一个ConfigurationPropertiesBean，然后调用了ConfigurationPropertiesBinder这个binder进行属性绑定，bind方法里会判断是否是VALUE_OBJECT，如果是直接返回不处理

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		bind(ConfigurationPropertiesBean.get(this.applicationContext, bean, beanName));
		return bean;
	}

	private void bind(ConfigurationPropertiesBean bean) {
		if (bean == null || hasBoundValueObject(bean.getName())) {
			return;
		}
		Assert.state(bean.getBindMethod() == BindMethod.JAVA_BEAN, "Cannot bind @ConfigurationProperties for bean '"
				+ bean.getName() + "'. Ensure that @ConstructorBinding has not been applied to regular bean");
		try {
			this.binder.bind(bean);
		}
		catch (Exception ex) {
			throw new ConfigurationPropertiesBindException(bean, ex);
		}
	}

2、VALUE_OBJECT的属性绑定

ConfigurationPropertiesBeanRegistrar在为VALUE_OBJECT创建BeanDefinition时提供了一个instanceSupplier，这个instanceSupplier里面调用ConfigurationPropertiesBinder进行属性绑定

final class ConfigurationPropertiesBeanRegistrar {
    
    private BeanDefinition createBeanDefinition(String beanName, Class type) {
		BindMethod bindMethod = BindMethod.forType(type);
		RootBeanDefinition definition = new RootBeanDefinition(type);
		definition.setAttribute(BindMethod.class.getName(), bindMethod);
		if (bindMethod == BindMethod.VALUE_OBJECT) {
			definition.setInstanceSupplier(() -> createvalueObject(beanName, type));
		}
		return definition;
	}

	private Object createvalueObject(String beanName, Class beanType) {
		ConfigurationPropertiesBean bean = ConfigurationPropertiesBean.forValueObject(beanType, beanName);
		ConfigurationPropertiesBinder binder = ConfigurationPropertiesBinder.get(this.beanFactory);
		try {
			return binder.bindOrCreate(bean);
		}
		catch (Exception ex) {
			throw new ConfigurationPropertiesBindException(bean, ex);
		}
	}
}

3、ConfigurationPropertiesBinder

ConfigurationPropertiesBinder对外提供bind和bindOrCreate两个方法，从这里开始涉及到细节和设计上的问题

a、Bindable

bindable封装的是能被Binder进行属性绑定的source（可以指一个类（需要先创建一个instance）、也可以指一个instance、还可以是instance里的一个需要被绑定的属性），里面包含这个类、instance的Supplier、注解、绑定限制，属性如下：

public final class Bindable {
	private final ResolvableType type;

	private final ResolvableType boxedType;

	private final Supplier value;

	private final Annotation[] annotations;

	private final EnumSet bindRestrictions;
}

type、boxedType就是解析过的类型，value是一个Supplier、可能是null，annotations就是这个类上的注解，bindRestrictions是绑定限制，目前BindRestriction只有一个枚举值NO_DIRECT_PROPERTY，不要直接绑定Spring bean，而对其属性进行绑定

	public enum BindRestriction {

		NO_DIRECT_PROPERTY
	}

这个类提供了一些of方法和with方法来方便的创建bindable对象
of方法

	public static  Bindable of(Class type) {
		Assert.notNull(type, "Type must not be null");
		return of(ResolvableType.forClass(type));
	}

	public static  Bindable ofInstance(T instance) {
		Assert.notNull(instance, "Instance must not be null");
		Class type = (Class) instance.getClass();
		return of(type).withExistingValue(instance);
	}

    public static  Bindable> listOf(Class elementType) {
		return of(ResolvableType.forClassWithGenerics(List.class, elementType));
	}

	public static  Bindable of(ResolvableType type) {
		Assert.notNull(type, "Type must not be null");
		ResolvableType boxedType = box(type);
		return new Bindable<>(type, boxedType, null, NO_ANNOTATIONS, NO_BIND_RESTRICTIONS);
	}

with方法

	public Bindable withAnnotations(Annotation... annotations) {
		return new Bindable<>(this.type, this.boxedType, this.value,
				(annotations != null) ? annotations : NO_ANNOTATIONS, NO_BIND_RESTRICTIONS);
	}

	public Bindable withExistingValue(T existingValue) {
		Assert.isTrue(
				existingValue == null || this.type.isArray() || this.boxedType.resolve().isInstance(existingValue),
				() -> "ExistingValue must be an instance of " + this.type);
		Supplier value = (existingValue != null) ? () -> existingValue : null;
		return new Bindable<>(this.type, this.boxedType, value, this.annotations, this.bindRestrictions);
	}

	public Bindable withBindRestrictions(BindRestriction... additionalRestrictions) {
		EnumSet bindRestrictions = EnumSet.copyOf(this.bindRestrictions);
		bindRestrictions.addAll(Arrays.asList(additionalRestrictions));
		return new Bindable<>(this.type, this.boxedType, this.value, this.annotations, bindRestrictions);
	}

	public Bindable withSuppliedValue(Supplier suppliedValue) {
		return new Bindable<>(this.type, this.boxedType, suppliedValue, this.annotations, this.bindRestrictions);
	}

b、ConfigurationPropertiesBean

ConfigurationPropertiesBean封装了一个需要绑定的bean，跟bindable的区别是ConfigurationPropertiesBean跟spring里bean是对应的，而bindable指的是一个能被绑定的source，可以是类、instance、或者一个field，bindable可以脱离spring使用

public final class ConfigurationPropertiesBean {

	private final String name;

	private final Object instance;

	private final ConfigurationProperties annotation;

	private final Bindable bindTarget;

	private final BindMethod bindMethod;
}

name就是beanName，instance就是bean实例，bindMethod=VALUE_OBJECT时instance为null

JAVA_BEAN ConfigurationPropertiesBean的创建

ConfigurationPropertiesBindingPostProcessor里处理每个bean时调用ConfigurationPropertiesBean#get来创建

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		bind(ConfigurationPropertiesBean.get(this.applicationContext, bean, beanName));
		return bean;
	}

创建过程如下，调用了Bindable bindTarget = Bindable.of(bindType).withAnnotations(annotations);创建了bindTarget，然后new了一个ConfigurationPropertiesBean

	public static ConfigurationPropertiesBean get(ApplicationContext applicationContext, Object bean, String beanName) {
		Method factoryMethod = findFactoryMethod(applicationContext, beanName);
		return create(beanName, bean, bean.getClass(), factoryMethod);
	}

	private static ConfigurationPropertiesBean create(String name, Object instance, Class type, Method factory) {
		ConfigurationProperties annotation = findAnnotation(instance, type, factory, ConfigurationProperties.class);
		if (annotation == null) {
			return null;
		}
		Validated validated = findAnnotation(instance, type, factory, Validated.class);
		Annotation[] annotations = (validated != null) ? new Annotation[] { annotation, validated }
				: new Annotation[] { annotation };
		ResolvableType bindType = (factory != null) ? ResolvableType.forMethodReturnType(factory)
				: ResolvableType.forClass(type);
		Bindable

Spring Boot @ConfigurationProperties（原理）

Java相关栏目本月热门文章