11、IoC之依赖注入（5）-属性注入过程

在得到一个代理生成的目标对象之后，需要对目标对象进行属性注入，具体的实现是在AbstractAutowireCapableBeanFactory类中的populateBean方法中实现。具体代码如下：

 

	// AbstractAutowireCapableBeanFactory
	// 使用bean定义中的属性值在给定的BeanWrapper中填充bean实例。
	protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
		// 获取BeanDefiniton中设置的属性值
		PropertyValues pvs = mbd.getPropertyValues();
		// BeanWrapper为空
		if (bw == null) {
			// 属性值不为空
			if (!pvs.isEmpty()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				return;
			}
		}

		//给任何InstantiationAwareBeanPostProcessors提供在设置属性之前
		//修改bean状态的机会。 例如，这可以用来支持字段注入的风格。
		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}
		// 开始依赖注入，首先处理Autowire自动装配的注入   
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// 根据 名称 添加适用的基于自动装配的属性值。
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// 根据 类型 添加适用的基于自动装配的属性值。
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}
		
		// 是否要配置bean的后处理器
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		// 是否具有依赖  就是继承基类
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			// 提取依赖描述符
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
		// 对属性进行注入
		applyPropertyValues(beanName, mbd, bw, pvs);
	}	
	
	// AbstractAutowireCapableBeanFactory
	// 解析并注入属性
	// 应用给定的属性值，
	// 解析对这个bean工厂中的其他bean的任何运行时引用。
	// 必须使用深层复制，所以我们不会修改这个属性。
	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs == null || pvs.isEmpty()) {
			return;
		}
		// 用对象描述属性
		MutablePropertyValues mpvs = null;
		List<PropertyValue> original;

		if (System.getSecurityManager() != null) {
			if (bw instanceof BeanWrapperImpl) {
				// 设置安全的上下文环境
				((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
			}
		}

		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			// 属性值已经转换
			if (mpvs.isConverted()) {
				// 为实例化对象设置一个属性值
				try {
					bw.setPropertyValues(mpvs);
					return;
				}
				catch (BeansException ex) {
					throw new BeanCreationException(
							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
				}
			}
			// 获得以原始形式返回基础的PropertyValue对象列表
			original = mpvs.getPropertyValueList();
		}
		else {
			original = Arrays.asList(pvs.getPropertyValues());
		}
		// 处理用户自定义类型
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		创建一个BeanDefinition值的解析器
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// 创建一个深拷贝列表，用于存储实际注入的对象
		List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
		boolean resolveNecessary = false;
		for (PropertyValue pv : original) {
			// 属性值已经转换
			if (pv.isConverted()) {
				// 直接加入深拷贝List
				deepCopy.add(pv);
			}
			// 属性值还没有转换
			else {
				String propertyName = pv.getName();
				// 原始属性值 
				Object originalValue = pv.getValue();
				// 待转换的属性值
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				
				// 属性值是否可以转换
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					// 转换指定目标属性的给定值。
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
			
				// 可能将转换的值存储在合并的bean定义中，
				// 为了避免为每个创建的bean实例重新转换。
				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));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
			// 标记此对象仅包含转换值（即不再需要运行时分辨）。
			// 该对象已经转换过了
			mpvs.setConverted();
		}

		// 进行深拷贝，即实现属性的依赖注入
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}

根据代码，可以看出在这个属性注入的过程中分了两种情况：

1、 直接引用，不需要解析和转换，直接等待属性注入；

2、 间接引用，需要解析和转换，那么这种就需要先对属性进行解析和转换。