玩转springboot之springboot属性绑定原理

属性绑定原理

   注意：使用版本为spring-boot-2.2.2.RELEASE
  在进行自界说设置的时间，我们通常使用@ConfigurationProperties注解来进行设置文件和设置类的映射，为什么可以映射呢？
主要靠的是@EnableConfigurationProperties注解来进行主动的将外部设置绑定到@ConfigurationProperties标注的类的属性中

1. @Target(ElementType.TYPE)
2. @Retention(RetentionPolicy.RUNTIME)
3. @Documented
4. @Import(EnableConfigurationPropertiesRegistrar.class)
5. public @interface EnableConfigurationProperties

复制代码

看到该注解上引入了一个EnableConfigurationPropertiesRegistrar类，这个应该就是关键了

1. class EnableConfigurationPropertiesRegistrar implements ImportBeanDefinitionRegistrar {
3.    @Override
4.    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
5.       registerInfrastructureBeans(registry);
6.       ConfigurationPropertiesBeanRegistrar beanRegistrar = new ConfigurationPropertiesBeanRegistrar(registry);
7.      // 将配置的XxxProperties注册到spring容器中
8.       getTypes(metadata).forEach(beanRegistrar::register);
9.    }
11.   // @EnableConfigurationProperties注解中配置的value值,比如@EnableConfigurationProperties(ServerProperties.class),那么得到的值是ServerProperties.class
12.    private Set<Class<?>> getTypes(AnnotationMetadata metadata) {
13.       return metadata.getAnnotations().stream(EnableConfigurationProperties.class)
14.             .flatMap((annotation) -> Arrays.stream(annotation.getClassArray(MergedAnnotation.VALUE)))
15.             .filter((type) -> void.class != type).collect(Collectors.toSet());
16.    }
18.    @SuppressWarnings("deprecation")
19.    static void registerInfrastructureBeans(BeanDefinitionRegistry registry) {
20.      // 将ConfigurationPropertiesBindingPostProcessor注册到spring容器中，ConfigurationPropertiesBindingPostProcessor用于属性绑定
21.       ConfigurationPropertiesBindingPostProcessor.register(registry);
22.       ConfigurationPropertiesBeanDefinitionValidator.register(registry);
23.       ConfigurationBeanFactoryMetadata.register(registry);
24.    }
26. }

复制代码

在代码中我们看到了其向spring容器中注册了ConfigurationPropertiesBindingPostProcessor后置处置惩罚器，看该类的名字像是进行属性绑定的，来看一下该类的代码逻辑是如何进行属性绑定的

1. // 只展示了关键方法，其他方法没有展示
2. public class ConfigurationPropertiesBindingPostProcessor
3.       implements BeanPostProcessor, PriorityOrdered, ApplicationContextAware, InitializingBean {
5.    @Override
6.    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
7.      // 进行绑定
8.       bind(ConfigurationPropertiesBean.get(this.applicationContext, bean, beanName));
9.       return bean;
10.    }
12.    private void bind(ConfigurationPropertiesBean bean) {
13.       if (bean == null || hasBoundValueObject(bean.getName())) {
14.          return;
15.       }
16.       Assert.state(bean.getBindMethod() == BindMethod.JAVA_BEAN, "Cannot bind @ConfigurationProperties for bean '"
17.             + bean.getName() + "'. Ensure that @ConstructorBinding has not been applied to regular bean");
18.       try {
19.          this.binder.bind(bean);
20.       }
21.       catch (Exception ex) {
22.          throw new ConfigurationPropertiesBindException(bean, ex);
23.       }
24.    }
25. }
27. // ConfigurationPropertiesBinder类
28. BindResult<?> bind(ConfigurationPropertiesBean propertiesBean) {
29.   // 返回一个绑定了XxxProperties类的Bindable对象target，这个target对象即被外部属性值注入的目标对象
30.                 Bindable<?> target = propertiesBean.asBindTarget();
31.   // 得到@ConfigurationProperties注解
32.                 ConfigurationProperties annotation = propertiesBean.getAnnotation();
33.   // 得到BindHandler对象（默认是IgnoreTopLevelConverterNotFoundBindHandler对象），
34.    // 用于对ConfigurationProperties注解的ignoreUnknownFields等属性的处理
35.                 BindHandler bindHandler = getBindHandler(target, annotation);
36.           // 得到一个Binder对象，并利用其bind方法执行外部属性绑定逻辑
37.                 return getBinder().bind(annotation.prefix(), target, bindHandler);
38.         }
41. // Binder类
42. private <T> T bind(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler, Context context,
43.                         boolean allowRecursiveBinding, boolean create) {
44.   // 清空Binder的configurationProperty属性值
45.                 context.clearConfigurationProperty();
46.                 try {
47.       // 调用BindHandler的onStart方法，执行一系列的责任链对象的该方法
48.                         Bindable<T> replacementTarget = handler.onStart(name, target, context);
49.                         if (replacementTarget == null) {
50.                                 return handleBindResult(name, target, handler, context, null, create);
51.                         }
52.                         target = replacementTarget;
53.       // 调用bindObject方法对Bindable对象target的属性进行绑定外部配置的值，并返回赋值给bound对象
54.                         Object bound = bindObject(name, target, handler, context, allowRecursiveBinding);
55.       // 封装handleBindResult对象并返回，注意在handleBindResult的构造函数中会调用BindHandler的onSucess，onFinish方法
56.                         return handleBindResult(name, target, handler, context, bound, create);
57.                 }
58.                 catch (Exception ex) {
59.                         return handleBindError(name, target, handler, context, ex);
60.                 }
61.         }

复制代码

绑定对象的真正操纵在bindObject方法中

1. private <T> Object bindObject(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler,
2.                         Context context, boolean allowRecursiveBinding) {
3.           // 从propertySource中的配置属性，获取ConfigurationProperty对象property即application.properties配置文件中若有相关的配置的话,那么property将不会为null
4.                 ConfigurationProperty property = findProperty(name, context);
5.   // 若property为null，则不会执行后续的属性绑定相关逻辑
6.                 if (property == null && containsNoDescendantOf(context.getSources(), name) && context.depth != 0) {
7.                         return null;
8.                 }
9.   // 根据target类型获取不同的Binder，可以是null（普通的类型一般是Null）,MapBinder,CollectionBinder或ArrayBinder
10.                 AggregateBinder<?> aggregateBinder = getAggregateBinder(target, context);
11.   // 若aggregateBinder不为null，则调用bindAggregate并返回绑定后的对象
12.                 if (aggregateBinder != null) {
13.                         return bindAggregate(name, target, handler, context, aggregateBinder);
14.                 }
15.   // 若property不为null
16.                 if (property != null) {
17.                         try {
18.         // 绑定属性到对象中，比如配置文件中设置了server.port=8888，那么将会最终调用bindProperty方法进行属性设置
19.                                 return bindProperty(target, context, property);
20.                         }
21.                         catch (ConverterNotFoundException ex) {
22.                                 // We might still be able to bind it using the recursive binders
23.                                 Object instance = bindDataObject(name, target, handler, context, allowRecursiveBinding);
24.                                 if (instance != null) {
25.                                         return instance;
26.                                 }
27.                                 throw ex;
28.                         }
29.                 }
30.   // 只有@ConfigurationProperties注解的类进行外部属性绑定才会走这里
31.                 return bindDataObject(name, target, handler, context, allowRecursiveBinding);
32.         }
36. private Object bindDataObject(ConfigurationPropertyName name, Bindable<?> target, BindHandler handler,
37.                         Context context, boolean allowRecursiveBinding) {
38.                 if (isUnbindableBean(name, target, context)) {
39.                         return null;
40.                 }
41.                 Class<?> type = target.getType().resolve(Object.class);
42.                 if (!allowRecursiveBinding && context.isBindingDataObject(type)) {
43.                         return null;
44.                 }
45.   // 新建一个DataObjectPropertyBinder的实现类对象，注意这个对象实现了bindProperty方法
46.                 DataObjectPropertyBinder propertyBinder = (propertyName, propertyTarget) -> bind(name.append(propertyName),
47.                                 propertyTarget, handler, context, false, false);
48.                 return context.withDataObject(type, () -> {
49.                         for (DataObjectBinder dataObjectBinder : this.dataObjectBinders) {
50.         // 真正实现将外部配置属性绑定到@ConfigurationProperties注解的XxxProperties类的属性中的逻辑
51.                                 Object instance = dataObjectBinder.bind(name, target, context, propertyBinder);
52.                                 if (instance != null) {
53.                                         return instance;
54.                                 }
55.                         }
56.                         return null;
57.                 });
58.         }

复制代码

  https://zhhll.icu/2021/框架/springboot/源码/3.属性绑定原理/

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。