聊聊Spring中的数据绑定 --- BeanWrapper以及Java内省Introspector和PropertyDescriptor【享学Spring】（下）

    public static void main(String[] args) throws IntrospectionException {
        PropertyDescriptor age = new PropertyDescriptor("age", Child.class);
        System.out.println(age.getPropertyType()); //class java.lang.Integer
        System.out.println(age.getDisplayName()); //age
        // 最重要的两个方法~~~
        System.out.println(age.getReadMethod()); //public java.lang.Integer com.fsx.bean.Child.getAge()
        System.out.println(age.getWriteMethod()); //public void com.fsx.bean.Child.setAge(java.lang.Integer)
    }

public final class CachedIntrospectionResults {
  // 它可以通过在spring.properties里设置这个属性，来关闭内省的缓存~~~
  public static final String IGNORE_BEANINFO_PROPERTY_NAME = "spring.beaninfo.ignore";
  private static final boolean shouldIntrospectorIgnoreBeaninfoClasses = SpringProperties.getFlag(IGNORE_BEANINFO_PROPERTY_NAME);
  // 此处使用了SpringFactoriesLoader这个SPI来加载BeanInfoFactory,唯一实现类是ExtendedBeanInfoFactory
  /** Stores the BeanInfoFactory instances. */
  private static List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
      BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
  static final Set<ClassLoader> acceptedClassLoaders = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  static final ConcurrentMap<Class<?>, CachedIntrospectionResults> strongClassCache = new ConcurrentHashMap<>(64);
  static final ConcurrentMap<Class<?>, CachedIntrospectionResults> softClassCache = new ConcurrentReferenceHashMap<>(64);
  // 被包裹类的BeanInfo~~~也就是目标类
  private final BeanInfo beanInfo;
  // 它缓存了被包裹类的所有属性的属性描述器PropertyDescriptor。
  private final Map<String, PropertyDescriptor> propertyDescriptorCache;
  ... // 其它的都是静态方法
  // 只有它会返回一个实例，此类是单例的设计~  它保证了每个beanClass都有一个CachedIntrospectionResults 对象，然后被缓存起来~
  static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException { ... }
}

<listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>

public final class PropertyAccessorFactory {
  private PropertyAccessorFactory() {
  }
  // 生产一个BeanWrapperImpl（最为常用）
  public static BeanWrapper forBeanPropertyAccess(Object target) {
    return new BeanWrapperImpl(target);
  }
  // 生产一个DirectFieldAccessor
  public static ConfigurablePropertyAccessor forDirectFieldAccess(Object target) {
    return new DirectFieldAccessor(target);
  }
}

// 省略Apple类和Size类，有需要的请参照上篇文章（加上@Getter、@Setter即可
    public static void main(String[] args) {
        Apple apple = new Apple();
        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(apple);
        // ================当作一个普通的PropertyAccessor来使用  默认情况下字段也都必须有初始值才行~===================
        // 设置普通属性
        beanWrapper.setPropertyValue("color", "红色"); //请保证对应字段有set方法才行，否则抛错：Does the parameter type of the setter match the return type of the getter?
        // 设置嵌套属性（注意：此处能够正常work是因为有= new Size()，
        // 否则报错：Value of nested property 'size' is null 下同~）
        beanWrapper.setPropertyValue("size.height", 10);
        // 设置集合/数组属性
        beanWrapper.setPropertyValue("arrStr[0]", "arrStr");
        beanWrapper.setPropertyValue("arrStr[1]", "arrStr1"); // 注意：虽然初始化时初始化过数组了，但是仍以此处的为准
        // =========打印输出
        System.out.println(apple); //Apple(color=红色, size=Size(height=10, width=null), arrStr=[arrStr, arrStr1], listStr=[], map={}, listList=[[]], listMap=[{}])
        // 当作BeanWrapper使用
        PropertyDescriptor[] propertyDescriptors = beanWrapper.getPropertyDescriptors();
        PropertyDescriptor color = beanWrapper.getPropertyDescriptor("color");
        System.out.println(propertyDescriptors.length); // 8
        System.out.println(color); //org.springframework.beans.GenericTypeAwarePropertyDescriptor[name=color]
        System.out.println(beanWrapper.getWrappedClass()); //class com.fsx.bean.Apple
        System.out.println(beanWrapper.getWrappedInstance()); //Apple(color=红色, size=Size(height=10...
    }