代码位置：
spring-beans：org.springframework.beans.BeanWrapper
查看其继承关系，可以发现其有三个主要的父接口和一个实现类，如下所示：
image.png
所以只要了解了这三个接口的能力，那么BeanWrapper的作用就差不多了。

PropertyAccessor

主要的作用：读写Bean的属性；
image.png

源码

  1. public interface PropertyAccessor {
  3.     String NESTED_PROPERTY_SEPARATOR = ".";
  4.     char NESTED_PROPERTY_SEPARATOR_CHAR = '.';
  5.     String PROPERTY_KEY_PREFIX = "[";
  6.     char PROPERTY_KEY_PREFIX_CHAR = '[';
  7.     String PROPERTY_KEY_SUFFIX = "]";
  8.     char PROPERTY_KEY_SUFFIX_CHAR = ']';
  10.     // 判断属性是否可读，其实就是判断是否有get方法
  11.     boolean isReadableProperty(String propertyName);
  13.     // 判断属性是否可写，其实就是判断是否有set方法
  14.     boolean isWritableProperty(String propertyName);
  16.     // 获取属性类型
  17.     @Nullable
  18.     Class<?> getPropertyType(String propertyName) throws BeansException;
  20.     // 获取TypeDescriptor，属性描述器
  21.     @Nullable
  22.     TypeDescriptor getPropertyTypeDescriptor(String propertyName) throws BeansException;
  24.     // 获取属性的值
  25.     @Nullable
  26.     Object getPropertyValue(String propertyName) throws BeansException;
  28.     // 设置属性的值
  29.     void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException;
  31.     // 设置属性的值
  32.     void setPropertyValue(PropertyValue pv) throws BeansException;
  34.     // 批量设置属性的值
  35.     void setPropertyValues(Map<?, ?> map) throws BeansException;
  37.     // 批量设置属性的值
  38.     void setPropertyValues(PropertyValues pvs) throws BeansException;
  40.     // 批量设置属性的值
  41.     void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown)
  42.             throws BeansException;
  44.     // 批量设置属性的值
  45.     void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
  46.             throws BeansException;
  48. }

拿 BeanWrapper测试下

  1. @DisplayName("测试对Bean属性的读写能力")
  2. public class PropertyAccessorTest {
  4.     @Test
  5.     public void beanWrapperTest() {
  6.         Car car = new Car();
  7.         car.setName("笨笨");
  8.         car.setWeight(1000D);
  9.         car.setLabels(Lists.list("a,b,c"));
  10.         car.setProps(Maps.newHashMap("color", "red"));
  12.         BeanWrapper beanWrapper = new BeanWrapperImpl(car);
  13.         Class<?> type = beanWrapper.getPropertyType("type");
  14.         System.out.println("获取属性type：" + type);
  16.         boolean readName = beanWrapper.isReadableProperty("name");
  17.         System.out.println("属性name是否可读：" + readName);
  19.         boolean writeWeight = beanWrapper.isWritableProperty("weight");
  20.         System.out.println("属性weight是否可写：" + writeWeight);
  22.         TypeDescriptor typeDescriptor = beanWrapper.getPropertyTypeDescriptor("labels");
  23.         System.out.println("属性描述器：" + typeDescriptor);
  25.         Object props = beanWrapper.getPropertyValue("props");
  26.         System.out.println("获取属性props值：" + (Map<String, Object>) props);
  28.         beanWrapper.setPropertyValue("name", "1234");
  29.         System.out.println("设置name属性值为 1234");
  30.         System.out.println(car);
  32.         PropertyValue weight = new PropertyValue("weight", 20D);
  33.         beanWrapper.setPropertyValue(weight);
  34.         System.out.println("设置weight属性值为 20");
  35.         System.out.println(car);
  36.     }
  39.     static class Car {
  40.         private String name;
  41.         private double weight;
  42.         private Map<String, Object> props;
  43.         private List<String> labels;
  45.         public Car() {
  46.         }
  48.         public void setName(String name) {
  49.             this.name = name;
  50.         }
  52.         public void setWeight(double weight) {
  53.             this.weight = weight;
  54.         }
  56.         public void setProps(Map<String, Object> props) {
  57.             this.props = props;
  58.         }
  60.         public void setLabels(List<String> labels) {
  61.             this.labels = labels;
  62.         }
  64.         public Map<String, Object> getProps() {
  65.             return props;
  66.         }
  68.         @Override
  69.         public String toString() {
  70.             return "Car{" +
  71.                     "name='" + name + '\'' +
  72.                     ", weight=" + weight +
  73.                     ", props=" + props +
  74.                     ", labels=" + labels +
  75.                     '}';
  76.         }
  77.     }
  78. }

PropertyEditorRegistry

主要作用：封装用户自定义属性编辑器和自带的编辑器。

  1. public interface PropertyEditorRegistry {
  3.     // 注册用户自定义属性编辑器
  4.     void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor);
  6.     // 注册用户自定义属性编辑器
  7.     void registerCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath, PropertyEditor propertyEditor);
  9.     // 查找属性编辑器
  10.     @Nullable
  11.     PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath);
  12. }

类部分继承关系
image.png

除此之外，属性编辑器接口是JDK提供的。java.beans.PropertyEditor。

  1. public interface PropertyEditor {
  3.     void setValue(Object value);
  5.     Object getValue();
  7.     boolean isPaintable();
  9.     void paintValue(java.awt.Graphics gfx, java.awt.Rectangle box);
  11.     String getJavaInitializationString();
  13.     String getAsText();
  15.     void setAsText(String text) throws java.lang.IllegalArgumentException;
  17.     String[] getTags();
  19.     java.awt.Component getCustomEditor();
  21.     boolean supportsCustomEditor();
  23.     void addPropertyChangeListener(PropertyChangeListener listener);
  25.     void removePropertyChangeListener(PropertyChangeListener listener);
  26. }

自定义一个属性编辑器测试。

  1. @DisplayName("自定义属性解析器及注册测试")
  2. public class PropertyEditorRegistryTest {
  4.     @Test
  5.     public void customPropertyEditorRegistryTest() {
  6.         // 注册解析器
  7.         PropertyEditorRegistrySupport registrySupport = new PropertyEditorRegistrySupport();
  8.         registrySupport.registerCustomEditor(ConfigInfo.class, new CustomPropertyEditorRegistry());
  10.         // 解析属性测试
  11.         PropertyEditor customEditor = registrySupport.findCustomEditor(ConfigInfo.class, null);
  12.         customEditor.setAsText("treasure,soul");
  13.         ConfigInfo value = (ConfigInfo) customEditor.getValue();
  14.         System.out.println(value);
  15.     }
  17.     /**
  18.      * 自定义属性解析器
  19.      */
  20.     static class CustomPropertyEditorRegistry extends PropertyEditorSupport {
  22.         private String text;
  24.         @Override
  25.         public void setAsText(String text) throws IllegalArgumentException {
  26.             this.text = text;
  27.         }
  29.         @Override
  30.         public Object getValue() {
  31.             ConfigInfo configInfo = new ConfigInfo();
  32.             configInfo.setWords(Arrays.stream(text.split(",")).collect(Collectors.toList()));
  33.             return configInfo;
  34.         }
  35.     }
  37.     static class ConfigInfo {
  38.         private List<String> words;
  40.         public ConfigInfo() {
  41.         }
  43.         public void setWords(List<String> words) {
  44.             this.words = words;
  45.         }
  47.         @Override
  48.         public String toString() {
  49.             return "ConfigInfo{" +
  50.                     "words=" + words +
  51.                     '}';
  52.         }
  53.     }
  54. }

TypeConverter

主要作用：定义类型转换的方法。
image.png

源码中的方法

  1. public interface TypeConverter {
  3.     // 转换值为要求的类型（如果有必要从String转换）
  5.     @Nullable
  6.     <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType) throws TypeMismatchException;
  9.     @Nullable
  10.     <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
  11.             @Nullable MethodParameter methodParam) throws TypeMismatchException;
  13.     @Nullable
  14.     <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable Field field)
  15.             throws TypeMismatchException;
  17.     @Nullable
  18.     default <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
  19.             @Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException {
  21.         throw new UnsupportedOperationException("TypeDescriptor resolution not supported");
  22.     }
  23. }

BeanWrapper

到此为止，基于上面三个接口，BeanWrapper组合了它们的能力：
属性读写、自定义属性解析器、类型转换。