Spring 属性注入（三）AbstractNestablePropertyAccessor
Spring 系列目录(https://www.cnblogs.com/binarylei/p/10117436.html)
BeanWrapper 有两个核心的实现类
AbstractNestablePropertyAccessor提供对嵌套属性的支持BeanWrapperImpl提供对 JavaBean 的内省功能，如 PropertyDescriptor
AbstractNestablePropertyAccessor 是 Spring 4.2 提供的功能，将原 BeanWrapperImpl 的功能抽出，这样 BeanWrapperImpl 只提供对 JavaBean 的内省功能。
一、嵌套属性
AbstractNestablePropertyAccessor 类通过其成员属性提供了一种支持嵌套属性的数据结构，下面是几个核心的的属性成员：
| 属性类型及名称 | 说明 |
|---|---|
| Object object | 被 BeanWrapper 包装的对象 |
| String nestedPath | 当前 BeanWrapper 对象所属嵌套层次的属性名，最顶层的 BeanWrapper 此属性的值为空 |
| Object rootObject | 最顶层 BeanWrapper 所包装的对象 |
| Map nestedBeanWrappers | 缓存当前 BeanWrapper 的嵌套属性的 nestedPath 和对应的 BeanWrapperImpl 对象 |
例如如下的类结构：
@Test
public void test() throws Exception {
BeanWrapperImpl rootBeanWrapper = new BeanWrapperImpl(Company.class);
rootBeanWrapper.setAutoGrowNestedPaths(true);
rootBeanWrapper.setPropertyValue("name", "company");
rootBeanWrapper.setPropertyValue("department.name", "company");
rootBeanWrapper.setPropertyValue("director.info.name", "info...");
rootBeanWrapper.setPropertyValue("employees[0].attrs['a']", "a");
}
public class Company {
private String name;
private int total;
private Department department;
private Employee director;
private Employee[] employees;
private Map<Department, List<Employee>> departmentEmployees;
public static class Employee {
private String name;
private double salary;
private Map<String, String> attrs;
}
public static class Department {
private String name;
}
}
rootBeanWrapper 各嵌套层的属性如下：
| 对象 | level | object | nestedPath | rootObject | nestedBeanWrappers |
|---|---|---|---|---|---|
| rootBeanWrapper | 0(根) | company | "" | company | department -> departmentBeanWrapper director -> directorBeanWrapper |
| departmentBeanWrapper | 1 | department | department | company | 无 |
| directorBeanWrapper | 1 | director | director | company | info -> infoBeanWrapper |
| infoBeanWrapper | 2 | info | director.info | company | 无 |
二、getPropertyAccessorForPropertyPath
getPropertyAccessorForPropertyPath 根据属性(propertyPath)获取所在 bean 的包装对象 beanWrapper。如果是类似 director.info.name 的嵌套属性，则需要递归获取。真正获取指定属性的包装对象则由方法 getNestedPropertyAccessor 完成。
protected AbstractNestablePropertyAccessor getPropertyAccessorForPropertyPath(String propertyPath) {
// 1. 获取第一个点之前的属性部分。eg: director.info.name 返回 department
int pos = PropertyAccessorUtils.getFirstNestedPropertySeparatorIndex(propertyPath);
// 2. 递归处理嵌套属性
// 2.1 先获取 director 属性所在类的 rootBeanWrapper
// 2.2 再获取 info 属性所在类的 directorBeanWrapper
// 2.3 依此类推，获取最后一个属性 name 属性所在类的 infoBeanWrapper
if (pos > -1) {
String nestedProperty = propertyPath.substring(0, pos);
String nestedPath = propertyPath.substring(pos + 1);
AbstractNestablePropertyAccessor nestedPa = getNestedPropertyAccessor(nestedProperty);
return nestedPa.getPropertyAccessorForPropertyPath(nestedPath);
// 3. 当前对象直接返回
} else {
return this;
}
}
getPropertyAccessorForPropertyPath 有两种情况：
director(不包含 .)直接返回当前 bean 的包装对象director.info.name(包含 .)从当前对象开始递归查找，root -> director -> info。查找当前 beanWrapper 指定属性的包装对象由方法 getNestedPropertyAccessor 完成。
// 缓存已经查找过后 AbstractNestablePropertyAccessor
private Map<String, AbstractNestablePropertyAccessor> nestedPropertyAccessors;
private AbstractNestablePropertyAccessor getNestedPropertyAccessor(String nestedProperty) {
if (this.nestedPropertyAccessors == null) {
this.nestedPropertyAccessors = new HashMap<>();
}
// 1. 获取属性对应的 token 值，主要用于解析 attrs['key'][0] 这样 Map/Array/Collection 循环嵌套的属性
PropertyTokenHolder tokens = getPropertyNameTokens(nestedProperty);
String canonicalName = tokens.canonicalName;
Object value = getPropertyValue(tokens);
// 2. 属性不存在则根据 autoGrowNestedPaths 决定是否自动创建
if (value == null || (value instanceof Optional && !((Optional) value).isPresent())) {
if (isAutoGrowNestedPaths()) {
value = setDefaultValue(tokens);
} else {
throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + canonicalName);
}
}
// 3. 先从缓存中获取，没有就创建一个新的 nestedPa
AbstractNestablePropertyAccessor nestedPa = this.nestedPropertyAccessors.get(canonicalName);
if (nestedPa == null || nestedPa.getWrappedInstance() != ObjectUtils.unwrapOptional(value)) {
nestedPa = newNestedPropertyAccessor(value, this.nestedPath + canonicalName + NESTED_PROPERTY_SEPARATOR);
// Inherit all type-specific PropertyEditors.
copyDefaultEditorsTo(nestedPa);
copyCustomEditorsTo(nestedPa, canonicalName);
this.nestedPropertyAccessors.put(canonicalName, nestedPa);
}
return nestedPa;
}
getNestedPropertyAccessor 方法使用了动态规划算法，缓存每次递归的查的结果。该方法获取当前 bean 指定属性(nestedProperty)对应的 AbstractNestablePropertyAccessor。当然这个属性可能为 attrs['key'][0] 类型，这样就需要处理 Array、Map、List、Set 这样的数据类型。PropertyTokenHolder 正是处理这种类型的属性。
三、PropertyTokenHolder
PropertyTokenHolder 用于解析嵌套属性名称，标识唯一的属性。因为类似 attrs['key'][0] 这样的属性不统一，解析后将 [] 之间的 ' 和 " 去除后保存在 canonicalName 中，attrs 保存在 actualName 中，["key", "0"] 保存在 keys 中。
protected static class PropertyTokenHolder {
// 对应 bean 中的属性名称，如嵌套属性 attrs['key'][0] 在 bean 中的属性名称为 attrs
public String actualName;
// 将原始的嵌套属性处理成标准的 token，如 attrs['key'][0] 处理成 attrs[key][0]
public String canonicalName;
// 这个数组存放的是嵌套属性 [] 中的内容，如 attrs['key'][0] 处理成 ["key", "0"]
public String[] keys;
属性解析过程如下：
private PropertyTokenHolder getPropertyNameTokens(String propertyName) {
String actualName = null;
List<String> keys = new ArrayList<>(2);
int searchIndex = 0;
while (searchIndex != -1) {
int keyStart = propertyName.indexOf(PROPERTY_KEY_PREFIX, searchIndex);
searchIndex = -1;
if (keyStart != -1) {
int keyEnd = propertyName.indexOf(PROPERTY_KEY_SUFFIX, keyStart + PROPERTY_KEY_PREFIX.length());
if (keyEnd != -1) {
// 1. actualName 对应 bean 中的属性名称
if (actualName == null) {
actualName = propertyName.substring(0, keyStart);
}
// 2. 删除每个 key 中间的单引和双引
String key = propertyName.substring(keyStart + PROPERTY_KEY_PREFIX.length(), keyEnd);
if (key.length() > 1 && (key.startsWith("'") && key.endsWith("'")) ||
(key.startsWith(""") && key.endsWith("""))) {
key = key.substring(1, key.length() - 1);
}
keys.add(key);
searchIndex = keyEnd + PROPERTY_KEY_SUFFIX.length();
}
}
}
PropertyTokenHolder tokens = new PropertyTokenHolder(actualName != null ? actualName : propertyName);
if (!keys.isEmpty()) {
// 3. canonicalName 为原始属性名称去除单引和双引之后的名称
tokens.canonicalName += PROPERTY_KEY_PREFIX +
StringUtils.collectionToDelimitedString(keys, PROPERTY_KEY_SUFFIX + PROPERTY_KEY_PREFIX) +
PROPERTY_KEY_SUFFIX;
tokens.keys = StringUtils.toStringArray(keys);
}
return tokens;
}
四、PropertyHandler
PropertyHandler 的默认实现是 BeanPropertyHandler，位于 BeanWrapperImple 内，BeanPropertyHandler 是对 PropertyDescriptor 的封装，提供了对 JavaBean 底层的操作，如属性的读写。
protected PropertyHandler getPropertyHandler(String propertyName) throws BeansException {
Assert.notNull(propertyName, "Property name must not be null");
AbstractNestablePropertyAccessor nestedPa = getPropertyAccessorForPropertyPath(propertyName);
return nestedPa.getLocalPropertyHandler(getFinalPath(nestedPa, propertyName));
}
// PropertyHandler 是对 PropertyDescriptor 的封装，提供了对 JavaBean 底层的操作，如属性的读写
protected BeanPropertyHandler getLocalPropertyHandler(String propertyName) {
PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName);
return (pd != null ? new BeanPropertyHandler(pd) : null);
}
五、setPropertyValue 属性注入
@Override
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
// 1. 递归获取 propertyName 属性所在的 beanWrapper，如 director.info.name 获取 name 属性所在的 info bean
AbstractNestablePropertyAccessor nestedPa = getPropertyAccessorForPropertyPath(propertyName);
// 2. 获取属性的 token
PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
// 3. 设置属性值
nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
}
setPropertyValue 分以下步骤：
- 递归获取 propertyName 属性所在的 beanWrapper，如果这个属性为 null 则是否创建一个默认的值(setDefaultValue)？
- 根据属性的 tokens 进行赋值操作。这里分两种情况：一是简单的属性赋值，如 director；二是 Array、Map、List、Set 类型属性注入，如 employees[0].attrs['a']
protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
// 1. Array、Map、List、Set 类型属性注入。employees[0].attrs['a']
if (tokens.keys != null) {
processKeyedProperty(tokens, pv);
// 2. 简单 bean 属性注入。director
} else {
processLocalProperty(tokens, pv);
}
}
以 processLocalProperty 为例属性注入代码如下：
private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
if (ph == null || !ph.isWritable()) {
// 处理 null 情况 ...
}
Object oldValue = null;
Object originalValue = pv.getValue();
Object valueToApply = originalValue;
if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
if (pv.isConverted()) {
valueToApply = pv.getConvertedValue();
} else {
// 1. 将 oldValue 暴露给 PropertyEditor
if (isExtractOldValueForEditor() && ph.isReadable()) {
oldValue = ph.getValue();
}
// 2. 类型转换，委托给 TypeConverterDelegate 完成
valueToApply = convertForProperty(
tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
}
pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
}
// 3. 属性赋值
ph.setValue(valueToApply);
}
六、getPropertyValue
getPropertyValue 根据属性名称获取对应的值。
@Override
public Object getPropertyValue(String propertyName) throws BeansException {
AbstractNestablePropertyAccessor nestedPa = getPropertyAccessorForPropertyPath(propertyName);
PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
return nestedPa.getPropertyValue(tokens);
}
protected Object getPropertyValue(PropertyTokenHolder tokens) throws BeansException {
String propertyName = tokens.canonicalName;
String actualName = tokens.actualName;
PropertyHandler ph = getLocalPropertyHandler(actualName);
if (ph == null || !ph.isReadable()) {
throw new NotReadablePropertyException(getRootClass(), this.nestedPath + propertyName);
}
// 1. 反射获取属性对应的值
Object value = ph.getValue();
// 2. Array、Map、List、Set 类型需要单独处理
if (tokens.keys != null) {
if (value == null) {
if (isAutoGrowNestedPaths()) {
value = setDefaultValue(new PropertyTokenHolder(tokens.actualName));
} else {
throw new NullValueInNestedPathException();
}
}
StringBuilder indexedPropertyName = new StringBuilder(tokens.actualName);
// apply indexes and map keys
for (int i = 0; i < tokens.keys.length; i++) {
String key = tokens.keys[i];
if (value == null) {
throw new NullValueInNestedPathException();
} else if (value.getClass().isArray()) {
int index = Integer.parseInt(key);
value = growArrayIfNecessary(value, index, indexedPropertyName.toString());
value = Array.get(value, index);
} else if (value instanceof List) {
int index = Integer.parseInt(key);
List<Object> list = (List<Object>) value;
growCollectionIfNecessary(list, index, indexedPropertyName.toString(), ph, i + 1);
value = list.get(index);
} else if (value instanceof Set) {
Set<Object> set = (Set<Object>) value;
int index = Integer.parseInt(key);
if (index < 0 || index >= set.size()) {
throw new InvalidPropertyException();
}
Iterator<Object> it = set.iterator();
for (int j = 0; it.hasNext(); j++) {
Object elem = it.next();
if (j == index) {
value = elem;
break;
}
}
} else if (value instanceof Map) {
Map<Object, Object> map = (Map<Object, Object>) value;
Class<?> mapKeyType = ph.getResolvableType().getNested(i + 1).asMap().resolveGeneric(0);
TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
value = map.get(convertedMapKey);
}
indexedPropertyName.append(PROPERTY_KEY_PREFIX).append(key).append(PROPERTY_KEY_SUFFIX);
}
}
return value;
}
七、setDefaultValue
setDefaultValue 嵌套属性为 null 时设置默认属性。
getPropertyAccessorForPropertyPath 递归获取嵌套属性，或 getPropertyValue 时，如果属性为 null 且 autoGrowNestedPaths=true 会创建默认的对象。如 director.info.name 时 director 为 null 会调用其无参构造方法创建默认对象。
private Object setDefaultValue(PropertyTokenHolder tokens) {
PropertyValue pv = createDefaultPropertyValue(tokens);
setPropertyValue(tokens, pv);
Object defaultValue = getPropertyValue(tokens);
Assert.state(defaultValue != null, "Default value must not be null");
return defaultValue;
}
private PropertyValue createDefaultPropertyValue(PropertyTokenHolder tokens) {
TypeDescriptor desc = getPropertyTypeDescriptor(tokens.canonicalName);
Object defaultValue = newValue(desc.getType(), desc, tokens.canonicalName);
return new PropertyValue(tokens.canonicalName, defaultValue);
}
// 创建一个默认的对象，type 为 Class 类型，desc 用于解析集合或 Map 的泛型类型
private Object newValue(Class<?> type, @Nullable TypeDescriptor desc, String name) {
// 1. Array 仅考虑二维数组 String[][]
if (type.isArray()) {
Class<?> componentType = type.getComponentType();
// TODO - only handles 2-dimensional arrays
if (componentType.isArray()) {
Object array = Array.newInstance(componentType, 1);
Array.set(array, 0, Array.newInstance(componentType.getComponentType(), 0));
return array;
} else {
return Array.newInstance(componentType, 0);
}
// 2. Collection CollectionFactory.createCollection 都没有指定泛型
} else if (Collection.class.isAssignableFrom(type)) {
TypeDescriptor elementDesc = (desc != null ? desc.getElementTypeDescriptor() : null);
return CollectionFactory.createCollection(type, (elementDesc != null ? elementDesc.getType() : null), 16);
// 3. Map
} else if (Map.class.isAssignableFrom(type)) {
TypeDescriptor keyDesc = (desc != null ? desc.getMapKeyTypeDescriptor() : null);
return CollectionFactory.createMap(type, (keyDesc != null ? keyDesc.getType() : null), 16);
// 3. 简单的 Bean，直接使用默认的无参构造方法
} else {
Constructor<?> ctor = type.getDeclaredConstructor();
if (Modifier.isPrivate(ctor.getModifiers())) {
throw new IllegalAccessException("Auto-growing not allowed with private constructor: " + ctor);
}
return BeanUtils.instantiateClass(ctor);
}
}
参考：
- 《Spring 学习 （二）BeanWrapper及其实现》：https://blog.csdn.net/zhiweianran/article/details/7919129
每天用心记录一点点。内容也许不重要，但习惯很重要！