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

<bean id="myPerson" class="com.fsx.bean.Person">
    <property name="name" value="${diy.name}"/>
    <property name="age" value="18"/>
</bean>

// @since 1.2
class BeanDefinitionValueResolver {
	@Nullable
	public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
		...
		// 处理String类型的值：处理SpEL表达式，但是它并不处理占位符~~~
		else if (value instanceof TypedStringValue) {
			TypedStringValue typedStringValue = (TypedStringValue) value;
			// 此处evaluate最终调用的是我们熟悉的this.beanFactory.evaluateBeanDefinitionString(value, this.beanDefinition)方法
			// 而它底层调用是this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
			Object valueObject = evaluate(typedStringValue);
		}
	}
}

	public void visitBeanDefinition(BeanDefinition beanDefinition) {
		visitParentName(beanDefinition);
		visitBeanClassName(beanDefinition);
		visitFactoryBeanName(beanDefinition);
		visitFactoryMethodName(beanDefinition);
		visitScope(beanDefinition);
		// 这里 它会处理所有的配置的Bean定义的占位符、数组、List等等
		if (beanDefinition.hasPropertyValues()) {
			visitPropertyValues(beanDefinition.getPropertyValues());
		}
		if (beanDefinition.hasConstructorArgumentValues()) {
			ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
			visitIndexedArgumentValues(cas.getIndexedArgumentValues());
			visitGenericArgumentValues(cas.getGenericArgumentValues());
		}
	}

	// 显然，重点在resolveValue这个方法~~~
	protected void visitPropertyValues(MutablePropertyValues pvs) {
		PropertyValue[] pvArray = pvs.getPropertyValues();
		for (PropertyValue pv : pvArray) {
			Object newVal = resolveValue(pv.getValue());
			if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) {
				pvs.add(pv.getName(), newVal);
			}
		}
	}

	@Nullable
	protected Object resolveValue(@Nullable Object value) {
		if (value instanceof BeanDefinition) {
			visitBeanDefinition((BeanDefinition) value);
		}
		...
		else if (value instanceof TypedStringValue) {
			...
			// 处理占位符~~~
			String visitedString = resolveStringValue(stringValue);
			...
		}
	}

<bean class="foo.bar.xxx">
    <property name="referBeanName" ref="otherBeanName" />
</bean>

bw.setPropertyValues(new MutablePropertyValues(deepCopy))