HandlerAdapter 组件
HandlerAdapter 组件,处理器的适配器。因为处理器 handler
的类型是 Object 类型,需要有一个调用者来实现 handler
是怎么被执行。Spring 中的处理器的实现多变,比如用户的处理器可以实现 Controller 接口或者 HttpRequestHandler 接口,也可以用 @RequestMapping
注解将方法作为一个处理器等,这就导致 Spring MVC 无法直接执行这个处理器。所以这里需要一个处理器适配器,由它去执行处理器
由于 HandlerMapping 组件涉及到的内容较多,考虑到内容的排版,所以将这部分内容拆分成了五个模块,依次进行分析:
- 《HandlerAdapter 组件(一)之 HandlerAdapter》
- 《HandlerAdapter 组件(二)之 ServletInvocableHandlerMethod》
- 《HandlerAdapter 组件(三)之 HandlerMethodArgumentResolver》
- 《HandlerAdapter 组件(四)之 HandlerMethodReturnValueHandler》
- 《HandlerAdapter 组件(五)之 HttpMessageConverter》
HandlerAdapter 组件(三)之 HandlerMethodArgumentResolver
本文是接着 《HandlerAdapter 组件(二)之 ServletInvocableHandlerMethod》 一文来分享 HandlerMethodArgumentResolver 组件。在 HandlerAdapter
执行处理器的过程中,具体的执行过程交由 ServletInvocableHandlerMethod
对象来完成,其中需要先通过 HandlerMethodArgumentResolver 参数解析器从请求中解析出方法的入参,然后再通过反射机制调用对应的方法。
回顾
先来回顾一下 ServletInvocableHandlerMethod
在哪里调用参数解析器的,可以回到 《HandlerAdapter 组件(二)之 ServletInvocableHandlerMethod》 中 InvocableHandlerMethod 小节下面的 getMethodArgumentValues
方法,如下:
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
// 获得方法的参数
MethodParameter[] parameters = getMethodParameters();
// 无参,返回空数组
if (ObjectUtils.isEmpty(parameters)) {
return EMPTY_ARGS;
}
// 将参数解析成对应的类型
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
// 获得当前遍历的 MethodParameter 对象,并设置 parameterNameDiscoverer 到其中
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
// <1> 先从 providedArgs 中获得参数。如果获得到,则进入下一个参数的解析,默认情况 providedArgs 不会传参
args[i] = findProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
// <2> 判断 resolvers 是否支持当前的参数解析
if (!this.resolvers.supportsParameter(parameter)) {
throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
}
try {
// 执行解析,解析成功后,则进入下一个参数的解析
args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
}
catch (Exception ex) {
// Leave stack trace for later, exception may actually be resolved and handled...
if (logger.isDebugEnabled()) {
String exMsg = ex.getMessage();
if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
logger.debug(formatArgumentError(parameter, exMsg));
}
}
throw ex;
}
}
return args;
}
<2>
处,在获取到 Method 方法的所有参数对象,依次处理,根据resolvers
判断是否支持该参数的处理,如果支持则进行参数转换resolvers
为 HandlerMethodArgumentResolverComposite 组合对象,包含了许多的参数解析器
HandlerMethodArgumentResolver 接口
org.springframework.web.method.support.HandlerMethodArgumentResolver
,方法参数解析器
public interface HandlerMethodArgumentResolver {
/**
* 是否支持解析该参数
*/
boolean supportsParameter(MethodParameter parameter);
/**
* 解析该参数
*/
@Nullable
Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}
类图
因为请求入参的场景非常多,所以 HandlerMethodArgumentResolver 的实现类也非常多,上面仅列出了部分实现类,本文也 仅 分析上面图中右侧常见的几种参数场景
HandlerMethodArgumentResolverComposite
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
,实现 HandlerMethodArgumentResolver 接口,复合的 HandlerMethodArgumentResolver 实现类
构造方法
public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
/**
* HandlerMethodArgumentResolver 数组
*/
private final List<HandlerMethodArgumentResolver> argumentResolvers = new LinkedList<>();
/**
* MethodParameter 与 HandlerMethodArgumentResolver 的映射,作为缓存
*/
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache = new ConcurrentHashMap<>(256);
}
argumentResolvers
:HandlerMethodArgumentResolver 数组。这就是 Composite 复合~argumentResolverCache
:MethodParameter 与 HandlerMethodArgumentResolver 的映射,作为 缓存 。因为,MethodParameter 是需要从argumentResolvers
遍历到适合其的解析器,通过缓存后,无需再次重复遍历
在 《HandlerAdapter 组件(一)之 HandlerAdapter》 的 RequestMappingHandlerAdapter 小节的 getDefaultArgumentResolvers
方法中可以看到,默认的 argumentResolvers
有哪些 HandlerMethodArgumentResolver 实现类,注意这里是有顺序的添加哦
getArgumentResolver
getArgumentResolver(MethodParameter parameter)
方法,获得方法参数对应的 HandlerMethodArgumentResolver 对象,方法如下:
@Nullable
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
// 优先从 argumentResolverCache 缓存中,获得 parameter 对应的 HandlerMethodArgumentResolver 对象
HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
if (result == null) {
// 获得不到,则遍历 argumentResolvers 数组,逐个判断是否支持。
for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
// 如果支持,则添加到 argumentResolverCache 缓存中,并返回
if (resolver.supportsParameter(parameter)) {
result = resolver;
this.argumentResolverCache.put(parameter, result);
break;
}
}
}
return result;
}
很简单,先从argumentResolverCache
缓存中获取,没有获取到则遍历 argumentResolvers
,如果支持该参数则该 HandlerMethodArgumentResolver 对象并缓存起来
注意 ,往 argumentResolvers
添加的顺序靠前,则优先判断是否支持该参数哦~
supportsParameter
实现 supportsParameter(MethodParameter parameter)
方法,如果能获得到对应的 HandlerMethodArgumentResolver 参数处理器,则说明支持处理该参数,方法如下:
@Override
public boolean supportsParameter(MethodParameter parameter) {
return getArgumentResolver(parameter) != null;
}
resolveArgument
实现 resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
方法,解析出指定参数的值,方法如下:
@Override
@Nullable
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
// 获取参数解析器
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
if (resolver == null) {
throw new IllegalArgumentException("Unsupported parameter type [" +
parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
}
/**
* 进行解析
*
* 基于 @RequestParam 注解
* {@link org.springframework.web.method.annotation.RequestParamMethodArgumentResolver#resolveArgument}
* 基于 @PathVariable 注解
* {@link org.springframework.web.servlet.mvc.method.annotation.PathVariableMethodArgumentResolver#resolveArgument}
*/
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
很简单,获取到该方法参数对应的 HandlerMethodArgumentResolver 参数处理器,然后调用其 resolveArgument
执行解析
AbstractNamedValueMethodArgumentResolver
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
,实现 ValueMethodArgumentResolver 接口,基于名字获取值的HandlerMethodArgumentResolver 抽象基类。例如说,@RequestParam(value = "username")
注解的参数,就是从请求中获得 username
对应的参数值。 明白了么?
AbstractNamedValueMethodArgumentResolver 的子类也有挺多了,我们仅分析它的两个子类,如上面 类图 的下面两个:
- RequestParamMethodArgumentResolver :基于
@RequestParam
注解( 也可不加该注解的请求参数 )的方法参数,详情见下文 - PathVariableMethodArgumentResolver ,基于
@PathVariable
注解的方法参数,详情见下文
构造方法
public abstract class AbstractNamedValueMethodArgumentResolver implements HandlerMethodArgumentResolver {
@Nullable
private final ConfigurableBeanFactory configurableBeanFactory;
@Nullable
private final BeanExpressionContext expressionContext;
/**
* MethodParameter 和 NamedValueInfo 的映射,作为缓存
*/
private final Map<MethodParameter, NamedValueInfo> namedValueInfoCache = new ConcurrentHashMap<>(256);
}
NamedValueInfo 内部类
AbstractNamedValueMethodArgumentResolver 的静态内部类,代码如下:
protected static class NamedValueInfo {
/**
* 名字
*/
private final String name;
/**
* 是否必填
*/
private final boolean required;
/**
* 默认值
*/
@Nullable
private final String defaultValue;
public NamedValueInfo(String name, boolean required, @Nullable String defaultValue) {
this.name = name;
this.required = required;
this.defaultValue = defaultValue;
}
}
getNamedValueInfo
private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {
// <1> 从 namedValueInfoCache 缓存中,获得 NamedValueInfo 对象
NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
if (namedValueInfo == null) {
// <2> 获得不到,则创建 namedValueInfo 对象。这是一个抽象方法,子类来实现
namedValueInfo = createNamedValueInfo(parameter);
// <3> 更新 namedValueInfo 对象
namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
// <4> 添加到 namedValueInfoCache 缓存中
this.namedValueInfoCache.put(parameter, namedValueInfo);
}
return namedValueInfo;
}
- 从
namedValueInfoCache
缓存中,获得 NamedValueInfo 对象,获取到则直接返回 - 获得不到,则调用
createNamedValueInfo(MethodParameter parameter)
方法,创建 NamedValueInfo 对象。这是一个 抽象 方法,交由子类来实现 - 调用
updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info)
方法,更新 NamedValueInfo 对象,方法如下:
private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {
String name = info.name;
if (info.name.isEmpty()) {
// 【注意!!!】如果 name 为空,则使用参数名
name = parameter.getParameterName();
if (name == null) {
throw new IllegalArgumentException(
"Name for argument type [" + parameter.getNestedParameterType().getName() +
"] not available, and parameter name information not found in class file either.");
}
}
// 获得默认值
String defaultValue = (ValueConstants.DEFAULT_NONE.equals(info.defaultValue) ? null : info.defaultValue);
// 创建 NamedValueInfo 对象
return new NamedValueInfo(name, info.required, defaultValue);
}
如果名称为空,则取参数名,获取默认值,创建一个新的 NamedValueInfo 对象返回
- 添加到
namedValueInfoCache
缓存中 - 返回该 NamedValueInfo 对象
resolveArgument
resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
方法,从请求中解析出指定参数的值
@Override
@Nullable
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
// <1> 获得方法参数对应的 NamedValueInfo 对象。
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
// <2> 如果 parameter 是内嵌类型(Optional 类型)的,则获取内嵌的参数。否则,还是使用 parameter 自身
MethodParameter nestedParameter = parameter.nestedIfOptional();
// <3> 如果 name 是占位符,则进行解析成对应的值
Object resolvedName = resolveStringValue(namedValueInfo.name);
if (resolvedName == null) {
// 如果解析不到,则抛出 IllegalArgumentException 异常
throw new IllegalArgumentException(
"Specified name must not resolve to null: [" + namedValueInfo.name + "]");
}
// <4> 解析 name 对应的值
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
// <5> 如果 arg 不存在,则使用默认值
if (arg == null) {
// <5.1> 使用默认值
if (namedValueInfo.defaultValue != null) {
arg = resolveStringValue(namedValueInfo.defaultValue);
}
// <5.2> 如果是必填,则处理参数缺失的情况
else if (namedValueInfo.required && !nestedParameter.isOptional()) {
handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
}
// <5.3> 处理空值的情况
arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
}
// <6> 如果 arg 为空串,则使用默认值
else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
arg = resolveStringValue(namedValueInfo.defaultValue);
}
// <7> 数据绑定相关
if (binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
try {
arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
}
catch (ConversionNotSupportedException ex) {
throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
namedValueInfo.name, parameter, ex.getCause());
}
catch (TypeMismatchException ex) {
throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
namedValueInfo.name, parameter, ex.getCause());
}
}
// <8> 处理解析的值
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
return arg;
}
- 调用
getNamedValueInfo(MethodParameter parameter)
方法,获得方法参数对应的 NamedValueInfo 对象 - 如果
parameter
是内嵌类型(Optional 类型)的,则获取内嵌的参数。否则,还是使用parameter
自身。一般情况下,parameter
参数,我们不太会使用 Optional 类型。可以暂时忽略 - 调用
resolveStringValue(String value)
方法,如果name
是占位符,则进行解析成对应的值,方法如下:
@Nullable
private Object resolveStringValue(String value) {
// 如果 configurableBeanFactory 为空,则不进行解析
if (this.configurableBeanFactory == null) {
return value;
}
// 获得占位符对应的值
String placeholdersResolved = this.configurableBeanFactory.resolveEmbeddedValue(value);
// 获取表达式处理器对象
BeanExpressionResolver exprResolver = this.configurableBeanFactory.getBeanExpressionResolver();
if (exprResolver == null || this.expressionContext == null) {
return value;
}
// 计算表达式
return exprResolver.evaluate(placeholdersResolved, this.expressionContext);
}
这种用法非常小众,从来没用过。示例如下:
// Controller.java
@RequestMapping("/hello3")
public String hello3(@RequestParam(value = "${server.port}") String name) {
return "666";
}
// application.properties
server.port=8012
此时,就可以发送 `GET /hello3?8012=xxx` 请求
-
【重点】 调用
resolveName(String name, MethodParameter parameter, NativeWebRequest request)
抽象 方法,解析参数名name
对应的值,交由子类去实现 -
如果上面解析出来的参数值
arg
为null
,则使用默认值- 如果默认值非空,则调用
resolveStringValue(defaultValue)
方法,解析默认值 - 如果是必填,则调用
handleMissingValue(handleMissingValue)
方法,处理参数缺失的情况调用,也就是抛出指定的异常 - 调用
handleNullValue(String name, Object value, Class<?> paramType)
方法,处理null
值的情况,方法如下:
- 如果默认值非空,则调用
@Nullable
private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
if (value == null) {
if (Boolean.TYPE.equals(paramType)) {
return Boolean.FALSE;
} else if (paramType.isPrimitive()) { // 如果是基本类型则不能为 null
throw new IllegalStateException("Optional " + paramType.getSimpleName() + " parameter '" + name +
"' is present but cannot be translated into a null value due to being declared as a " +
"primitive type. Consider declaring it as object wrapper for the corresponding primitive type.");
}
}
return value;
}
- 否则,如果
arg
为空字符串,并且存在默认值,则和上面的5.1
相同处理方式 - 数据绑定相关,暂时忽略
- 调用
handleResolvedValue(Object arg, String name, MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
方法,解析参数值的后置处理,空方法,子类可以覆盖,子类 PathVariableMethodArgumentResolver 会重写该方法
代码有点长,不过逻辑不难理解
RequestParamMethodArgumentResolver
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
,实现 UriComponentsContributor 接口,继承 AbstractNamedValueMethodArgumentResolver 抽象类,参数解析器 HandlerMethodArgumentResolver 的实现类,处理 普通的请求参数
构造方法
public class RequestParamMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver
implements UriComponentsContributor {
private static final TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(String.class);
/**
* 是否使用默认解决
*
* 这个变量有点绕,见 {@link #supportsParameter(MethodParameter)} 方法
*/
private final boolean useDefaultResolution;
public RequestParamMethodArgumentResolver(boolean useDefaultResolution) {
this.useDefaultResolution = useDefaultResolution;
}
public RequestParamMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory,
boolean useDefaultResolution) {
super(beanFactory);
this.useDefaultResolution = useDefaultResolution;
}
}
supportsParameter
实现 supportsParameter(MethodParameter parameter)
方法,判断是否支持处理该方法入参,方法如下:
@Override
public boolean supportsParameter(MethodParameter parameter) {
// <3> 有 @RequestParam 注解的情况
if (parameter.hasParameterAnnotation(RequestParam.class)) {
// <3.1> 如果是 Map 类型,则 @RequestParam 注解必须要有 name 属性
if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
return (requestParam != null && StringUtils.hasText(requestParam.name()));
}
else {
// <3.2> 否则返回 true
return true;
}
}
else {
// 如果有 @RequestPart 注解,返回 false 。即 @RequestPart 的优先级 > @RequestParam
if (parameter.hasParameterAnnotation(RequestPart.class)) {
return false;
}
// 获得参数,如果存在内嵌的情况
parameter = parameter.nestedIfOptional();
// <1> 如果 Multipart 参数。则返回 true ,表示支持
if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
return true;
}
// <2> 如果开启 useDefaultResolution 功能,则判断是否为普通类型
else if (this.useDefaultResolution) {
return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
}
// 其它,不支持
else {
return false;
}
}
}
- 如果 Multipart 参数。则返回 true ,表示支持调用
MultipartResolutionDelegate#isMultipartArgument(parameter)
方法,如果 Multipart 参数。则返回true
,表示支持。代码如下:
public static boolean isMultipartArgument(MethodParameter parameter) {
Class<?> paramType = parameter.getNestedParameterType();
return (MultipartFile.class == paramType ||
isMultipartFileCollection(parameter) || isMultipartFileArray(parameter) ||
(Part.class == paramType || isPartCollection(parameter) || isPartArray(parameter)));
}
上传文件相关类型
- 如果开启
useDefaultResolution
功能,则调用BeanUtils#isSimpleProperty(Class<?> clazz)
方法,判断是否为普通类型,代码如下:
public static boolean isSimpleProperty(Class<?> type) {
Assert.notNull(type, "'type' must not be null");
return isSimpleValueType(type) || (type.isArray() && isSimpleValueType(type.getComponentType()));
}
public static boolean isSimpleValueType(Class<?> type) {
return (type != void.class && type != Void.class &&
(ClassUtils.isPrimitiveOrWrapper(type) ||
Enum.class.isAssignableFrom(type) ||
CharSequence.class.isAssignableFrom(type) ||
Number.class.isAssignableFrom(type) ||
Date.class.isAssignableFrom(type) ||
URI.class == type ||
URL.class == type ||
Locale.class == type ||
Class.class == type));
}
那么 `useDefaultResolution` 到底是怎么被赋值的呢?回到 RequestMappingHandlerAdapter 的 `getDefaultArgumentResolvers()` 的方法,精简代码如下:
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();
// Annotation-based argument resolution
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
// ... 省略许多 HandlerMethodArgumentResolver 的添加
// Catch-all
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
resolvers.add(new ServletModelAttributeMethodProcessor(true));
return resolvers;
}
我们可以看到有两个 RequestParamMethodArgumentResolver 对象,前者 `useDefaultResolution` 为 `false` ,后者为 `useDefaultResolution` 为 `true` 。什么意思呢?优先将待有 `@RequestParam` 注解的请求参数给第一个 RequestParamMethodArgumentResolver 对象;其次,给中间省略的一大片参数解析器试试能不能解析;最后,使用第二个 RequestParamMethodArgumentResolver 兜底,处理剩余的情况。
-
如果该方法参数有
@RequestParam
注解的情况- 如果是 Map 类型,则
@RequestParam
注解必须要有 name 属性,是不是感觉有几分灵异?答案在下面的 RequestParamMapMethodArgumentResolver 中揭晓 - 否则,返回
true
- 如果是 Map 类型,则
createNamedValueInfo
实现父类的 createNamedValueInfo(MethodParameter parameter)
方法,创建 NamedValueInfo 对象,方法如下:
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
RequestParam ann = parameter.getParameterAnnotation(RequestParam.class);
return (ann != null ? new RequestParamNamedValueInfo(ann) : new RequestParamNamedValueInfo());
}
private static class RequestParamNamedValueInfo extends NamedValueInfo {
public RequestParamNamedValueInfo() {
super("", false, ValueConstants.DEFAULT_NONE);
}
public RequestParamNamedValueInfo(RequestParam annotation) {
super(annotation.name(), annotation.required(), annotation.defaultValue());
}
}
-
如果方法参数有
@RequestParam
注解,则根据注解创建一个 RequestParamNamedValueInfo 对象,获取注解中的name
、required
和defaultValue
配置 -
否则,就创建一个空的 RequestParamNamedValueInfo 对象,三个属性分别为,
空字符串
、false
和ValueConstants.DEFAULT_NONE
上面的 getNamedValueInfo 方法中讲述到,
name
为空字符串
没有关系,会获取方法的参数名说明:通过反射获取方法的参数名,我们只能获取到 arg0,arg1 的名称,因为jdk8之后这些变量名称没有被编译到class文件中,编译时需要指定
-parameters
选项,方法的参数名才会记录到class文件中,运行时我们就可以通过反射机制获取到,所以我们最好还是用@RequestParam
注解来标注ValueConstants.DEFAULT_NONE
则会设置为null
resolveName
实现 #resolveName(String name, MethodParameter parameter, NativeWebRequest request)
方法,获得参数的值,方法如下:
@Override
@Nullable
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
// 情况一,HttpServletRequest 情况下的 MultipartFile 和 Part 的情况
HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
if (servletRequest != null) {
Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
return mpArg;
}
}
// 情况二,MultipartHttpServletRequest 情况下的 MultipartFile 的情况
Object arg = null;
MultipartRequest multipartRequest = request.getNativeRequest(MultipartRequest.class);
if (multipartRequest != null) {
List<MultipartFile> files = multipartRequest.getFiles(name);
if (!files.isEmpty()) {
arg = (files.size() == 1 ? files.get(0) : files);
}
}
// 情况三,普通参数的获取
if (arg == null) {
String[] paramValues = request.getParameterValues(name);
if (paramValues != null) {
arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
}
}
return arg;
}
- 情况一、二,是处理参数类型为 文件
org.springframework.web.multipart.MultipartFile
和javax.servlet.http.Part
的参数的获取,例如我们常用到 MultipartFile 作为参数就是在这里处理的 - 情况三,是处理 普通 参数的获取。就是我们常见的 String、Integer 之类的请求参数,直接从请求中获取参数值就好了
因为在《MultipartResolver 组件》中讲过了会对请求进行处理,包括解析出参数,解析成对应的 HttpServletRequest 对象
获得到参数值后,就可以准备开始通过反射调用对应的方法了
RequestParamMapMethodArgumentResolver
org.springframework.web.method.annotation.RequestParamMapMethodArgumentResolver
,实现 HandlerMethodArgumentResolver 接口,用于处理带有 @RequestParam
注解,但是注解上没有 name
属性的 Map 类型的参数, HandlerMethodArgumentResolver 的实现类,代码如下:
public class RequestParamMapMethodArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(MethodParameter parameter) {
RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
return (requestParam != null && Map.class.isAssignableFrom(parameter.getParameterType()) &&
!StringUtils.hasText(requestParam.name()));
}
@Override
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
// MultiValueMap 类型的处理
if (MultiValueMap.class.isAssignableFrom(parameter.getParameterType())) {
Class<?> valueType = resolvableType.as(MultiValueMap.class).getGeneric(1).resolve();
if (valueType == MultipartFile.class) { // MultipartFile 类型
MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
return (multipartRequest != null ? multipartRequest.getMultiFileMap() : new LinkedMultiValueMap<>(0));
}
else if (valueType == Part.class) { // Part 类型
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
Collection<Part> parts = servletRequest.getParts();
LinkedMultiValueMap<String, Part> result = new LinkedMultiValueMap<>(parts.size());
for (Part part : parts) {
result.add(part.getName(), part);
}
return result;
}
return new LinkedMultiValueMap<>(0);
}
else {
Map<String, String[]> parameterMap = webRequest.getParameterMap();
MultiValueMap<String, String> result = new LinkedMultiValueMap<>(parameterMap.size());
parameterMap.forEach((key, values) -> {
for (String value : values) {
result.add(key, value);
}
});
return result;
}
}
// 普通 Map 类型的处理
else {
Class<?> valueType = resolvableType.asMap().getGeneric(1).resolve();
if (valueType == MultipartFile.class) { // MultipartFile 类型
MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
return (multipartRequest != null ? multipartRequest.getFileMap() : new LinkedHashMap<>(0));
}
else if (valueType == Part.class) { // Part 类型
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
Collection<Part> parts = servletRequest.getParts();
LinkedHashMap<String, Part> result = new LinkedHashMap<>(parts.size());
for (Part part : parts) {
if (!result.containsKey(part.getName())) {
result.put(part.getName(), part);
}
}
return result;
}
return new LinkedHashMap<>(0);
}
else {
Map<String, String[]> parameterMap = webRequest.getParameterMap();
Map<String, String> result = new LinkedHashMap<>(parameterMap.size());
parameterMap.forEach((key, values) -> {
if (values.length > 0) {
result.put(key, values[0]);
}
});
return result;
}
}
}
}
上面没有仔细看,实际上是有点看不懂,不知道处理场景就举两个例子吧
- 对于 RequestParamMapMethodArgumentResolver 类,它的效果是,将所有参数添加到 Map 集合中,示例如下:
// Controller.java
@RequestMapping("/hello")
public String hello4(@RequestParam Map<String, Object> map) {
return "666";
}
发送请求 `GET /hello?name=yyy&age=20`,`name` 和 `age` 参数,就会都添加到 `map` 中
- 对于 RequestParamMethodArgumentResolver 类,它的效果是,将指定名字的参数添加到 Map 集合中,示例如下:
// Controller.java
@RequestMapping("/hello")
public String hello5(@RequestParam(name = "map") Map<String, Object> map) {
return "666";
}
发送请求 `GET /hello4?map={"name": "yyyy", age: 20}`, `map` 参数的元素则都会添加到方法参数 `map` 中。当然,要注意下,实际请求要 UrlEncode 编码下参数,所以实际请求是 `GET /hello?map=%7b%22name%22%3a+%22yyyy%22%2c+age%3a+20%7d`
PathVariableMethodArgumentResolver
org.springframework.web.servlet.mvc.method.annotation.PathVariableMethodArgumentResolver
,实现 UriComponentsContributor 接口,继承 AbstractNamedValueMethodArgumentResolver 抽象类,处理路径参数
supportsParameter
实现 supportsParameter(MethodParameter parameter)
方法,判断是否支持处理该方法参数,代码如下:
@Override
public boolean supportsParameter(MethodParameter parameter) {
// <1> 如果无 @PathVariable 注解
if (!parameter.hasParameterAnnotation(PathVariable.class)) {
return false;
}
// <2> Map 类型,有 @PathVariable 注解,但是有 name 属性
if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
PathVariable pathVariable = parameter.getParameterAnnotation(PathVariable.class);
return (pathVariable != null && StringUtils.hasText(pathVariable.value()));
}
return true;
}
- 如果没有
@PathVariable
注解则直接返回fasle
,也就是说必须配置@PathVariable
注解 - 如果还是 Map 类型,则需要
@PathVariable
注解有name
属性,才返回true
,查看org.springframework.web.servlet.mvc.method.annotation.PathVariableMapMethodArgumentResolver
就理解了,和上述的逻辑差不多 - 否则,直接返回
true
createNamedValueInfo
实现 createNamedValueInfo(MethodParameter parameter)
方法,方法如下:
@Override
protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
// 获得 @PathVariable 注解
PathVariable ann = parameter.getParameterAnnotation(PathVariable.class);
Assert.state(ann != null, "No PathVariable annotation");
// 创建 PathVariableNamedValueInfo 对象
return new PathVariableNamedValueInfo(ann);
}
private static class PathVariableNamedValueInfo extends NamedValueInfo {
public PathVariableNamedValueInfo(PathVariable annotation) {
super(annotation.name(), annotation.required(), ValueConstants.DEFAULT_NONE);
}
}
必须要有 @PathVariable
注解,没有的话抛出异常,然后根据注解创建 PathVariableNamedValueInfo 对象
resolveName
实现 resolveName(String name, MethodParameter parameter, NativeWebRequest request)
方法,从请求路径中获取方法参数的值,方法如下:
@Override
@SuppressWarnings("unchecked")
@Nullable
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
// 获得路径参数
Map<String, String> uriTemplateVars = (Map<String, String>) request.
getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
// 获得参数值
return (uriTemplateVars != null ? uriTemplateVars.get(name) : null);
}
handleResolvedValue
重写 handleResolvedValue(Object arg, String name, MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest request)
方法,添加获得的属性值到请求的 View.PATH_VARIABLES
属性种,方法如下:
@Override
@SuppressWarnings("unchecked")
protected void handleResolvedValue(@Nullable Object arg, String name, MethodParameter parameter,
@Nullable ModelAndViewContainer mavContainer, NativeWebRequest request) {
// 获得 pathVars
String key = View.PATH_VARIABLES;
int scope = RequestAttributes.SCOPE_REQUEST;
Map<String, Object> pathVars = (Map<String, Object>) request.getAttribute(key, scope);
// 如果不存在 pathVars,则进行创建
if (pathVars == null) {
pathVars = new HashMap<>();
request.setAttribute(key, pathVars, scope);
}
// 添加 name + arg 到 pathVars 中
pathVars.put(name, arg);
}
具体用途还不清楚
总结
在 HandlerAdapter
执行 HandlerMethod
处理器的过程中,会将该处理器封装成 ServletInvocableHandlerMethod
对象,通过该对象来执行处理器。该对象通过反射机制调用对应的方法,在调用方法之前,借助 HandlerMethodArgumentResolver 参数解析器从请求中获取到对应的方法参数值,因为你无法确认哪个参数值对应哪个参数,所以需要先通过它从请求中解析出参数值,一一对应,然后才能调用该方法。
HandlerMethodArgumentResolver 参数解析器的实现类非常多,采用了组合模式来进行处理,如果有某一个参数解析器支持解析该方法参数,则使用它从请求体中获取到该方法参数的值,注意这里有一定的先后顺序,因为是通过 LinkedList 保存所有的实现类,排在前面的实现类则优先处理。
本文分析了我们常用的 @RequestParam
和 @PathVariable
注解所对应的 HandlerMethodArgumentResolver 实现类,如下:
RequestParamMethodArgumentResolver
:解析@RequestParam
注解配置参数(名称、是否必须、默认值),根据注解配置从请求获取参数值PathVariableMethodArgumentResolver
:解析@PathVariable
注解配置的(名称、是否必须),根据注解配置从请求路径中获取参数值
注意 ,关于方法参数为 Map 类型,应该如何配置,可以参考上面的 RequestParamMapMethodArgumentResolver
小节中的两个示例
关于其他的 HandlerMethodArgumentResolver 实现类,感兴趣的可以去看看
在接下来的 《HandlerAdapter 组件(四)之 HandlerMethodReturnValueHandler》 中讲到 RequestResponseBodyMethodProcessor 既是 HandlerMethodReturnValueHandler 实现类,也是 HandlerMethodArgumentResolver 实现类,用于处理器 @RequestBody 和 @ResponseBody 两个注解