Spring IoC是如何使用BeanWrapper和Java内省结合起来给Bean属性赋值的【享学Spring】（上）

  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    ...
    // 这一步简单的说：通过构造函数实例化Bean后，new BeanWrapperImpl(beanInstance)包装起来
    // 并且：initBeanWrapper(bw);  作用是注册ConversionService和registerCustomEditors() ...
    instanceWrapper = createBeanInstance(beanName, mbd, args);
    ...
    // 给属性赋值：此处会实施BeanWrapper的真正实力~~~~
    // 注意：此处第三个参数传入的是BeanWrapper，而不是源生beanduixiang~~~ 
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    ...
  }

  protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    ...
    // 从Bean定义里面把准备好的值都拿出来~~~
    // 它是个MutablePropertyValues，持有N多个属性的值~~~
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    ...
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
      ...
      // 此处会从后置处理，从里面把依赖的属性，值都拿到。比如大名鼎鼎的AutowiredAnnotationBeanPostProcessor就是在此处拿出值的~~~
      PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
      ...
      pvs = pvsToUse;
    }
    ...
    // 若存在属性pvs ，那就做赋值操作吧~~~（本处才是今天关心的重点~~~）
    if (pvs != null) {
      applyPropertyValues(beanName, mbd, bw, pvs);
    }
  }

  // 本方法传入了beanName和bean定义信息，以及它对应的BeanWrapper和value值们~
  protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if (pvs.isEmpty()) {
      return;
    }
    ...
    MutablePropertyValues mpvs = null;
    List<PropertyValue> original;
    // 说明一下：为何这里还是要判断一下，虽然Spring对PropertyValues的内建实现只有MutablePropertyValues
    // 但是这个是调用者自己也可以实现逻辑的~~~so判断一下最佳~~~~
    if (pvs instanceof MutablePropertyValues) {
      mpvs = (MutablePropertyValues) pvs;
      // 此处有个短路处理：
      // 若该mpvs中的所有属性值都已经转换为对应的类型，则把mpvs设置到BeanWrapper中，返回
      if (mpvs.isConverted()) {
        // Shortcut: use the pre-converted values as-is.
        try {
          bw.setPropertyValues(mpvs);
          return;
        } catch (BeansException ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
      }
      // 否则，拿到里面的属性值们~~~
      original = mpvs.getPropertyValueList();
    } else {
      original = Arrays.asList(pvs.getPropertyValues());
    }
    // 显然，若调用者没有自定义转换器，那就使用BeanWrapper本身~~~（因为BeanWrapper实现了TypeConverter 接口~~）
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
      converter = bw;
    }
    // 获取BeanDefinitionValueResolver，该Bean用于将bean定义对象中包含的值解析为应用于目标bean实例的实际值。
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    // Create a deep copy, resolving any references for values.
    // 此处翻译成深度拷贝不合适，倒不如翻译成深度解析更为合理~~~~
    List<PropertyValue> deepCopy = new ArrayList<>(original.size());
    boolean resolveNecessary = false;
    // 遍历没有被解析的original属性值们~~~~
    for (PropertyValue pv : original) {
      if (pv.isConverted()) {
        deepCopy.add(pv);
      } else { // 那种还没被解析过的PropertyValue此处会一步步解析~~~~
        String propertyName = pv.getName(); // 属性名称
        Object originalValue = pv.getValue(); // 未经类型转换的值（注意：是未经转换的，可能还只是个字符串或者表达式而已~~~~）
        // 最为复杂的解析逻辑~~~
        Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
        Object convertedValue = resolvedValue;
        // 属性可写 并且 不是嵌套（如foo.bar，java中用getFoo().getBar()表示）或者索引（如person.addresses[0]）属性
        boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
        if (convertible) {
          // 用类型转换器进行转换
          convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
        }
        if (resolvedValue == originalValue) {
          if (convertible) {
            pv.setConvertedValue(convertedValue);
          }
          deepCopy.add(pv);
        } else if (convertible && originalValue instanceof TypedStringValue &&
            !((TypedStringValue) originalValue).isDynamic() &&
            !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
          pv.setConvertedValue(convertedValue);
          deepCopy.add(pv);
        }
        else {
          resolveNecessary = true;
          deepCopy.add(new PropertyValue(pv, convertedValue));
        }
      }
    }
    // 标记mpvs已经转换
    if (mpvs != null && !resolveNecessary) {
      mpvs.setConverted();
    }
    // Set our (possibly massaged) deep copy.
    // 使用转换后的值进行填充~~~~~~~~~~
    try {
      bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    } catch (BeansException ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
  }
  // 属性值的转换
  @Nullable
  private Object convertForProperty(@Nullable Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
    // 需要特别注意的是：convertForProperty方法是BeanWrapperImpl的实例方法，并非接口方法
    // 这个方法内部就用到了CachedIntrospectionResults，从何就和Java内省搭上了关系~~~
    if (converter instanceof BeanWrapperImpl) {
      return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
    } else { // 自定义转换器
      PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
      MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
      return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
    }
  }