【Spring】DI：源码流程（下）依赖注入

刺骨的言语ヽ痛彻心扉 2022-10-31 01:58 229阅读 0赞

在上一篇的分析中我们已经了解到Bean的依赖注入主要分为两个步骤

1.  首先调用createBeanInstance()方法生成 Bean 所包含的 Java对象实例
2.  然后调用 populateBean()方法，对 Bean属性的依赖注入进行处理。

现在我们继续分析生成对象后，Spring IOC 容器是如何将 Bean 的属性依赖关系注入 Bean 实例对象中并设置好的。

![20201209005644357.png][]

## 1.准备依赖注入 (AbstractAutowireCapableBeanFactory) ##

回到AbstractAutowireCapableBeanFactory 的populateBean()方法，对属性依赖注入的代码如下

### populateBean() ###

将Bean属性设置到生成的实例对象上

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
        { 
    		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;
    			}
    		}
    
    		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the state of the bean before properties are set. 
    		// This can be used, for example,to support styles of field injection.
    		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;
    		}
    		// 获取容器在解析Bean定义资源时为BeanDefiniton中设置的属性值
    		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
    		// 对依赖注入处理，首先处理autowiring自动装配的依赖注入
    		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME 
    				|| mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    
    			// Add property values based on autowire by name if applicable.
    			// 根据Bean名称进行autowiring自动装配处理
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    
    			// Add property values based on autowire by type if applicable.
    			// 根据Bean类型进行autowiring自动装配处理
    			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 
    				autowireByType(beanName, mbd, bw, newPvs);
    			}
    
    			pvs = newPvs;
    		}
    
    		// 对非autowiring的属性进行依赖注入处理
    		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    
    		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 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);
    		}
    	}

### applyPropertyValues() ###

解析并注入依赖属性的过程

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { 
    		if (pvs.isEmpty()) { 
    			return;
    		}
    
    		// 封装属性值
    		MutablePropertyValues mpvs = null;
    		List<PropertyValue> original;
    
    		if (System.getSecurityManager() != null) { 
    			if (bw instanceof BeanWrapperImpl) { 
    				// 设置安全上下文，JDK安全机制
    				((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    			}
    		}
    
    		if (pvs instanceof MutablePropertyValues) { 
    			mpvs = (MutablePropertyValues) pvs;
    			// 属性值已经转换
    			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());
    		}
    
    		// 获取用户自定义的类型转换
    		TypeConverter converter = getCustomTypeConverter();
    		if (converter == null) { 
    			converter = bw;
    		}
    		// 创建一个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;
    		for (PropertyValue pv : original) { 
    			// 属性值不需要转换
    			if (pv.isConverted()) { 
    				deepCopy.add(pv);
    			}
    			// 属性值需要转换
    			else { 
    				String propertyName = pv.getName();
    				// 原始的属性值，即转换之前的属性值
    				Object originalValue = pv.getValue();
    				// 转换属性值，例如将引用转换为IOC容器中实例化对象引用
    				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);
    				}
    				// Possibly store converted value in merged bean definition,
    				// in order to avoid re-conversion for every created bean instance.
    				// 存储转换后的属性值，避免每次属性注入时的转换工作
    				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();
    		}
    
    		// 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);
    		}
    	}

分析上述代码，我们可以看出，对属性的注入过程分以下两种情况：

*  属性值类型不需要强制转换时，不需要解析属性值，直接准备进行依赖注入。
 *  属性值需要进行类型强制转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值依赖注入。
    
     *  对属性值的解析是在BeanDefinitionValueResolver类中的resolveValueIfNecessary()方法中进行的，
     *  对属性值的依赖注入是通过bw.setPropertyValues()方法实现的，

在分析属性值的依赖注入之前，我们先分析一下对属性值的解析过程。

## 2.解析属性注入规则 (BeanDefinitionValueResolver) ##

当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，如属性值是容器中另一个 Bean实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，然后才能将该引用对象注入到目标实例对象的属性上去，对属性进行解析的由resolveValueIfNecessary()方法实现，其源码如下：

### resolveValueIfNecessary() ###

解析属性值，对注入类型进行转换

@Nullable
    	public Object resolveValueIfNecessary(Object argName, @Nullable Object value) { 
    		// We must check each value to see whether it requires a runtime reference
    		// to another bean to be resolved.
    		// 对引用类型的属性进行解析
    		if (value instanceof RuntimeBeanReference) { 
    			RuntimeBeanReference ref = (RuntimeBeanReference) value;
    			// 调用引用类型属性的解析方法
    			return resolveReference(argName, ref);
    		}
    		// 对属性值是引用容器中另一个Bean名称的解析
    		else if (value instanceof RuntimeBeanNameReference) { 
    			String refName = ((RuntimeBeanNameReference) value).getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			// 从容器中获取指定名称的Bean
    			if (!this.beanFactory.containsBean(refName)) { 
    				throw new BeanDefinitionStoreException(
    						"Invalid bean name '" + refName + "' in bean reference for " + argName);
    			}
    			return refName;
    		}
    		// 对Bean类型属性的解析，主要是Bean中的内部类
    		else if (value instanceof BeanDefinitionHolder) { 
    			// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
    			BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
    			return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
    		}
    		else if (value instanceof BeanDefinition) { 
    			// Resolve plain BeanDefinition, without contained name: use dummy name.
    			BeanDefinition bd = (BeanDefinition) value;
    			String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR 
    											+ ObjectUtils.getIdentityHexString(bd);
    			return resolveInnerBean(argName, innerBeanName, bd);
    		}
    		// 对集合数组类型的属性解析
    		else if (value instanceof ManagedArray) { 
    			// May need to resolve contained runtime references.
    			ManagedArray array = (ManagedArray) value;
    			// 获取数组的类型
    			Class<?> elementType = array.resolvedElementType;
    			if (elementType == null) { 
    				// 获取数组元素的类型
    				String elementTypeName = array.getElementTypeName();
    				if (StringUtils.hasText(elementTypeName)) { 
    					try { 
    						// 使用反射机制创建指定类型的对象
    						elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
    						array.resolvedElementType = elementType;
    					}
    					catch (Throwable ex) { 
    						// Improve the message by showing the context.
    						throw new BeanCreationException(
    								this.beanDefinition.getResourceDescription(), this.beanName,
    								"Error resolving array type for " + argName, ex);
    					}
    				}
    				// 没有获取到数组的类型，也没有获取到数组元素的类型，则直接设置数组的类型为Object
    				else { 
    					elementType = Object.class;
    				}
    			}
    			// 创建指定类型的数组
    			return resolveManagedArray(argName, (List<?>) value, elementType);
    		}
    		// 解析list类型的属性值
    		else if (value instanceof ManagedList) { 
    			// May need to resolve contained runtime references.
    			return resolveManagedList(argName, (List<?>) value);
    		}
    		// 解析set类型的属性值
    		else if (value instanceof ManagedSet) { 
    			// May need to resolve contained runtime references.
    			return resolveManagedSet(argName, (Set<?>) value);
    		}
    		// 解析map类型的属性值
    		else if (value instanceof ManagedMap) { 
    			// May need to resolve contained runtime references.
    			return resolveManagedMap(argName, (Map<?, ?>) value);
    		}
    		// 解析props类型的属性值，props其实就是key和value均为字符串的map
    		else if (value instanceof ManagedProperties) { 
    			Properties original = (Properties) value;
    			// 创建一个拷贝，用于作为解析后的返回值
    			Properties copy = new Properties();
    			original.forEach((propKey, propValue) -> { 
    				if (propKey instanceof TypedStringValue) { 
    					propKey = evaluate((TypedStringValue) propKey);
    				}
    				if (propValue instanceof TypedStringValue) { 
    					propValue = evaluate((TypedStringValue) propValue);
    				}
    				if (propKey == null || propValue == null) { 
    					throw new BeanCreationException(
    							this.beanDefinition.getResourceDescription(), this.beanName,
    							"Error converting Properties key/value pair for " + argName + ": 
                            resolved to null");
    				}
    				copy.put(propKey, propValue);
    			});
    			return copy;
    		}
    		// 解析字符串类型的属性值
    		else if (value instanceof TypedStringValue) { 
    			// Convert value to target type here.
    			TypedStringValue typedStringValue = (TypedStringValue) value;
    			Object valueObject = evaluate(typedStringValue);
    			try { 
    				// 获取属性的目标类型
    				Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
    				if (resolvedTargetType != null) { 
    					// 对目标类型的属性进行解析，递归调用
    					return this.typeConverter.convertIfNecessary(valueObject, 
                                                                     resolvedTargetType);
    				}
    				// 没有获取到属性的目标对象，则按Object类型返回
    				else { 
    					return valueObject;
    				}
    			}
    			catch (Throwable ex) { 
    				// Improve the message by showing the context.
    				throw new BeanCreationException(
    						this.beanDefinition.getResourceDescription(), this.beanName,
    						"Error converting typed String value for " + argName, ex);
    			}
    		}
    		else if (value instanceof NullBean) { 
    			return null;
    		}
    		else { 
    			return evaluate(value);
    		}
    	}

### resolveReference ###

解析引用类型的属性值

@Nullable
    	private Object resolveReference(Object argName, RuntimeBeanReference ref) { 
    		try { 
    			Object bean;
    			// 获取引用的Bean名称
    			String refName = ref.getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			// 如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象
    			if (ref.isToParent()) { 
    				if (this.beanFactory.getParentBeanFactory() == null) { 
    					throw new BeanCreationException(
    							this.beanDefinition.getResourceDescription(), this.beanName,
    							"Can't resolve reference to bean '" + refName +"' in parent factory: no parent factory available");
    				}
    				bean = this.beanFactory.getParentBeanFactory().getBean(refName);
    			}
    			// 从当前的容器中获取指定的引用Bean对象，如果指定的Bean没有被实例化，则会递归触发引用Bean的初始化和依赖注入
    			else { 
    				bean = this.beanFactory.getBean(refName);
    				// 将当前实例化对象的依赖引用对象
    				this.beanFactory.registerDependentBean(refName, this.beanName);
    			}
    			if (bean instanceof NullBean) { 
    				bean = null;
    			}
    			return bean;
    		}
    		catch (BeansException ex) { 
    			throw new BeanCreationException(
    					this.beanDefinition.getResourceDescription(), this.beanName,
    					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    		}
    	}

### resolveManagedArray() ###

解析array类型的属性

private Object resolveManagedArray(Object argName, List<?> ml, Class<?> elementType) { 
    		// 创建一个指定类型的数组，用于存放和返回解析后的数组
    		Object resolved = Array.newInstance(elementType, ml.size());
    		for (int i = 0; i < ml.size(); i++) { 
    			// 递归解析array的每一个元素，并将解析后的值设置到resolved数组中，索引为i
    			Array.set(resolved, i,resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
    		}
    		return resolved;
    	}

通过上面的代码分析，我们明白了Spring是如何将引用类型，内部类以及集合类型等属性进行解析的，属性值解析完成后就可以进行依赖注入了。

**依赖注入的过程就是Bean对象实例设置到它所依赖的Bean对象属性上去**。而真正的依赖注入是通过bw.setPropertyValues()方法实现的，该方法也使用了委托模式，在 BeanWrapper 接口中至少定义了方法声明，依赖注入的具体实现交由其实现类BeanWrapperImpl来完成。

下面我们就分析依BeanWrapperImpl中赖注入相关的源码。

## 3.注入赋值 (AbstractNestablePropertyAccessor) ##

BeanWrapperImpl类主要是对容器中完成初始化的 Bean 实例对象进行属性的依赖注入，即把 Bean 对象设置到它所依赖的另一个 Bean 的属性中去。然而，BeanWrapperImpl 中的注入方法实际上由 AbstractNestablePropertyAccessor来实现的，其相关源码如下：

### setPropertyValue() ###

实现属性依赖注入功能

protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException { 
    		if (tokens.keys != null) { 
    			processKeyedProperty(tokens, pv);
    		}
    		else { 
    			processLocalProperty(tokens, pv);
    		}
    	}

### processKeyedProperty() ###

实现集合属性依赖注入

@SuppressWarnings("unchecked")
    	private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) { 
    		// 调用属性的getter方法，获取属性的值
    		Object propValue = getPropertyHoldingValue(tokens);
    		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
    		if (ph == null) { 
    			throw new InvalidPropertyException(
    					getRootClass(), this.nestedPath + tokens.actualName, "No property handler found");
    		}
    		Assert.state(tokens.keys != null, "No token keys");
    		String lastKey = tokens.keys[tokens.keys.length - 1];
    
    		// 注入array类型的属性值
    		if (propValue.getClass().isArray()) { 
    			Class<?> requiredType = propValue.getClass().getComponentType();
    			int arrayIndex = Integer.parseInt(lastKey);
    			Object oldValue = null;
    			try { 
    				if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) { 
    					oldValue = Array.get(propValue, arrayIndex);
    				}
    				Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    														requiredType, ph.nested(tokens.keys.length));
    				// 获取集合类型属性的长度
    				int length = Array.getLength(propValue);
    				if (arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) { 
    					Class<?> componentType = propValue.getClass().getComponentType();
    					Object newArray = Array.newInstance(componentType, arrayIndex + 1);
    					System.arraycopy(propValue, 0, newArray, 0, length);
    					setPropertyValue(tokens.actualName, newArray);
    					// 调用属性的getter方法，获取属性的值
    					propValue = getPropertyValue(tokens.actualName);
    				}
    				// 将属性的值赋值给数组中的元素
    				Array.set(propValue, arrayIndex, convertedValue);
    			}
    			catch (IndexOutOfBoundsException ex) { 
    				throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    						"Invalid array index in property path '" + tokens.canonicalName + "'", ex);
    			}
    		}
    
    		// 注入list类型的属性值
    		else if (propValue instanceof List) { 
    			// 获取list集合的类型
    			Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
    			List<Object> list = (List<Object>) propValue;
    			// 获取list集合的size
    			int index = Integer.parseInt(lastKey);
    			Object oldValue = null;
    			if (isExtractOldValueForEditor() && index < list.size()) { 
    				oldValue = list.get(index);
    			}
    			// 获取list解析后的属性值
    			Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    													requiredType, ph.nested(tokens.keys.length));
    			int size = list.size();
    			// 如果list的长度大于属性值的长度，则多余的元素赋值为null
    			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 + tokens.canonicalName,
    								"Cannot set element with index " + index + " in List of size " + size 
    								  + ", accessed using property path '" + tokens.canonicalName 
    								  +"': List does not support filling up gaps with null elements");
    					}
    				}
    				list.add(convertedValue);
    			}
    			else { 
    				try { 
    					// 将值添加到list中
    					list.set(index, convertedValue);
    				}
    				catch (IndexOutOfBoundsException ex) { 
    					throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    							"Invalid list index in property path '" + tokens.canonicalName + "'", ex);
    				}
    			}
    		}
    
    		// 注入map类型的属性值
    		else if (propValue instanceof Map) { 
    			// 获取map集合key的类型
    			Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
    			// 获取map集合value的类型
    			Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
    			Map<Object, Object> map = (Map<Object, Object>) 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 = TypeDescriptor.valueOf(mapKeyType);
    			// 解析map类型属性key值
    			Object convertedMapKey = convertIfNecessary(null, null, lastKey, 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.
    			// 解析map类型属性value值
    			Object convertedMapValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    					mapValueType, ph.nested(tokens.keys.length));
    			// 将解析后的key和value值赋值给map集合属性
    			map.put(convertedMapKey, convertedMapValue);
    		}
    
    		else { 
    			throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
    					"Property referenced in indexed property path '" + tokens.canonicalName 
    					+"' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
    		}
    	}

### getPropertyHoldingValue() ###

private Object getPropertyHoldingValue(PropertyTokenHolder tokens) { 
    		// Apply indexes and map keys: fetch value for all keys but the last one.
    		Assert.state(tokens.keys != null, "No token keys");
    		PropertyTokenHolder getterTokens = new PropertyTokenHolder(tokens.actualName);
    		getterTokens.canonicalName = tokens.canonicalName;
    		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 + tokens.canonicalName,
    					"Cannot access indexed value in property referenced " 
    					+ "in indexed property path '" + tokens.canonicalName + "'", ex);
    		}
    
    		if (propValue == null) { 
    			// null map value case
    			if (isAutoGrowNestedPaths()) { 
    				int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
    				getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
    				propValue = setDefaultValue(getterTokens);
    			}
    			else { 
    				throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + tokens.canonicalName,
    						"Cannot access indexed value in property referenced " +"in indexed property path '" 
    						+ tokens.canonicalName + "': returned null");
    			}
    		}
    		return propValue;
    	}

### processLocalProperty() ###

对非集合类型的处理

@SuppressWarnings("unchecked")
    	private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) { 
             AbstractNestablePropertyAccessor.PropertyHandler ph = getLocalPropertyHandler(actualName);
             Object oldValue = null;
             try { 
                 Object originalValue = pv.getValue();
                 Object valueToApply = originalValue;
                 if (!Boolean.FALSE.equals(pv.conversionNecessary)) { 
                     if (pv.isConverted()) { 
                         valueToApply = pv.getConvertedValue();
                     }else { 
                         if (isExtractOldValueForEditor() && ph.isReadable()) { 
                             try { 
                                 oldValue = ph.getValue();
                             }catch (Exception ex) { }
                         }
                         valueToApply = convertForProperty(propertyName, oldValue, originalValue, ph.toTypeDescriptor());
                     }
                     pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
                 }
                  // 通过反射注入
                 ph.setValue(object, valueToApply);
                 }
             }
         }

### setValue() ###

public void setValue(final Object object, Object valueToApply) throws Exception { 
         final Method writeMethod = this.pd.getWriteMethod();
         if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) { 
             if (System.getSecurityManager() != null) { 
                 AccessController.doPrivileged(new PrivilegedAction<Object>() { 
                     @Override
                     public Object run() { 
                         writeMethod.setAccessible(true);
                         return null;
                     }
                 });
             } else { 
                 writeMethod.setAccessible(true);
             }
         }
         final Object value = valueToApply;
         if (System.getSecurityManager() != null) { 
         } else { 
             // 通过反射 用set 方法注入属性
             writeMethod.invoke(getWrappedInstance(), value);
         }
     }

[20201209005644357.png]: /images/20221024/cf9d5fe6efe34e05af56dcee88692029.png?