SpringBoot实战：Spring如何到对应转换器优雅使⽤枚
举参数
⽬录
⼊⼝
请求⼊⼝是DispatcherServlet
查转换器
Spring 如何查转换器
类型转换
跟随源码到⾃定义转换器⼯⼚类和转换器类的实现逻辑
⽆论是GET请求，还是传参式的POST请求（即Form模式）
⼊⼝
请求⼊⼝是DispatcherServlet
所有的请求最终都会落到doDispatch⽅法中的
ha.handle(processedRequest, response, Handler())逻辑。
我们从这⾥出发，⼀层⼀层向⾥扒。
跟着代码深⼊，我们会到
org.hod.support.InvocableHandlerMethod#invokeForRequest的逻辑：
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
< providedArgs) throws Exception {
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
}
return doInvoke(args);
}
可以看出，这⾥⾯通过getMethodArgumentValues⽅法处理参数，然后调⽤doInvoke⽅法获取返回值。
继续深⼊，能够到
org.hod.annotation.RequestParamMethodArgumentResolver#resolveArgument⽅法
这个⽅法就是解析参数的逻辑。
试想⼀下，如果是我们⾃⼰实现这段逻辑，会怎么做呢？
1. 输⼊参数
2. 到⽬标参数
3. 检查是否需要特殊转换逻辑
4. 如果需要，进⾏转换
5. 如果不需要，直接返回
获取输⼊参数的逻辑在
enum怎么用org.hod.annotation.RequestParamMethodArgumentResolver#resolveName 单参数返回的是 String 类型，多参数返回 String 数组。
核⼼代码如下：
String[] paramValues = ParameterValues(name);
if (paramValues != null) {
arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
}
所以说，⽆论我们的⽬标参数是什么，输⼊参数都是 String 类型或 String 数组
然后 Spring 把它们转换为我们期望的类型。
到⽬标参数的逻辑在DispatcherServlet中，根据 uri 到对应的 Controller 处理⽅法
到⽅法就到了⽬标参数类型。
接下来就是检查是否需要转换逻辑，也就是
org.springframework.validation.DataBinder#convertIfNecessary
顾名思义，如果需要就转换，将字符串类型转换为⽬标类型。
在我们的例⼦中，就是将 String 转换为枚举值。
查转换器
org.springframework.beans.TypeConverterDelegate#convertIfNecessary⽅法中
继续深扒到这么⼀段逻辑：
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
try {
return (T) vert(newValue, sourceTypeDesc, typeDescriptor);
}
catch (ConversionFailedException ex) {
// fallback to default conversion logic below
conversionAttemptEx = ex;
}
}
这段逻辑中，调⽤了
onvert.support.GenericConversionService#canConvert⽅法
检查是否可转换，如果可以转换，将会执⾏类型转换逻辑。
检查是否可转换的本质就是检查是否能够到对应的转换器。
如果能到，就⽤到的转换器开始转换逻辑
如果不到，那就是不能转换，⾛其他逻辑。
我们可以看看查转换器的代码
onvert.support.GenericConversionService#getConverter
可以对我们⾃⼰写代码有⼀些启发：
private final Map<ConverterCacheKey, GenericConverter> converterCache = new ConcurrentReferenceHashMap<>(64);
protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
GenericConverter converter = (key);
if (converter != null) {
return (converter != NO_MATCH ? converter : null);
}
converter = verters.find(sourceType, targetType);
if (converter == null) {
converter = getDefaultConverter(sourceType, targetType);
}
if (converter != null) {
return converter;
}
return null;
}
转换为伪代码就是：
1. 根据参数类型和⽬标类型，构造缓存 key
2. 根据缓存 key从缓存中查询转换器
3. 如果能到且不是 NO_MATCH，返回转换器；如果是 NO_MATCH，返回 null；如果未到，继续
4. 通过onvert.support.GenericConversionService.Converters#find查询转换器
5. 如果未到，检查源类型和⽬标类型是否可以强转，也就是类型⼀致。如果是，返回 NoOpConverter，如果否，返回
null。
6. 检查到的转换器是否为 null，如果不是，将转换器加⼊到缓存中，返回该转换器
7. 如果否，在缓存中添加 NO_MATCH 标识，返回 null
Spring 内部使⽤Map作为缓存，⽤来存储通⽤转换器接⼝GenericConverter，这个接⼝会是我们⾃定义转换器的包装类。
我们还可以看到，转换器缓存⽤的是ConcurrentReferenceHashMap，这个类是线程安全的
可以保证并发情况下，不会出现异常存储。但是getConverter⽅法没有使⽤同步逻辑。
换句话说，并发请求时，可能存在性能损耗。
不过，对于 web 请求场景，并发损耗好过阻塞等待。
Spring 如何查转换器
onvert.support.GenericConversionService.Converters#find
就是到对应转换器的核⼼逻辑：
private final Map<ConvertiblePair, ConvertersForPair> converters = new ConcurrentHashMap<>(256);
@Nullable
public GenericConverter find(TypeDescriptor sourceType, TypeDescriptor targetType) {
// Search the full type hierarchy
List<Class<?>> sourceCandidates = Type());
List<Class<?>> targetCandidates = Type());
for (Class<?> sourceCandidate : sourceCandidates) {
for (Class<?> targetCandidate : targetCandidates) {
ConvertiblePair convertiblePair = new ConvertiblePair(sourceCandidate, targetCandidate);
GenericConverter converter = getRegisteredConverter(sourceType, targetType, convertiblePair);
if (converter != null) {
return converter;
}
}
}
return null;
}
@Nullable
private GenericConverter getRegisteredConverter(TypeDescriptor sourceType,
TypeDescriptor targetType, ConvertiblePair convertiblePair) {
// Check specifically registered converters
ConvertersForPair convertersForPair = (convertiblePair);
if (convertersForPair != null) {
GenericConverter converter = Converter(sourceType, targetType);
if (converter != null) {
return converter;
}
}
// Check ConditionalConverters for a dynamic match
for (GenericConverter globalConverter : this.globalConverters) {
if (((ConditionalConverter) globalConverter).matches(sourceType, targetType)) {
return globalConverter;
}
}
return null;
}
我们可以看到，Spring 是通过源类型和⽬标类型组合起来，查对应的转换器。
⽽且，Spring 还通过getClassHierarchy⽅法，将源类型和⽬标类型的家族族谱全部列出来，⽤双层 for 循环遍历查。上⾯的代码中，还有⼀个matches⽅法，在这个⽅法⾥⾯，调⽤了ConverterFactory#getConverter⽅法
也就是⽤这个⼯⼚⽅法，创建了指定类型的转换器。
private final ConverterFactory<Object, Object> converterFactory;
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
boolean matches = true;
if (verterFactory instanceof ConditionalConverter) {
matches = ((ConditionalConverter) verterFactory).matches(sourceType, targetType);
}
if (matches) {
Converter<?, ?> converter = Type());
if (converter instanceof ConditionalConverter) {
matches = ((ConditionalConverter) converter).matches(sourceType, targetType);
}
}
return matches;
}
类型转换
经过上⾯的逻辑，已经到判断可以进⾏转换。
onvert.support.GenericConversionService#convert
其核⼼逻辑就是已经到对应的转换器了，下⾯就是转换逻辑
public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
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 && !ObjectType().isInstance(source)) {
throw new IllegalArgumentException("Source to convert from must be an instance of [" +
sourceType + "]; instead it was a [" + Class().getName() + "]");
}
GenericConverter converter = getConverter(sourceType, targetType);
if (converter != null) {
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论