HandlerMethodArgumentResolver源码分析
基于SpringBoot 2.2.0.RELEASE
先看下Spring对HandlerMethodArgumentResolver的接口定义
/**
*用于将请求上下文中的方法参数解析为参数值的策略接口
*/
public interface HandlerMethodArgumentResolver {
/**是否MethodParamter是否能被该resolver解析器支持
* @param parameter 待检查的方法参数
* @return {@code true} 如果解析器支持提供出来的参数 返回true
* 否则返回false
*/
boolean supportsParameter(MethodParameter parameter);
/**
* 将给定请求的方法参数解析为参数值
* @param parameter 要解析的方法参数。
* 此参数必须先前已传递给{supportsParameter}，该必须已返回{@code true}。
* 返回已解析的参数值，如果无法解析，则返回{@code null}
* @throws Exception 如果出错则抛出异常
*/
@Nullable
Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}
因为SpringMVC/SpringBoot中controller中方法入参对应多中情况，如@RequestParam类型的参数、@PathVariable类型的参数、@RequestBody类型的参数等等吧。相信HandlerMethodArgumentResolver提供了不同的实现类来根据参数类型解析对应的参数。
下面是常见HandlerMethodArgumentResolver实现类以及能处理的参数类型
- RequestParamMethodArgumentResolver
带有@RequestParam注解的参数；(与MultipartResolver结合使用的)参数类型是MultipartFile；(与Servlet 3.0 multipart requests结合使用的)参数类型是javax.servlet.http.Part的参数以及一些没有被@RequestParam修饰的基本数据类型，如int/long等。
- RequestParamMapMethodArgumentResolver
带有@RequestParam注解的类型是Map的参数
- PathVariableMethodArgumentResolver
带有@PathVaribale注解类型的参数
- RequestResponseBodyMethodProcessor
借助HttpMessageConverter，这个类是来解析注解为@RequestBody的请求参数和注解为@ResponseBody的响应内容
下面以源码分析其中的一些类
- RequestParamMethodArgumentResolver
public class RequestParamMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver
implements UriComponentsContributor {
@Override
public boolean supportsParameter(MethodParameter parameter) {
//如果参数有被@RequestParam注解标识
if (parameter.hasParameterAnnotation(RequestParam.class)) {
//如果方法参数的类型是Map
if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
//因为指定在@RequestParam注解中的name 是用来解析请求参数的value值的，
//所以下面是判断name是否存在，如果存在 则可以使用该解析器
return (requestParam != null && StringUtils.hasText(requestParam.name()));
}
else {
//如果被注解标注的不是Map类型
return true;
}
}
else {
//如果参数有被@RequestPart注解标识
if (parameter.hasParameterAnnotation(RequestPart.class)) {
return false;
}
parameter = parameter.nestedIfOptional();
//如果请求参数类型是MultipartFile
if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
return true;
}
//如果可以使用默认解析方案
else if (this.useDefaultResolution) {
return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
}
else {
return false;
}
}
}
//将给定的参数类型和值名称解析为参数值。
@Override
@Nullable
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
if (servletRequest != null) {
//如果方法中的参数是MultipartFile类型，则解析它的数据值
Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
return mpArg;
}
}
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;
}
}
- PathVariableMethodArgumentResolver
public class PathVariableMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver
implements UriComponentsContributor {
@Override
public boolean supportsParameter(MethodParameter parameter) {
//如果参数没有被@PathVariable标注
if (!parameter.hasParameterAnnotation(PathVariable.class)) {
return false;
}
//如果方法的参数类型是Map
if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
PathVariable pathVariable = parameter.getParameterAnnotation(PathVariable.class);
//因为指定在@PathVariable注解中的value 是用来解析请求参数的value值的，
//所以下面是判断value是否存在，如果存在 则可以使用该解析器
return (pathVariable != null && StringUtils.hasText(pathVariable.value()));
}
return true;
}
//AbstractNamedValueMethodArgumentResolver#resolveArgument会调用到
@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);
if (pathVars == null) {
pathVars = new HashMap<>();
request.setAttribute(key, pathVars, scope);
}
pathVars.put(name, arg);
}
@Override
@SuppressWarnings("unchecked")
@Nullable
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
//在url中的属性已经被spring容器解析 并放入org.springframework.web.servlet.HandlerMapping.uriTemplateVariables的key里
//如果我的url为a/{id},且我请求的时候给id赋值为1
//那么这里获取到的 map形如{"id",1}
Map<String, String> uriTemplateVars = (Map<String, String>) request.getAttribute(
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
//如果map不为空 根据key(name)取出value值
return (uriTemplateVars != null ? uriTemplateVars.get(name) : null);
}
}
经过发现，PathVariableMethodArgumentResolver和RequestParamMethodArgumentResolver的继承体系是一样的,而且resolveArgument是写在父类的。下面来看下AbstractNamedValueMethodArgumentResolver是如何解析参数的
//参数解析是一个参数一个参数的解析，
//如我controller中@RequestParam String a,@RequestParam String b
//则会执行两次参数解析
@Override
@Nullable
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
//获取参数的NameValueInfo,这个NameValueInfo其实就是name/required/defaultValue,
//相信使用过@RequestParam/@PathVariable注解的，应该比较熟悉，因为这是注解内的属性
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
MethodParameter nestedParameter = parameter.nestedIfOptional();
//解析注解的名称，因为注解的name属性中可能会含有占位符和表达式
Object resolvedName = resolveStringValue(namedValueInfo.name);
if (resolvedName == null) {
throw new IllegalArgumentException(
"Specified name must not resolve to null: [" + namedValueInfo.name + "]");
}
//解析获得参数的值
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
if (arg == null) {
//如果参数为空，但是配置了默认值 则以默认值作为参数值
if (namedValueInfo.defaultValue != null) {
arg = resolveStringValue(namedValueInfo.defaultValue);
}
//如果参数是必需的
else if (namedValueInfo.required && !nestedParameter.isOptional()) {
//如果解析的参数值是空的，而且这个字段也是必须的，就会执行到这里。
//AbstractNamedValueMethodArgumentResolver这里是抛出异常处理
handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
}
//如果某个参数不是必须的，并且解析出来的参数值是空
//这里方法的内部实现是：如果arg不为空 则返回arg；
//如果arg为空，如果方法类型为Boolean，则返回FALSE,
//如果是其他的基本数据类型 则抛出异常
arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
}
//如果解析出的arg为"",且默认值不为空
else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
arg = resolveStringValue(namedValueInfo.defaultValue);
}
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());
}
}
//PathVariable注解时 会执行到这个方法
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
return arg;
}
下面跟着RequestResponseBodyMethodProcessor类来看下Spring如何对@RequestBody和@ResponseBody做处理的。
从类的继承关系可以看出，RequestResponseBodyMethodProcessor既实现了HandlerMethodArgumentResolver又实现了HandlerMethodReturnValueHandler,因此具有了解析入参和响应结果的能力。
先从解析入参开始，老套路了，既然实现了HandlerMethodArgumentResolver，那么肯定会先根据supportParameter来判断当前参数解析器是否能够解析该注解的参数，然后再决定是否解析。
RequestResponseBodyMethodProcessor类
@Override
public boolean supportsParameter(MethodParameter parameter) {
//判断当前参数中是否有@RequestBody的注解，如果有则可以使用该参数解析器
return parameter.hasParameterAnnotation(RequestBody.class);
}
@Override
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
parameter = parameter.nestedIfOptional();
//根据MediaType选择合适的HTTPMessageConverter 来读取请求信息
//这个是解析参数的重要步骤，具体实现在其父类AbstractMessageConverterMethodArgumentResolver中做的操作
Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
String name = Conventions.getVariableNameForParameter(parameter);
if (binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
if (arg != null) {
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
}
}
if (mavContainer != null) {
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
}
}
return adaptArgumentIfNecessary(arg, parameter);
}
@Override
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
Assert.state(servletRequest != null, "No HttpServletRequest");
ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
//调用父类AbstractMessageConverterMethodArgumentResolver中的readWithMessageConverters
Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
if (arg == null && checkRequired(parameter)) {
throw new HttpMessageNotReadableException("Required request body is missing: " +
parameter.getExecutable().toGenericString(), inputMessage);
}
return arg;
}
AbstractMessageConverterMethodArgumentResolver
public abstract class AbstractMessageConverterMethodArgumentResolver implements HandlerMethodArgumentResolver {
@Nullable
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
MediaType contentType;
boolean noContentType = false;
try {
//获取请求头的content-type
contentType = inputMessage.getHeaders().getContentType();
}
catch (InvalidMediaTypeException ex) {
throw new HttpMediaTypeNotSupportedException(ex.getMessage());
}
if (contentType == null) {
noContentType = true;
//如果contentType为空 为其设置默认值
contentType = MediaType.APPLICATION_OCTET_STREAM;
}
//解析方法中的参数类型
Class<?> contextClass = parameter.getContainingClass();
Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
if (targetClass == null) {
ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
targetClass = (Class<T>) resolvableType.resolve();
}
//获取Http请求方法
HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
Object body = NO_VALUE;
EmptyBodyCheckingHttpInputMessage message;
try {
message = new EmptyBodyCheckingHttpInputMessage(inputMessage);
//messageConverters 是在SpringMVC上下文启动的加载进来的
//有框架提供的默认值，有根据classpath来决定加载某messageConverter的
for (HttpMessageConverter<?> converter : this.messageConverters) {
Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
GenericHttpMessageConverter<?> genericConverter =
(converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
//根据具体messageConverter能处理的content-type与实际请求的content-type来判断能否被
//messageConverter处理。
if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
(targetClass != null && converter.canRead(targetClass, contentType))) {
if (message.hasBody()) {
HttpInputMessage msgToUse =
getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
//如果能被具体某httpmessageconverter处理，则进行处理
//比如 能被MappingJackson2HttpMessageConverter处理，能被其方法read处理
//将请求参数 转为json
body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
}
else {
body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
}
break;
}
}
}
catch (IOException ex) {
throw new HttpMessageNotReadableException("I/O error while reading input message", ex, inputMessage);
}
//如果当前上下文中没有能够处理当前content-type类型参数的HTTPMessageConverter存在
if (body == NO_VALUE) {
//如果请求方法不存在或者不被支持或者请求参数没内容 那么返回null
if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
(noContentType && !message.hasBody())) {
return null;
}
//否则这里抛出异常
throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
}
MediaType selectedContentType = contentType;
Object theBody = body;
LogFormatUtils.traceDebug(logger, traceOn -> {
String formatted = LogFormatUtils.formatValue(theBody, !traceOn);
return "Read \"" + selectedContentType + "\" to [" + formatted + "]";
});
return body;
}
}
this.messageConverters如何被加载进上下文，可参考HttpMessageConverter
以上是常用注解的参数解析代码分析，但是由于SpringMVC框架 代码常用到很多设计模式，会出现 这一刻代码在这个类，下一刻就跑到了其某个实现类或父类等这样的情况。加之本人水平有限，所以会导致代码分析的时候，有种乱糟糟的感觉，望见谅。