SpringBoot 实战：优雅的使用枚举参数

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
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方法，这个方法就是解析参数的逻辑。

试想一下，如果是我们自己实现这段逻辑，会怎么做呢？

1. 获取输入参数

2. 找到目标参数

3. 检查是否需要特殊转换逻辑

4. 如果需要，进行转换

5. 如果不需要，直接返回

获取输入参数的逻辑在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 数组，然后 Spring 把它们转换为我们期望的类型。

找到目标参数的逻辑在DispatcherServlet中，根据 uri 找到对应的 Controller 处理方法，找到方法就找到了目标参数类型。

接下来就是检查是否需要转换逻辑，也就是org.springframework.validation.DataBinder#convertIfNecessary，顾名思义，如果需要就转换，将字符串类型转换为目标类型。在我们的例子中，就是将 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;

}

复制代码

转换为伪代码就是：

1. 根据参数类型和目标类型，构造缓存 key

2. 根据缓存 key，从缓存中查询转换器

3. 如果能找到且不是 NO_MATCH，返回转换器；如果是 NO_MATCH，返回 null；如果未找到，继续

4. 通过org.springframework.core.convert.support.GenericConversionService.Converters#find查询转换器

5. 如果未找到，检查源类型和目标类型是否可以强转，也就是类型一致。如果是，返回 NoOpConverter，如果否，返回 null。

6. 检查找到的转换器是否为 null，如果不是，将转换器加入到缓存中，返回该转换器

7. 如果否，在缓存中添加 NO_MATCH 标识，返回 null

Spring 内部使用Map作为缓存，用来存储通用转换器接口GenericConverter，这个接口会是我们自定义转换器的包装类。我们还可以看到，转换器缓存用的是ConcurrentReferenceHashMap，这个类是线程安全的，可以保证并发情况下，不会出现异常存储。但是getConverter方法没有使用同步逻辑。换句话说，并发请求时，可能存在性能损耗。不过，对于 web 请求场景，并发损耗好过阻塞等待。

我们在看下 Spring 是如何查找转换器的，在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;

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

大厂面试场景

知识点总结

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

[外链图片转存中…(img-MJnfhwF0-1714754503435)]

大厂面试场景

[外链图片转存中…(img-A6T1YXmM-1714754503436)]

知识点总结

[外链图片转存中…(img-XgrapBgC-1714754503436)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！