Spring Boot @ConfigurationProperties（原理二）

已于 2022-03-20 16:47:44 修改
阅读量834 收藏
点赞数
文章标签： spring boot java spring 后端
于 2022-03-19 21:28:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32868023/article/details/123603241
版权

用法：https://blog.csdn.net/qq_32868023/article/details/123390627
原理一：https://blog.csdn.net/qq_32868023/article/details/123515652
原理二：https://blog.csdn.net/qq_32868023/article/details/123603241
原理三：https://blog.csdn.net/qq_32868023/article/details/123604439
原理四：https://blog.csdn.net/qq_32868023/article/details/123606236
原理五：https://blog.csdn.net/qq_32868023/article/details/123616110

本节主要介绍ConfigurationPropertiesBinder相关背景及实现。ConfigurationPropertiesBinder将@ConfigurationProperties的多种使用方式统一起来，实例化Binder并将属性绑定的具体任务交给Binder，起到一个桥梁作用

1、调用链路

前面分析ConfigurationPropertiesBeanRegistrar的时候注意到，ConfigurationPropertiesBeanRegistrar在注册bean时，对于bindMethod=VALUE_OBJECT的类，会提供一个instanceSupplier，而对于bindMethod=JAVA_BEAN则不会，这两者的处理是有区别的，分别来看

a、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);
		}
	}

b、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);
		}
	}
}

2、ConfigurationPropertiesBinder

ConfigurationPropertiesBinder对外提供bind和bindOrCreate两个方法，这两个方法本身很简单，拿到bindTarget和annotation，创建BindHandler，然后创建Binder，将绑定细节交给Binder。主要有几个问题

  • ConfigurationPropertiesBean是什么
  • Bindable是什么
  • BindHandler是什么，getBindHandler逻辑是怎样的

下面分别看下这三个问题，至于getBinder方法，这里会实例化Binder，后面分析Binder的过程中再分析

	BindResult<?> bind(ConfigurationPropertiesBean propertiesBean) {
		Bindable<?> target = propertiesBean.asBindTarget();
		ConfigurationProperties annotation = propertiesBean.getAnnotation();
		BindHandler bindHandler = getBindHandler(target, annotation);
		return getBinder().bind(annotation.prefix(), target, bindHandler);
	}

	Object bindOrCreate(ConfigurationPropertiesBean propertiesBean) {
		Bindable<?> target = propertiesBean.asBindTarget();
		ConfigurationProperties annotation = propertiesBean.getAnnotation();
		BindHandler bindHandler = getBindHandler(target, annotation);
		return getBinder().bindOrCreate(annotation.prefix(), target, bindHandler);
	}

a、Bindable

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

public final class Bindable<T> {
	private final ResolvableType type;

	private final ResolvableType boxedType;

	private final Supplier<T> value;

	private final Annotation[] annotations;

	private final EnumSet<BindRestriction> bindRestrictions;
}

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

	public enum BindRestriction {

		NO_DIRECT_PROPERTY
	}

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

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

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

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

	public static <T> Bindable<T> 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<T> withAnnotations(Annotation... annotations) {
		return new Bindable<>(this.type, this.boxedType, this.value,
				(annotations != null) ? annotations : NO_ANNOTATIONS, NO_BIND_RESTRICTIONS);
	}

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

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

	public Bindable<T> withSuppliedValue(Supplier<T> 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<Object> bindTarget = Bindable.of(bindType).withAnnotations(annotations);
		if (instance != null) {
			bindTarget = bindTarget.withExistingValue(instance);
		}
		return new ConfigurationPropertiesBean(name, instance, annotation, bindTarget);
	}
VALUE_OBJECT ConfigurationPropertiesBean的创建

ConfigurationPropertiesBeanRegistrar创建beanDefinition的instanceSupplier里，创建了ConfigurationPropertiesBean

	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);
		}
	}

forValueObject里面还是调用了create方式，只是这是instance时null

	static ConfigurationPropertiesBean forValueObject(Class<?> beanClass, String beanName) {
		ConfigurationPropertiesBean propertiesBean = create(beanName, null, beanClass, null);
		Assert.state(propertiesBean != null && propertiesBean.getBindMethod() == BindMethod.VALUE_OBJECT,
				() -> "Bean '" + beanName + "' is not a @ConfigurationProperties value object");
		return propertiesBean;
	}

c、BindHandler

bindHandler规定了5个回调方法，在对Bindable进行绑定的各个时期会调用回调方法，并采用责任链设计模式，可以自由组合多个handler来实现多种功能，这个接口每个方法都有default实现。这里先分析这种设计模式，何时回调这些方法在分析Binder时一并分析

public interface BindHandler {

	BindHandler DEFAULT = new BindHandler() {

	};

	default <T> Bindable<T> onStart(ConfigurationPropertyName name, Bindable<T> target, BindContext context) {
		return target;
	}

	default Object onSuccess(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		return result;
	}

	default Object onCreate(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		return result;
	}

	default Object onFailure(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Exception error)
			throws Exception {
		throw error;
	}

	default void onFinish(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result)
			throws Exception {
	}
}

AbstractBindHandler持有一个默认的parent，对onCreate之外的4个方法重载了实现，调用了parent的相应方法。那么子类再实现这些方法是，只要调用super.onXXX，就能实现责任链组合不同handler的功能，实际上有些子类实现可以不调用super.onXXX，这样责任链到这里就结束了，所有parent的该方法都不会被调用

public abstract class AbstractBindHandler implements BindHandler {

	private final BindHandler parent;

	public AbstractBindHandler() {
		this(BindHandler.DEFAULT);
	}

	public AbstractBindHandler(BindHandler parent) {
		Assert.notNull(parent, "Parent must not be null");
		this.parent = parent;
	}

	@Override
	public <T> Bindable<T> onStart(ConfigurationPropertyName name, Bindable<T> target, BindContext context) {
		return this.parent.onStart(name, target, context);
	}

	@Override
	public Object onSuccess(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		return this.parent.onSuccess(name, target, context, result);
	}

	@Override
	public Object onFailure(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Exception error)
			throws Exception {
		return this.parent.onFailure(name, target, context, error);
	}

	@Override
	public void onFinish(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result)
			throws Exception {
		this.parent.onFinish(name, target, context, result);
	}
}

看几个具体的实现

IgnoreTopLevelConverterNotFoundBindHandler

IgnoreTopLevelConverterNotFoundBindHandler重载了onFailure，如果当前正在绑定最外层的bean、并且抛出了ConverterNotFoundException，则不抛出这个异常。这也我也看懂到底什么情况下会走到这

public class IgnoreTopLevelConverterNotFoundBindHandler extends AbstractBindHandler {
    // construstors

	@Override
	public Object onFailure(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Exception error)
			throws Exception {
		if (context.getDepth() == 0 && error instanceof ConverterNotFoundException) {
			return null;
		}
		throw error;
	}
}

ConfigurationPropertiesBindHandler

这个作用是看绑定的Target上有没有@ConfigurationProperties注解，有的话加入绑定限制：NO_DIRECT_PROPERTY，因为不管BindMethod是JAVA_BEAN还是VALUE_OBJECT，都是外部来创建需要绑定的对象的

	private static class ConfigurationPropertiesBindHandler extends AbstractBindHandler {

		ConfigurationPropertiesBindHandler(BindHandler handler) {
			super(handler);
		}

		@Override
		public <T> Bindable<T> onStart(ConfigurationPropertyName name, Bindable<T> target, BindContext context) {
			return isConfigurationProperties(target.getType().resolve())
					? target.withBindRestrictions(BindRestriction.NO_DIRECT_PROPERTY) : target;
		}

		private boolean isConfigurationProperties(Class<?> target) {
			return target != null && MergedAnnotations.from(target).isPresent(ConfigurationProperties.class);
		}

	}

IgnoreErrorsBindHandler

IgnoreErrorsBindHandler是对@ConfigurationProperties#ignoreInvalidFields()=false时的支持，当某个属性转换错误时吞掉异常返回null

public class IgnoreErrorsBindHandler extends AbstractBindHandler {

	public IgnoreErrorsBindHandler() {
	}

	public IgnoreErrorsBindHandler(BindHandler parent) {
		super(parent);
	}

	@Override
	public Object onFailure(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Exception error)
			throws Exception {
		return (target.getValue() != null) ? target.getValue().get() : null;
	}
}

NoUnboundElementsBindHandler

NoUnboundElementsBindHandler是对@ConfigurationProperties#ignoreUnknownFields()=false的支持。忽略细节，其中boundNames记录绑定过的.properties里的属性名，重载了onSuccess方法和onFinish方法，每次绑定成功后将绑定的属性名保存到boundNames，绑定结束后看当前是否在绑定最顶层bean，如果是的话，从context里拿出所有的propertySource，checkNoUnboundElements方法看有没有没绑定的属性，有的话会抛出异常

public class NoUnboundElementsBindHandler extends AbstractBindHandler {

	private final Set<ConfigurationPropertyName> boundNames = new HashSet<>();

	@Override
	public Object onSuccess(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		this.boundNames.add(name);
		return super.onSuccess(name, target, context, result);
	}
    
	@Override
	public void onFinish(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result)
			throws Exception {
		if (context.getDepth() == 0) {
			checkNoUnboundElements(name, context);
		}
	}
}

ValidationBindHandler

ValidationBindHandler支持了绑定时候对属性值的验证，支持jsr303和自定义的验证。属性validators保存了用来对值进行验证的Validator。onFinish的重载中对值进行了验证，遍历了Validator数组对该值进行验证，有不满足限制条件的将会抛出异常

public class ValidationBindHandler extends AbstractBindHandler {

	private final Validator[] validators;

	public ValidationBindHandler(BindHandler parent, Validator... validators) {
		super(parent);
		this.validators = validators;
	}

    @Override
	public void onFinish(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result)
			throws Exception {
		validate(name, target, context, result);
		super.onFinish(name, target, context, result);
	}
    
    	private void validate(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		if (this.exception == null) {
			Object validationTarget = getValidationTarget(target, context, result);
			Class<?> validationType = target.getBoxedType().resolve();
			if (validationTarget != null) {
				validateAndPush(name, validationTarget, validationType);
			}
		}
		if (context.getDepth() == 0 && this.exception != null) {
			throw this.exception;
		}
	}

	private Object getValidationTarget(Bindable<?> target, BindContext context, Object result) {
		if (result != null) {
			return result;
		}
		if (context.getDepth() == 0 && target.getValue() != null) {
			return target.getValue().get();
		}
		return null;
	}

	private void validateAndPush(ConfigurationPropertyName name, Object target, Class<?> type) {
		ValidationResult result = null;
		for (Validator validator : this.validators) {
			if (validator.supports(type)) {
				result = (result != null) ? result : new ValidationResult(name, target);
				validator.validate(target, result);
			}
		}
		if (result != null && result.hasErrors()) {
			this.exception = new BindValidationException(result.getValidationErrors());
		}
	}
}

BoundPropertiesTrackingBindHandler

BoundPropertiesTrackingBindHandler用来跟踪绑定成功的属性，重载了onSuccess方法，会调用consumer

public class BoundPropertiesTrackingBindHandler extends AbstractBindHandler {

	private final Consumer<ConfigurationProperty> consumer;

	public BoundPropertiesTrackingBindHandler(Consumer<ConfigurationProperty> consumer) {
		Assert.notNull(consumer, "Consumer must not be null");
		this.consumer = consumer;
	}

	@Override
	public Object onSuccess(ConfigurationPropertyName name, Bindable<?> target, BindContext context, Object result) {
		if (context.getConfigurationProperty() != null && name.equals(context.getConfigurationProperty().getName())) {
			this.consumer.accept(context.getConfigurationProperty());
		}
		return super.onSuccess(name, target, context, result);
	}

}

spring里注册了有一个BoundConfigurationProperties，并且ConfigurationPropertiesBinder#getBindHandler在创建BindHandler时用到了，BoundConfigurationProperties#add方法作为方法引用传给Tracker

	private IgnoreTopLevelConverterNotFoundBindHandler getHandler() {
		BoundConfigurationProperties bound = BoundConfigurationProperties.get(this.applicationContext);
		return (bound != null)
				? new IgnoreTopLevelConverterNotFoundBindHandler(new BoundPropertiesTrackingBindHandler(bound::add))
				: new IgnoreTopLevelConverterNotFoundBindHandler();
	}

BoundConfigurationProperties如下，也就是每次绑定成功的属性都会记录到BoundConfigurationProperties#properties里，可以通过get或getAll查询哪些属性被绑定了

public class BoundConfigurationProperties {

	private Map<ConfigurationPropertyName, ConfigurationProperty> properties = new LinkedHashMap<>();

	void add(ConfigurationProperty configurationProperty) {
		this.properties.put(configurationProperty.getName(), configurationProperty);
	}
    
    public ConfigurationProperty get(ConfigurationPropertyName name) {
		return this.properties.get(name);
	}
    
	public Map<ConfigurationPropertyName, ConfigurationProperty> getAll() {
		return Collections.unmodifiableMap(this.properties);
	}
}

BindHandler的组装

ConfigurationPropertiesBinder#getBindHandler为bindTarget创建BindHandler

  • getHandler创建了IgnoreTopLevelConverterNotFoundBindHandler，BoundPropertiesTrackingBindHandler作为parent，可以记录所有绑定成功的属性
  • 如果开启了ignoreInvalidFields，组装上IgnoreErrorsBindHandler
  • 如果关闭了ignoreUnknownFields，组装上NoUnboundElementsBindHandler
  • 如果有Validator，组装上ValidationBindHandler
  • 最后提供了扩展机制，ConfigurationPropertiesBindHandlerAdvisor可以继续组装handler
	private <T> BindHandler getBindHandler(Bindable<T> target, ConfigurationProperties annotation) {
		List<Validator> validators = getValidators(target);
		BindHandler handler = getHandler();
		handler = new ConfigurationPropertiesBindHandler(handler);
		if (annotation.ignoreInvalidFields()) {
			handler = new IgnoreErrorsBindHandler(handler);
		}
		if (!annotation.ignoreUnknownFields()) {
			UnboundElementsSourceFilter filter = new UnboundElementsSourceFilter();
			handler = new NoUnboundElementsBindHandler(handler, filter);
		}
		if (!validators.isEmpty()) {
			handler = new ValidationBindHandler(handler, validators.toArray(new Validator[0]));
		}
		for (ConfigurationPropertiesBindHandlerAdvisor advisor : getBindHandlerAdvisors()) {
			handler = advisor.apply(handler);
		}
		return handler;
	}

	private IgnoreTopLevelConverterNotFoundBindHandler getHandler() {
		BoundConfigurationProperties bound = BoundConfigurationProperties.get(this.applicationContext);
		return (bound != null)
				? new IgnoreTopLevelConverterNotFoundBindHandler(new BoundPropertiesTrackingBindHandler(bound::add))
				: new IgnoreTopLevelConverterNotFoundBindHandler();
	}
}
jjjjjjjjjjjjjjjjjjzq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
在Spring Boot中使用 @ConfigurationProperties 注解
走过程序员的路
02-13 3万+
@ConfigurationProperties根据类型校验和管理application中的bean。 Spring Boot 使用一些松的规则来绑定属性到@ConfigurationProperties bean 并且支持分层结构（hierarchical structure）。 开始创建一个@ConfigurationProperties bean: @Configura
spring boot @ConfigurationProperties注入list
兔子 兔子 你掉毛么
09-30 4105
文章目录背景分析核心步骤拓展 注入list<Map<String,String>> 背景 业务需求是要读取yaml文件配置，注入到List<Map<String, String>>中，查了一下官方文档 To bind to properties like that by using Spring Boot’s Binder utilities (w...
Spring Boot @ConfigurationProperties（原理五）
qq_32868023的博客
03-20 625
Binder负责对一个Bindable进行绑定，一个Bindable的属性可能是一个java对象、数组、集合、Map等各种情况，需要递归的去绑定java对象的属性，数组、集合、Map的元素，其流程简单来说就是：从配置属性源中获取到对应的值，将这个值转化为所需要的类型。本节主要分析下Binder的绑定逻辑和绑定上下文Context
聊聊springboot的ConfigurationProperties的绑定
go4it
09-07 575
本文主要研究一下springboot的ConfigurationProperties的绑定。
@ConfigurationProperties原理浅析
随笔
06-10 844
背景 用springboot开发总会涉及Properties的处理，@ConfigurationProperties这个注解就是用来处理配置文件到属性类的映射问题的，用起来挺简单的，但是到底咋回事一直也没去了解过，现在看看到底怎么一回事。 试水 还是先放上一段代码好说话。 //pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sp...
【SpringBoot】@ConfigurationProperties注解的使用与源码分析
morris
09-27 1534
相信大家肯定了解@Value注解，它可以通过一个配置文件中的属性名与对象的属性进行绑定。@ConfigurationProperties注解的作用其实就类似于使用多个@Value注解同时绑定一个对象的多个属性，@ConfigurationProperties注解用于自动配置绑定，可以将application.properties配置中的值（准确来说是Environment中的属性值）注入到bean对象上，该注解的使用必须先将对象注入到IOC容器中才有配置自动绑定的功能。
【SpringBoot】配置文件的加载与属性值的绑定，Binder以及@ConfigurationProperties(prefix = ““)原理
yrsg666的博客
12-24 490
https://blog.csdn.net/u010634066/article/details/108325717
Spring Boot技术知识点：如何理解@ConfigurationProperties注解
06-20
在Spring Boot框架中，`@ConfigurationProperties`注解是一个核心特性，它允许我们将配置属性从外部化配置文件（如application.properties或application.yml）绑定到Java对象的字段上，从而简化了属性管理。...
Spring Boot：启动原理解析.docx
11-24
在深入探讨Spring Boot启动原理之前，首先需要理解的是Spring Boot的核心注解——`@SpringBootApplication`。这个注解是一个复合注解，包含了`@Configuration`、`@EnableAutoConfiguration`和`@ComponentScan`这三个...
spring boot微服务自定义starter原理详解
08-25
Spring Boot 微服务自定义 Starter 原理详解 Spring Boot 微服务自定义 Starter 是指在 Spring Boot 应用程序中，通过自定义 Starter 来实现微服务架构的自动配置和 Bean 的依赖注入。在本文中，我们将详细介绍 ...
spring-boot-2.7.0.zip源码
06-22
当我们深入研究Spring Boot 2.7.0的源码时，可以更深刻地理解其工作原理，提升我们的开发技能，并有助于解决实际项目中遇到的问题。本文将围绕Spring Boot 2.7.0的源码展开，探讨其中的关键技术和设计模式。 1. **...
spring boot应用启动原理分析.docx
07-12
Spring Boot 应用启动原理分析 Spring Boot 是一个快速开发框架，它简化了构建和运行 Java 应用程序的过程。其核心特点之一是能够将应用直接打包成一个可执行的 JAR 或 WAR 文件，无需额外的 Web 服务器。本文将...
@ConfigurationProperties 注解源码级细节分析（贼细的那种）
HeartException的博客
09-28 2143
进入 ConfigurationProperties @Index注解是什么 @AliasFor：别名 进入 ConfigurationPropertiesBindingPostProcessor ConfigurationPropertiesBindingPostProcessor 实现的接口 postProcessBeforeInitialization(Object bean, String beanName) 方法 ConfigurationPropertiesBean：提供对@Config
@ConfigurationProperties注解的工作原理
追逐消失的记忆
11-22 2471
@ConfigurationProperties是springboot新加入的注解，主要用于配置文件中的指定键值对映射到一个java实体类上。那么它是怎么发挥作用的呢？下面我们将揭开@ConfigurationProperties的魔法。 1 概述 ConfigurationPropertiesBindingPostProcessor这个bean后置处理器，就是来处理bean属性的绑定的，这个bean后置处理器后文将称之为properties后置处理器。你需要知道以下几件事： ioc容器context的e
SpringBoot-Binder的使用
zzzj的博客
04-01 1074
通过Binder以属性名前缀获取属性对象
Handler和Binder的原理
乡下的事业
01-19 2415
Android主线程中不能进行耗时操作，然而在子线程中做完耗时操作则无法更新UI。于是便有了handler ，作为线程之前的通信。 handler的流程分为4个对象，handler ，Message，MessageQueue，Looper。 当应用创建的时候在主线程中创建handler对象，通过要发送的消息保存到Message中，handler通过sendMessage发送到MessageQueue中，Looper对象就会不断的调用loop()方法，不断的从MessageQueue中去除Message交
Binder、Handler、synchronized
zjj1910066023的博客
05-30 347
文章目录一、Activity生命周期方法二、使用步骤1.引入库2.读入数据总结 一、Activity生命周期方法 主要有onCreate()、onStart()、onResume()、onPause()、onStop()、onDestroy()和onRestart()等7个方法。 onCreate:表示Activity正在被创建，这是生命周期的第一个方法。在这个方法中，我们可以做一些初始化工作，比如调用setContentView去加载界面布局资源、初始化Activity所需数据等。 onStart:
Spring Boot 2.0的属性绑定
WGH100817的博客
06-25 755
Spring Boot2.0的属性绑定 原文从Spring boot第一个版本以来，我们可以使用@ConfigurationProperties注解将属性绑定到对象。也可以指定属性的各种不同格式。比如，person.first-name,person.firstName和PERSON_FIRSTNAME都可以使用。这个功能叫做“relaxed ...
【java深入学习第5章】Spring Boot 统一功能的实现及处理方式
liyananweb的博客
07-14 740
通过本文的介绍，我们了解了如何在 Spring Boot 中实现统一的数据返回格式和异常处理，并通过一个图书管理系统的案例代码演示了这些功能的实现。采用统一的功能处理方式可以提高代码的可维护性和可扩展性，提高开发效率，并且可以提供更好的用户体验。希望本文对你有所帮助。AI写论文🔥🔥🔥。
在 Spring Boot 中使用 WebSocket 构建在线日志系统
最新发布
xiaoerbuyu1233的博客
07-15 376
感谢原作者 侵删在 Spring Boot 中使用 WebSocket 构建在线日志系统 - spring 中文网

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值