Spring源码：bean创建（四）属性注入

一、populateBean

在创建了bean的实例后，Spring的下一步工作就是为bean注入其依赖的属性：

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		//传入的beanWrapper为空，如果属性不为空就抛出异常，否则返回null
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// 应用后处理器InstantiationAwareBeanPostProcessor，调用其postProcessAfterInstantiation方法
		// 在注入属性前修改bean状态,如果方法中发挥false的话，可以终止后面代码运行，直接返回
		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;
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		//为bean注入PropertyValues中包含的属性
		//这种注入方式适用的是配置文件中通过配置的属性并且显示在配置文件中配置了autowireMode属性
		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;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
		//如果存在InstantiationAwareBeanPostProcessor后处理器 || 需要进行依赖检查
		//一般情况下，Spring会提前注册几种存在InstantiationAwareBeanPostProcessor
		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						//应用后处理器InstantiationAwareBeanPostProcessor，调用其postProcessPropertyValues方法
						//作用是对需要进行依赖检查的属性进行处理
						//Autowired等注解的属性就是在这里完成注入的
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
		//注入配置文件中配置的属性
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

处理流程：

1. 应用InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation方法。该方法可以控制是否继续进行属性填充
2. 获取配置文件中配置的property属性
3. 应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，完成对注入属性的验证、处理。值得注意的是，AutowiredAnnotationBeanPostProcessor会负责注入标注有@Autowired等注解的属性.
4. 将配置的属性注入到bean中

二、配置属性的注入

对于通过配置文件中给配置节点来完成注入的代码实现在applyPropertyValues中：

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs == null || pvs.isEmpty()) {
			return;
		}
		MutablePropertyValues mpvs = null;
		List original;
		if (System.getSecurityManager() != null) {
			if (bw instanceof BeanWrapperImpl) {
				((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
			}
		}
		//BeanDefinition中定义的PropertyValues的类型就是MutablePropertyValues，所以为true
		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			//属性是否已经转换过类型了
			if (mpvs.isConverted()) {
				// 如果属性已经转换为对应的类型，则直接设置到BeanWrapper中
				try {
					bw.setPropertyValues(mpvs);
					return;
				}
				//catch 
			}
			//获取配置文件中配置的原始值
			original = mpvs.getPropertyValueList();
		}
		else {
			original = Arrays.asList(pvs.getPropertyValues());
		}
		//获取类型转换器，如果没有配置的话为null
		TypeConverter converter = getCustomTypeConverter();
		//如果类型转换器为null，则使用BeanWrapper作为类型转换器，因为BeanWrapper实现了TypeConverter接口
		if (converter == null) {
			converter = bw;
		}
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// 遍历属性，并将配置的值转换为对应的类型
		List deepCopy = new ArrayList(original.size());
		boolean resolveNecessary = false;
		for (PropertyValue pv : original) {
			if (pv.isConverted()) {
				deepCopy.add(pv);
			}
			else {
				String propertyName = pv.getName();
				Object originalValue = pv.getValue();
				//解析原始值，例如RuntimeBeanReference类型，会获取BeanFactory中其真正的bean；String或TypedStringValue类型会视为一个表达式进行求值等
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				//是否能进行类型转换 = 可以写入 && 没有'.'或者'[' 符号
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					//将value转换为对应的类型
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}

				//为了避免每次创建bean的时候都重复转换类型，Spring会尽可能地将转换好的值放入对应的BeanDefinition中
				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();
		}

		// 将解析、转换好的属性设置到BeanWrapper中
		//之所以bean需要BeanWrapper包装一次，也是为了方便给bean填充属性
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}

最终是通过BeanWrapper的setPropertyValues来完成属性的注入，而前面的工作主要是解析配置文件配置的原始值，因为原始值可能是最终注入的值（String类型），也可能需要被解析后才能被应用，所以Spring花费大量工作来解析原始值。解析完成后，如果有必要还得转换值的类型，最终将解析、转换好的值注入到bean中。

	public void setPropertyValues(PropertyValues pvs) throws BeansException {
		setPropertyValues(pvs, false, false);
	}

	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
			throws BeansException {
		//保存注入时抛出的PropertyAccessException
		List propertyAccessExceptions = null;
		//获取需要注入的propertyValue列表
		List propertyValues = (pvs instanceof MutablePropertyValues ?
				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
		for (PropertyValue pv : propertyValues) {
			try {
				// 注入属性
				setPropertyValue(pv);
			}
			catch (NotWritablePropertyException|NullValueInNestedPathException ex) {
				if (!ignoreUnknown) {
					throw ex;
				}
			} catch (PropertyAccessException ex) {
				if (propertyAccessExceptions == null) {
					propertyAccessExceptions = new LinkedList();
				}
				propertyAccessExceptions.add(ex);
			}
		}

		// 如果注入时抛出的PropertyAccessException不为空，Spring会收集起来，在这里统一抛出
		if (propertyAccessExceptions != null) {
			PropertyAccessException[] paeArray =
					propertyAccessExceptions.toArray(new PropertyAccessException[propertyAccessExceptions.size()]);
			throw new PropertyBatchUpdateException(paeArray);
		}
	}

在上面的代码中主要是进行统一的异常处理和遍历属性列表，真正的属性注入还需要继续向下调用设置单个属性的方法setPropertyValue：

	public void setPropertyValue(PropertyValue pv) throws BeansException {
		setPropertyValue(pv.getName(), pv.getValue());
	}
	
	public void setPropertyValue(String propertyName, Object value) throws BeansException {
		AbstractNestablePropertyAccessor nestedPa;
		try {
			//将属性访问的工作交给AbstractNestablePropertyAccessor完成
			//当配置的属性名propertyName中包含'.'或者'['这样字符时，代表需要设置嵌套属性
			//如果存在嵌套属性，Spring会递归向下获取最终设置的属性，比如：a.b.c，Spring会递归调用获取到b，c是需要设置的属性
			//如果没有嵌套属性的话。会返回BeanWrapper自身
			nestedPa = getPropertyAccessorForPropertyPath(propertyName);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
					"Nested property in path '" + propertyName + "' does not exist", ex);
		}
		PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
		//设置属性
		nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
	}

上面主要是解析propertyName，处理嵌套的属性，确定最终需要设置的属性

	protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
		//如果propertyName中存在'['的情况，即存在数组下标
		if (tokens.keys != null) {
			processKeyedProperty(tokens, pv);
		}
		else {
			//非数组、容器类型的属性设置
			processLocalProperty(tokens, pv);
		}
	}

属性设置分为了数组类型设置和非数组类型设置，我们分析更为普遍的非数组类型：

	private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
		//属性设置交由PropertyHandler完成
        //Spring会使用反射获取属性的getter和setter方法
		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
		//如果不存在属性或者属性不是可写的
		if (ph == null || !ph.isWritable()) {
			//如果属性是Optional类型，则直接返回
			if (pv.isOptional()) {
				//日志，略
				return;
			} else {
				//其他情况会抛出异常
				throw createNotWritablePropertyException(tokens.canonicalName);
			}
		}

		Object oldValue = null;
		try {
			//获取属性值
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			//需要转换值的类型
			if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
				//如果已经完成了类型转换，直接使用就可以了
				if (pv.isConverted()) {
					valueToApply = pv.getConvertedValue();
				}
				else {
					//如果需要读取旧值(默认为false) && 值是可读的
					if (isExtractOldValueForEditor() && ph.isReadable()) {
						try {
							oldValue = ph.getValue();
						}
						catch (Exception ex) {
							//无法读取旧值
						}
					}
					//类型装换
					valueToApply = convertForProperty(
							tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
				}
				pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
			}
			//使用PropertyHandler完成属性的注入
			ph.setValue(this.wrappedObject, valueToApply);
		}
		//catch略
	}

下面就是注入属性的代码：

		public void setValue(final Object object, Object valueToApply) throws Exception {
			//获取解析好的setter方法
			final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
					((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
					this.pd.getWriteMethod());
			//设置Method的访问权限
			if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) {
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction