spring填充属性类型装换过程分析

￡神魔★判官ぃ 2022-11-18 04:55 296阅读 0赞

## 1：写在前面 ##

在[这篇文章][Link 1]中我们分析了spring通过`populateBean`方法进行属性填充的过程，而对于数据类型具体是如何转换的并没有详细分析，本文就来分析配置文件中的配置的String信到底是如何转换为目标bean的具体类型的。

## 2：convertForProperty ##

首先我们看`populateBean`方法，相关源码：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { 
    	...snip...
    	if (pvs != null) { 
    		applyPropertyValues(beanName, mbd, bw, pvs);
    	}
    }

`applyPropertyValues`源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyPropertyValues
    protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { 
    	...snip...
    	for (PropertyValue pv : original) { 
    		...snip...
    		else { 
    			// 属性名
    			String propertyName = pv.getName();
    			// 原始属性值
    			Object originalValue = pv.getValue();
    			// 解析属性值，可以认为和originalValue相同
    			Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    			Object convertedValue = resolvedValue;
    			// 判断是可转换的
    			boolean convertible = bw.isWritableProperty(propertyName) &&
    					!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
    			if (convertible) { 
    				// <2021-04-12 18:10>
    				// resolvedValue:配置的原始值 propertyName：属性的名称
    				// bw:封装bean的beanwrapper converter：转换属性值的转换器
    				convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
    			}
    			...snip...
    	}
    	...snip...
    }

`<2021-04-12 18:10>`处就是执行具体的转换工作，也是本部分分析的重点，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#convertForProperty
    private Object convertForProperty(
    			@Nullable Object value, String propertyName, BeanWrapper bw, TypeConverter converter) { 
    	// 如果是BeanWrapper则调用convertForProperty方法转换，因为BeanWrapperImpl实现了
    	// PropertyEditorRegistry,这里执行的其实就是PropertyEditorRegistry接口的逻辑
    	// 默认这里为true
    	if (converter instanceof BeanWrapperImpl) { 
    		return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
    	}
    	// 如果不是BeanWrapperImpl
    	else { 
    		// <2021-04-13 13:05>
    		// 获取java.beans.PropertyDescriptor接口，该接口能够获取属性类型，属性的读方法
    		// 属性的写方法等功能
    		PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
    		MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
    		// <2021-04-13 15:06>
    		return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
    	}
    }

`<2021-04-13 13:05>`处是属性描述器，关于属性描述器可参考[这里][Link 2]。`<2021-04-13 15:06>`处是通过`TypeConverter`接口来完成转换，该接口源码如下：

public interface TypeConverter { 
    	@Nullable
    	<T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType) throws TypeMismatchException;
    	
    	@Nullable
    	<T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
    			@Nullable MethodParameter methodParam) throws TypeMismatchException;
    
    	@Nullable
    	<T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType, @Nullable Field field)
    			throws TypeMismatchException;
    			
    	@Nullable
    	default <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
    			@Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException { 
    
    		throw new UnsupportedOperationException("TypeDescriptor resolution not supported");
    	}
    
    }

看到源码中大量使用了`@Nullable`注解，该注解是用来给静态分析工具使用的，比如在idea中会根据该注解给开发人员以提示，减少程序的bug，如下图调用标注了不可为null注解的方法给出的提示：  
![在这里插入图片描述][20210413182710915.png]详细可以参考[这里][Link 3]。其中该接口的实现类主要是如下的两个类：

// org.springframework.validation.DataBinder
    public class DataBinder implements PropertyEditorRegistry, TypeConverter { }
    // org.springframework.beans.TypeConverterSupport
    public abstract class TypeConverterSupport extends PropertyEditorRegistrySupport implements TypeConverter { }

其中DataBinder类主要用于springmvc的参数绑定，详细可以参考[这里][Link 4]，我们这里主要关注的是TypeConverterSupport类。

### 2.1：convertIfNecessary ###

org.springframework.beans.TypeConverterSupport#convertIfNecessary(java.lang.Object, java.lang.Class<T>, org.springframework.core.MethodParameter)
    public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
    			@Nullable MethodParameter methodParam) throws TypeMismatchException { 
    
    	return convertIfNecessary(value, requiredType,
    			(methodParam != null ? new TypeDescriptor(methodParam) : TypeDescriptor.valueOf(requiredType)));
    }

继续：

org.springframework.beans.TypeConverterSupport#convertIfNecessary(java.lang.Object, java.lang.Class<T>, org.springframework.core.convert.TypeDescriptor)
    public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
    			@Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException { 
    
    	Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
    	try { 
    		// 前两个参数给null，第三个参数是我们配置的值，第四个参数requiredType是spring bean
    		// 要求的类型，第五个参数typeDescriptor是类型描述器
    		return this.typeConverterDelegate.convertIfNecessary(null, null, value, requiredType, typeDescriptor);
    	}
    	...catch...
    }

继续：

org.springframework.beans.TypeConverterDelegate#convertIfNecessary(java.lang.String, java.lang.Object, java.lang.Object, java.lang.Class<T>, org.springframework.core.convert.TypeDescriptor)
    	public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
    			@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException { 
    	...snip...
    	// <20210415 1607>
    	ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
    	if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) { 
    		TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
    		if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) { 
    			try { 
    				// 执行转换并返回转换后的值
    				// newValue是我们配置的属性值，sourceTypeDesc是配置的属性值的类型描述器
    				// typeDescriptor是要转换的目标类型的类型描述器
    				return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
    			}
    			catch (ConversionFailedException ex) { 
    				// fallback to default conversion logic below
    				conversionAttemptEx = ex;
    			}
    		}
    	}
    	...snip...
    }

`<20210415 1607>`处是获取用户注册的ConversionService,ConversionService是在是在`spring 3.0`引入的用来代替Javabeas的PropertyEditor的，定义如下：

org.springframework.core.convert.ConversionService
    public interface ConversionService { 
    	// sourceType类型是否可以转换为targetType类型
    	boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType);
    	// sourceType的类型描述符，是否可以转换为targetType的类型描述符
    	boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
    	// 转换source为targetType
    	@Nullable
    	<T> T convert(@Nullable Object source, Class<T> targetType);
    	// 转换source+sourceType为targetType
    	@Nullable
    	Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
    }

这里调用的是有三个参数的方法`Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);`，具体使用的是子类`GenericConversionService`，源码如下：

org.springframework.core.convert.support.GenericConversionService#convert(java.lang.Object, org.springframework.core.convert.TypeDescriptor, org.springframework.core.convert.TypeDescriptor)
    public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	Assert.notNull(targetType, "Target type to convert to cannot be null");
    	// 如果是没有配置的数据的类型的类型描述器
    	if (sourceType == null) { 
    		Assert.isTrue(source == null, "Source must be [null] if source type == [null]");
    		return handleResult(null, targetType, convertNullSource(null, targetType));
    	}
    	// 如果是配置的属性值类型和不是其属性描述器所描述的类型，则异常
    	if (source != null && !sourceType.getObjectType().isInstance(source)) { 
    		throw new IllegalArgumentException("Source to convert from must be an instance of [" +
    				sourceType + "]; instead it was a [" + source.getClass().getName() + "]");
    	}
    	// <20210415 1958>
    	// 从类型转换的缓存中获取sourceType->targetType对应的GenericConverter
    	// 负责从一种类型转换为另一种类型的工作
    	GenericConverter converter = getConverter(sourceType, targetType);
    	if (converter != null) { 
    		// <20210415 1956>
    		// 执行具体的转换
    		Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
    		// <20210415 2000>
    		return handleResult(sourceType, targetType, result);
    	}
    	// <20210416 1522>
    	// 处理没有找到转换器的情况
    	return handleConverterNotFound(source, sourceType, targetType);
    }

`<20210415 1958>`处是获取对应类型的GenericConverter，具体参考`2.2：getConverter`。  
`<20210415 1956>`处是执行具体的转换，具体参考`2.3：invokeConverter`。`<20210415 2000>`处是校验转换后的结果，具体参考`2.4：handleResult`。`<20210416 1522>`是处理没有获取到转换器的情况，具体参考`2.5：handleConverterNotFound`。

### 2.2：getConverter ###

org.springframework.core.convert.support.GenericConversionService#getConverter
    protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	// <20210416 1006>
    	// 使用源和目标属性描述器组合为key
    	ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
    	// 从缓存map中尝试获取
    	GenericConverter converter = this.converterCache.get(key);
    	// 如果是获取到则返回
    	if (converter != null) { 
    		// 如果不是NO_MATCH，则返回，否则返回null
    		// NO_MATCH是专门表示没有匹配的转换器而定义的一个类
    		return (converter != NO_MATCH ? converter : null);
    	}
    	// <20210416 1442>
    	// 从所有的转换器中获取
    	converter = this.converters.find(sourceType, targetType);
    	// 没有获取到，这里可能的一种情况是目标类型是源类型的父类，即此时不需要转换
    	if (converter == null) { 
    		// <20210416 1508>
    		// 获取默认的转换器
    		converter = getDefaultConverter(sourceType, targetType);
    	}
    	// 如果是获取到转换器了，则添加到转换器缓存中
    	if (converter != null) { 
    		this.converterCache.put(key, converter);
    		// 返回获取到的转换器
    		return converter;
    	}
    	// 到这里，则说明没有获取到转换器，则添加没有匹配的转换器的对象NO_MATCH
    	this.converterCache.put(key, NO_MATCH);
    	// 返回null，代表没有获取到转换器
    	return null;
    }

`<20210416 1006>`处是使用源和目标属性描述器组合缓存key对象，这里需要重写`hashCode`和`equals`两个方法，关于这两个方法可以参考[这里][Link 5]。这里贴下ConverterCacheKey源码：

org.springframework.core.convert.support.GenericConversionService.ConverterCacheKey
    private static final class ConverterCacheKey implements Comparable<ConverterCacheKey> { 
    
    	private finalTypeDescriptor sourceType;
    
    	private final TypeDescriptor targetType;
    
    	public ConverterCacheKey(TypeDescriptor sourceType, TypeDescriptor targetType) { 
    		this.sourceType = sourceType;
    		this.targetType = targetType;
    	}
    
    	@Override
    	public boolean equals(Object other) { 
    		if (this == other) { 
    			return true;
    		}
    		if (!(other instanceof ConverterCacheKey)) { 
    			return false;
    		}
    		ConverterCacheKey otherKey = (ConverterCacheKey) other;
    		return (this.sourceType.equals(otherKey.sourceType)) &&
    				this.targetType.equals(otherKey.targetType);
    	}
    
    	@Override
    	public int hashCode() { 
    		return (this.sourceType.hashCode() * 29 + this.targetType.hashCode());
    	}
    
    	@Override
    	public String toString() { 
    		return ("ConverterCacheKey [sourceType = " + this.sourceType +
    				", targetType = " + this.targetType + "]");
    	}
    
    	@Override
    	public int compareTo(ConverterCacheKey other) { 
    		int result = this.sourceType.getResolvableType().toString().compareTo(
    				other.sourceType.getResolvableType().toString());
    		if (result == 0) { 
    			result = this.targetType.getResolvableType().toString().compareTo(
    					other.targetType.getResolvableType().toString());
    		}
    		return result;
    	}
    }

`<20210416 1442>`处是从所有注册的转换器中查找对应的转换器，转换器有很多，看下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]  
其中红框中的就是我们这次要获取的目标转换器。具体的查找源码如下：

org.springframework.core.convert.support.GenericConversionService.Converters#find
    public GenericConverter find(TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	// 获取继承关系，比如这里类型是String，则结果集合如下：
    	/* 0 = {Class@343} "class java.lang.String" 1 = {Class@346} "interface java.io.Serializable" 2 = {Class@345} "interface java.lang.Comparable" 3 = {Class@344} "interface java.lang.CharSequence" 4 = {Class@347} "class java.lang.Object" */
    	List<Class<?>> sourceCandidates = getClassHierarchy(sourceType.getType());
    	// 获取继承结果，比如这里的类型是int，则结果集合如下：
    	/* 0 = {Class@271} "class java.lang.Integer" 1 = {Class@276} "class java.lang.Number" 2 = {Class@345} "interface java.lang.Comparable" 3 = {Class@346} "interface java.io.Serializable" 4 = {Class@347} "class java.lang.Object" */
    	List<Class<?>> targetCandidates = getClassHierarchy(targetType.getType());
    	// 双层for循环根据继承关系中的各种类型组合查找转换器
    	for (Class<?> sourceCandidate : sourceCandidates) { 
    		for (Class<?> targetCandidate : targetCandidates) { 
    			// 使用源类型和目标类型组合对象ConvertiblePari对象
    			ConvertiblePair convertiblePair = new ConvertiblePair(sourceCandidate, targetCandidate);
    			// 通过ConvertiblePair对象获取转换器
    			GenericConverter converter = getRegisteredConverter(sourceType, targetType, convertiblePair);
    			// 如果是获取到了，则返回
    			if (converter != null) { 
    				return converter;
    			}
    		}
    	}
    	// 最终没有获取到，返回null
    	return null;
    }

`<20210416 1508>`处是获取默认的转换器，源码如下：

org.springframework.core.convert.support.GenericConversionService#getDefaultConverter
    protected GenericConverter getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	// sourceType.isAssignableTo(targetType)：对于普通对象类型，如果目标类型是源类型的父类，则为true
    	// 对于集合，数组如目标类型可以包含源类型，则结果为true
    	// 如果为true，说明可以直接赋值，不需要转换，此时返回代表不需要操作的对象NO_OP_CONVERTE
    	// 否则返回null，代表是没有获取到
    	return (sourceType.isAssignableTo(targetType) ? NO_OP_CONVERTER : null);
    }

### 2.3：invokeConverter ###

获取到了类型转换器，到这里就是执行就是执行转换了，源码如下：

org.springframework.core.convert.support.ConversionUtils#invokeConverter
    
    @Nullable // 告知静态分析工具，如idea，findbug，该方法返回值可能为null，从而给开发人员以提示，减少bug
    public static Object invokeConverter(GenericConverter converter, @Nullable Object source,
    			TypeDescriptor sourceType, TypeDescriptor targetType) { 
    
    	try { 
    		// 重要！！！
    		// 这里执行具体的类型转换工作
    		return converter.convert(source, sourceType, targetType);
    	}
    	...snip catch...
    }

### 2.4：handleResult ###

转换完成后，通过该方法进行转换结果的校验，其实就是校验转换结果为null时目标类型为基础类型的情况，源码如下：

org.springframework.core.convert.support.GenericConversionService#handleResult
    private Object handleResult(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType, @Nullable Object result) { 
    	// 如果为null，则判断是不是基础数据类型
    	if (result == null) { 
    		assertNotPrimitiveTargetType(sourceType, targetType);
    	}
    	return result;
    }

org.springframework.core.convert.support.GenericConversionService#assertNotPrimitiveTargetType
    private void assertNotPrimitiveTargetType(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	// 如果是基础数据类型，则异常，告知基础数据类型不能赋值为null
    	if (targetType.isPrimitive()) { 
    		throw new ConversionFailedException(sourceType, targetType, null,
    				new IllegalArgumentException("A null value cannot be assigned to a primitive type"));
    	}
    }

### 2.5：handleConverterNotFound ###

这里是处理没有获取到转换器的情况，源码如下：

org.springframework.core.convert.support.GenericConversionService#handleConverterNotFound
    private Object handleConverterNotFound(
    			@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) { 
    	// 如果是源数据为null
    	if (source == null) { 
    		// 如果是目标类型是基础数据类型，则异常，因为基础数据类型值不能为null
    		assertNotPrimitiveTargetType(sourceType, targetType);
    		return null;
    	}
    	// 如果targetType类型可以代替sourceType类型作为引用
    	if ((sourceType == null || sourceType.isAssignableTo(targetType)) &&
    			targetType.getObjectType().isInstance(source)) { 
    		return source;
    	}
    	// 抛出ConverterNotFoundException
    	throw new ConverterNotFoundException(sourceType, targetType);
    }

[Link 1]: https://blog.csdn.net/wang0907/article/details/115023488
[Link 2]: https://blog.csdn.net/wang0907/article/details/115287124
[20210413182710915.png]: https://img-blog.csdnimg.cn/20210413182710915.png
[Link 3]: /images/20221022/c1be2b4c659746daa15ddf1d72a5fe1a.png
[Link 4]: https://blog.csdn.net/wang0907/article/details/108357696
[Link 5]: https://blog.csdn.net/wang0907/article/details/115749867
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221022/c6e3685471ae40d3ba681f0c1216c82c.png