Spring IOC - 依赖注入（Bean实例化过程）

双十一过去了，终于可以把这篇博客补上了。

本文将分析BeanWrapperImpl，出现了大量的源码。如果你对BeanWrapper有相当的了解，请略过；如果想稍微了解一下BeanWrapper，可能需要关注一下源码。

--------------------------------------------

学习 Spring 核心是一件比较耗费精力的过程，代码太多，代码的层次也比较深。每次我都是在上午看代码，把一天中精力比较集中的时间段留给了他。在【Spring IOC -依赖注入（概述 getBean）】一文中，我们了解了 Spring 依赖注入的大概过程。本次我们要着重说明一下依赖注入中的 Bean 实例化，以及自动注入的实现方式。

 

1. 本次分享需要解决的几个问题

• 不得不说的 BeanWrapper
• 实例化的经过的各层传递
• 常用的自动注入如何实现

 

2. 不得不说的 BeanWrapper

BeanWrapper 是 Spring 框架中十分重要的技术支持组件。他的实现类大概有1千多行代码，很长，但是功能也是比较内聚的。BeanWrapper 的主要作用是把所有的 Bean 的属性都可以集中处理。这种集中处理的机制来自于 Java 的反射。通过 Java 的反射，可以把 Bean 的属性抽取出来，然后在通过反射的方式进行赋值。这种方式使 Spring 可以用同一种方式来处理 Bean 的属性。

 

2.1  BeanWrapper 的实现类图

 

上图中可以发现默认实现 BeanWrapper 的实现类 BeanWrapperImpl 通过继承 AbstractPropertyAccessor 来增强其属性的赋值功能。这个过程中你可以定义自己的类型处理器。在org.springframework.beans.propertyeditors包下面是 Spring 扩展自己定义的类型处理器，如果需要可以扩展自己处理器注册到容器中。这些不是这次讨论的主题，就不详细说明了。

 

2.2 构建 BeanWrapper 的实例

构建一个 BeanWrapper 实例有很多种方式，可以指定需要实例化的 Bean.class，可以指定需要包装的 Bean 实例等。下面就 BeanWrapper 的属性的进行说明。

Object object;	被包装的Bean实例，如果传递了对应的 class，通过 BeanUtils 实例化一个
String nestedPath = "";	嵌套路径。例如如果BeanA里面包含属性BeanB，那么访问BeanA的BeanB属性的路径是“beanA.beanB”。那BeanB的嵌套路径就是“beanA.”
Object rootObject;	嵌套上级Bean实例，如果没有上级，就是自己本身
TypeConverterDelegate typeConverterDelegate;	类型转换器代理实现
CachedIntrospectionResults cachedIntrospectionResults;	缓存Bean实例对应的class、属性等信息（beanInfo），在使用的Bean的信息，可以从中获取。（Java 内省机制）
Map nestedBeanWrappers;	保存嵌套路径到BeanWrapper实例的映射关系保存。

 

 

构造方法重要的有两个：

/**
 * Create new BeanWrapperImpl for the given object,
 * registering a nested path that the object is in.
 * @param object object wrapped by this BeanWrapper
 * @param nestedPath the nested path of the object
 * @param rootObject the root object at the top of the path
 */
public BeanWrapperImpl(Object object, String nestedPath, Object rootObject) {
	registerDefaultEditors();
	setWrappedInstance(object, nestedPath, rootObject);
}

/**
 * Create new BeanWrapperImpl for the given object,
 * registering a nested path that the object is in.
 * @param object object wrapped by this BeanWrapper
 * @param nestedPath the nested path of the object
 * @param superBw the containing BeanWrapper (must not be null)
 */
private BeanWrapperImpl(Object object, String nestedPath, BeanWrapperImpl superBw) {
	setWrappedInstance(object, nestedPath, superBw.getWrappedInstance());
	setExtractOldValueForEditor(superBw.isExtractOldValueForEditor());
	setAutoGrowNestedPaths(superBw.isAutoGrowNestedPaths());
	setAutoGrowCollectionLimit(superBw.getAutoGrowCollectionLimit());
	setConversionService(superBw.getConversionService());
	setSecurityContext(superBw.acc);
}

/**
 * Switch the target object, replacing the cached introspection results only
 * if the class of the new object is different to that of the replaced object.
 * @param object the new target object
 * @param nestedPath the nested path of the object
 * @param rootObject the root object at the top of the path
 */
public void setWrappedInstance(Object object, String nestedPath, Object rootObject) {
	Assert.notNull(object, "Bean object must not be null");
	this.object = object;
	this.nestedPath = (nestedPath != null ? nestedPath : "");
	this.rootObject = (!"".equals(this.nestedPath) ? rootObject : object);
	this.nestedBeanWrappers = null;
	this.typeConverterDelegate = new TypeConverterDelegate(this, object);
	setIntrospectionClass(object.getClass());
}

 

2.3 使用 BeanWrapper 设置&获取属性值（包含嵌套）

• PropertyTokenHolder

 在了解 BeanWrapper 设置和获取获取属性值前，我们先了解一下 PropertyTokenHolder。PropertyTokenHolder 是 BeanWrapperImpl 的内部类，他很简单，定义了属性命名描述。一个能标识 Bean 的唯一名称（可能包含嵌套的路径），Bean 真实名称（不包含嵌套路径），访问集合属性的索引数组。

private static class PropertyTokenHolder {
	// 例如 BeanA 中有个 Set 属性，他们的名称是“xxxSet”，
	// 我们可以通过“xxxSet[1]”访问这个属性值，需要获得BeanA.xxxSet的一个值
	// 权威唯一名称，例如：xxxSet[1]
	public String canonicalName;
	// 真实名称，例如：xxxSet
	public String actualName;
	// 访问集合索引，例如：["1"]
	public String[] keys;

}

 

• 设置属性值

 

设置属性值，设置属性值有两个重载的方法可供选择。在设置属性时，需要处理嵌套属性的设置。此种需要了解 PropertyTokenHolder，他是一个内部简单类，定义了嵌套的名称、真实名称、对应的访问KEY三个属性。

@Override
public void setPropertyValue(String propertyName, Object value) throws BeansException {
	BeanWrapperImpl nestedBw;
	try {
		// 此方法在下面介绍
		nestedBw = getBeanWrapperForPropertyPath(propertyName);
	}
	catch (NotReadablePropertyException ex) {
		throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
				"Nested property in path '" + propertyName + "' does not exist", ex);
	}
	// getFinalPath 的处理逻辑是如果 nestedBw 是自己情况，直接返回传入的 propertyName
	PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedBw, propertyName));
	// 后面介绍这个方法
	nestedBw.setPropertyValue(tokens, new PropertyValue(propertyName, value));
}

@Override
public void setPropertyValue(PropertyValue pv) throws BeansException {
	PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
	// 如果无法获取属性标识，重新计算一下
	if (tokens == null) {
		String propertyName = pv.getName();
		BeanWrapperImpl nestedBw;
		try {
			// 如果是嵌套的 BeanWrapper，获取的是嵌套的实例，否则是自己本身
			nestedBw = getBeanWrapperForPropertyPath(propertyName);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
					"Nested property in path '" + propertyName + "' does not exist", ex);
		}
		tokens = getPropertyNameTokens(getFinalPath(nestedBw, propertyName));
		if (nestedBw == this) {
			pv.getOriginalPropertyValue().resolvedTokens = tokens;
		}
		nestedBw.setPropertyValue(tokens, pv);
	}
	else {
		setPropertyValue(tokens, pv);
	}
}

@SuppressWarnings("unchecked")
private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
	String propertyName = tokens.canonicalName;
	String actualName = tokens.actualName;

	// 如果标识中的 keys 不为空，说明属性是集合方式的，需要通过集合的方式处理
	// 并且应该提供对应属性的 getter 方法，因为需要访问对应的集合
	if (tokens.keys != null) {
		// Apply indexes and map keys: fetch value for all keys but the last one.
		PropertyTokenHolder getterTokens = new PropertyTokenHolder();
		getterTokens.canonicalName = tokens.canonicalName;
		getterTokens.actualName = tokens.actualName;
		getterTokens.keys = new String[tokens.keys.length - 1];
		System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
		Object propValue;
		try {
			// 获取对应属性值
			propValue = getPropertyValue(getterTokens);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
					"Cannot access indexed value in property referenced " +
					"in indexed property path '" + propertyName + "'", ex);
		}
		// Set value for last key.
		String key = tokens.keys[tokens.keys.length - 1];
		if (propValue == null) {
			// null map value case
			if (this.autoGrowNestedPaths) {
				// TODO: cleanup, this is pretty hacky
				int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
				getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
				propValue = setDefaultValue(getterTokens);
			}
			else {
				throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + propertyName,
						"Cannot access indexed value in property referenced " +
						"in indexed property path '" + propertyName + "': returned null");
			}
		}
		// 如果属性值是数组类型
		if (propValue.getClass().isArray()) {
			PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
			Class requiredType = propValue.getClass().getComponentType();
			int arrayIndex = Integer.parseInt(key);
			Object oldValue = null;
			try {
				if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
					oldValue = Array.get(propValue, arrayIndex);
				}
				Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
						requiredType, TypeDescriptor.nested(property(pd), tokens.keys.length));
				Array.set(propValue, arrayIndex, convertedValue);
			}
			catch (IndexOutOfBoundsException ex) {
				throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
						"Invalid array index in property path '" + propertyName + "'", ex);
			}
		}
		// 如果属性值是List类型
		else if (propValue instanceof List) {
			PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
			Class requiredType = GenericCollectionTypeResolver.getCollectionReturnType(
					pd.getReadMethod(), tokens.keys.length);
			List list = (List) propValue;
			int index = Integer.parseInt(key);
			Object oldValue = null;
			if (isExtractOldValueForEditor() && index < list.size()) {
				oldValue = list.get(index);
			}
			Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
					requiredType, TypeDescriptor.nested(property(pd), tokens.keys.length));
			int size = list.size();
			if (index >= size && index < this.autoGrowCollectionLimit) {
				for (int i = size; i < index; i++) {
					try {
						list.add(null);
					}
					catch (NullPointerException ex) {
						throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
								"Cannot set element with index " + index + " in List of size " +
								size + ", accessed using property path '" + propertyName +
								"': List does not support filling up gaps with null elements");
					}
				}
				list.add(convertedValue);
			}
			else {
				try {
					list.set(index, convertedValue);
				}
				catch (IndexOutOfBoundsException ex) {
					throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
							"Invalid list index in property path '" + propertyName + "'", ex);
				}
			}
		}
		// 如果属性是Map类型
		else if (propValue instanceof Map) {
			PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
			Class mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(
					pd.getReadMethod(), tokens.keys.length);
			Class mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(
					pd.getReadMethod(), tokens.keys.length);
			Map map = (Map) propValue;
			// IMPORTANT: Do not pass full property name in here - property editors
			// must not kick in for map keys but rather only for map values.
			TypeDescriptor typeDescriptor = (mapKeyType != null ?
					TypeDescriptor.valueOf(mapKeyType) : TypeDescriptor.valueOf(Object.class));
			Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
			Object oldValue = null;
			if (isExtractOldValueForEditor()) {
				oldValue = map.get(convertedMapKey);
			}
			// Pass full property name and old value in here, since we want full
			// conversion ability for map values.
			Object convertedMapValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
					mapValueType, TypeDescriptor.nested(property(pd), tokens.keys.length));
			map.put(convertedMapKey, convertedMapValue);
		}
		// 其他是非集合情况，抛出异常
		else {
			throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
					"Property referenced in indexed property path '" + propertyName +
					"' is neither an array nor a List nor a Map; returned value was [" + pv.getValue() + "]");
		}
	}

	// 当标识中Key为空，此时需要直接设定属性的值
	else {
		// 获取对应的属性描述
		PropertyDescriptor pd = pv.resolvedDescriptor;
		// 如果无法获取属性描述，或者获得的属性描述对应的 class 不是被包装实例的class时，重新获取
		if (pd == null || !pd.getWriteMethod().getDeclaringClass().isInstance(this.object)) {
			pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
			if (pd == null || pd.getWriteMethod() == null) {
				if (pv.isOptional()) {
					logger.debug("Ignoring optional value for property '" + actualName +
							"' - property not found on bean class [" + getRootClass().getName() + "]");
					return;
				}
				else {
					PropertyMatches matches = PropertyMatches.forProperty(propertyName, getRootClass());
					throw new NotWritablePropertyException(
							getRootClass(), this.nestedPath + propertyName,
							matches.buildErrorMessage(), matches.getPossibleMatches());
				}
			}
			pv.getOriginalPropertyValue().resolvedDescriptor = pd;
		}

		Object oldValue = null;
		try {
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			// 如果需要类型转换，需要对输入的属性值进行类型转换
			if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
				if (pv.isConverted()) {
					valueToApply = pv.getConvertedValue();
				}
				else {
					// 如果存在 getter，从 getter 中获取对应的属性值，为了某些个性化的编辑器使用
					if (isExtractOldValueForEditor() && pd.getReadMethod() != null) {
						final Method readMethod = pd.getReadMethod();
						if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) &&
								!readMethod.isAccessible()) {
							if (System.getSecurityManager()!= null) {
								AccessController.doPrivileged(new PrivilegedAction