所有的请求最终都会落到doDispatch方法中的
ha.handle(processedRequest, response, mappedHandler.getHandler())逻辑。
我们从这里出发,一层一层向里扒。
跟着代码深入,我们会找到
org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest的逻辑:
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception { Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); if (logger.isTraceEnabled()) { logger.trace("Arguments: " + Arrays.toString(args)); } return doInvoke(args); }
可以看出,这里面通过getMethodArgumentValues方法处理参数,然后调用doInvoke方法获取返回值。
继续深入,能够找到
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver#resolveArgument方法
这个方法就是解析参数的逻辑。
试想一下,如果是我们自己实现这段逻辑,会怎么做呢?
获取输入参数的逻辑在
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver#resolveName
单参数返回的是 String 类型,多参数返回 String 数组。
核心代码如下:
String[] paramValues = request.getParameterValues(name); if (paramValues != null) { arg = (paramValues.length == 1 ? paramValues[0] : paramValues); }
所以说,无论我们的目标参数是什么,输入参数都是 String 类型或 String 数组
在我们的例子中,就是将 String 转换为枚举值。
org.springframework.beans.TypeConverterDelegate#convertIfNecessary方法中
继续深扒找到这么一段逻辑:
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) { try { return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor); } catch (ConversionFailedException ex) { // fallback to default conversion logic below conversionAttemptEx = ex; } }
这段逻辑中,调用了
org.springframework.core.convert.support.GenericConversionService#canConvert方法
检查是否可转换,如果可以转换,将会执行类型转换逻辑。
检查是否可转换的本质就是检查是否能够找到对应的转换器。
我们可以看看查找转换器的代码
org.springframework.core.convert.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 = this.converterCache.get(key); if (converter != null) { return (converter != NO_MATCH ? converter : null); } converter = this.converters.find(sourceType, targetType); if (converter == null) { converter = getDefaultConverter(sourceType, targetType); } if (converter != null) { this.converterCache.put(key, converter); return converter; } this.converterCache.put(key, NO_MATCH); return null; }
转换为伪代码就是:
Spring 内部使用Map作为缓存,用来存储通用转换器接口GenericConverter,这个接口会是我们自定义转换器的包装类。
不过,对于 web 请求场景,并发损耗好过阻塞等待。
org.springframework.core.convert.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 = getClassHierarchy(sourceType.getType()); List<Class<?>> targetCandidates = getClassHierarchy(targetType.getType()); 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 = this.converters.get(convertiblePair); if (convertersForPair != null) { GenericConverter converter = convertersForPair.getConverter(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 (this.converterFactory instanceof ConditionalConverter) { matches = ((ConditionalConverter) this.converterFactory).matches(sourceType, targetType); } if (matches) { Converter<?, ?> converter = this.converterFactory.getConverter(targetType.getType()); if (converter instanceof ConditionalConverter) { matches = ((ConditionalConverter) converter).matches(sourceType, targetType); } } return matches; }
经过上面的逻辑,已经找到判断可以进行转换。
org.springframework.core.convert.support.GenericConversionService#convert
其核心逻辑就是已经找到对应的转换器了,下面就是转换逻辑
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() + "]"); } GenericConverter converter = getConverter(sourceType, targetType); if (converter != null) { Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType); return handleResult(sourceType, targetType, result); } return handleConverterNotFound(source, sourceType, targetType); }
其中的GenericConverter converter = getConverter(sourceType, targetType)就是前文中getConverter方法。
执行到这里,直接调用
ConversionUtils.invokeConverter(converter, source, sourceType, targetType)转换
其内部是使用
org.springframework.core.convert.support.GenericConversionService.ConverterFactoryAdapter#convert
方法,代码如下:
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { if (source == null) { return convertNullSource(sourceType, targetType); } return this.converterFactory.getConverter(targetType.getObjectType()).convert(source); }
这里就是调用ConverterFactory工厂类构建转换器(即IdCodeToEnumConverterFactory类的getConverter方法)
然后调用转换器的conver方法(即IdCodeToEnumConverter类的convert方法),将输入参数转换为目标类型。
具体实现可以看一下实战篇中的代码,这里不做赘述。
至此,我们把整个路程通了下来。
这里需要强调一下的是,由于实战篇中我们用到的例子是简单参数的方式,也就是Controller的方法参数都是直接参数
但是 HTTP Body 方式却不行,为什么呢?
所以,想要实现 body 的类型转换,还需要走另外一种方式,更多关于Spring对应转换器的枚举参数的资料请关注其它相关文章!