目录
前言
这篇博客过后，我的基本疑问也就解决了，这个国庆节，了解了springmvc基本工作原理、springmvc如何获得控制器方法（HandlerMapping与HandlerAdapter），springmvc如何进行参数转换（HttpMessageConveter、转换器、格式化器），这篇博客将介绍SpringMVC如何进行参数绑定，即如何知道哪个http参数对应哪个形参，本片博客的springmvc版本为5.1.0，参数绑定一般出现在RequestMappingHandlerAdapter中，因此以下会阅读RequestMappingHandlerAdapter的源码
HandlerMethodArgumentResolver
这个接口是请求参数绑定的核心接口，不同的参数类型绑定都是通过实现这个接口来实现。也可以通过实现这个接口来自定义参数解析器。源码如下：
public interface HandlerMethodArgumentResolver {
/**
* Whether the given {@linkplain MethodParameter method parameter} is
* supported by this resolver.
* @param parameter the method parameter to check
* @return {@code true} if this resolver supports the supplied parameter;
* {@code false} otherwise
*/
boolean supportsParameter(MethodParameter parameter);
/**
* Resolves a method parameter into an argument value from a given request.
* A {@link ModelAndViewContainer} provides access to the model for the
* request. A {@link WebDataBinderFactory} provides a way to create
* a {@link WebDataBinder} instance when needed for data binding and
* type conversion purposes.
* @param parameter the method parameter to resolve. This parameter must
* have previously been passed to {@link #supportsParameter} which must
* have returned {@code true}.
* @param mavContainer the ModelAndViewContainer for the current request
* @param webRequest the current request
* @param binderFactory a factory for creating {@link WebDataBinder} instances
* @return the resolved argument value, or {@code null} if not resolvable
* @throws Exception in case of errors with the preparation of argument values
*/
@Nullable
Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}ok，节省一下脑细胞，简单来说，supportsParameter表示当前解析器是否能解析当前参数，resolveArgument负责给形参填值
初始化
- RequestMappingHandlerAdapter继承了接口InitializingBean，意味着在构造函数执行完毕后，Spring会默认执行AfterPropertiesSet()方法，如下：
@Override public void afterPropertiesSet() { // Do this first, it may add ResponseBody advice beans initControllerAdviceCache(); //形参解析器 if (this.argumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } //@InitBinder使用的解析器 if (this.initBinderArgumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResol用于对Controller中函数执行的返回值进行处理操作的vers(); this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } //用于对Controller中函数执行的返回值进行解析的解析器 if (this.returnValueHandlers == null) { List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers(); this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers); } }
- 这个方法初始化了三个解析器，我们重点看初始化HandlerMethodArgumentResolver的getDefaultArgumentResolvers方法，如下：
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); // 基于注解的参数解析器 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false)); resolvers.add(new RequestParamMapMethodArgumentResolver()); resolvers.add(new PathVariableMethodArgumentResolver()); resolvers.add(new PathVariableMapMethodArgumentResolver()); resolvers.add(new MatrixVariableMethodArgumentResolver()); resolvers.add(new MatrixVariableMapMethodArgumentResolver()); resolvers.add(new ServletModelAttributeMethodProcessor(false)); resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice)); resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory())); resolvers.add(new RequestHeaderMapMethodArgumentResolver()); resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new SessionAttributeMethodArgumentResolver()); resolvers.add(new RequestAttributeMethodArgumentResolver()); // 基于类型的参数解析器 resolvers.add(new ServletRequestMethodArgumentResolver()); resolvers.add(new ServletResponseMethodArgumentResolver()); resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); resolvers.add(new RedirectAttributesMethodArgumentResolver()); resolvers.add(new ModelMethodProcessor()); resolvers.add(new MapMethodProcessor()); resolvers.add(new ErrorsMethodArgumentResolver()); resolvers.add(new SessionStatusMethodArgumentResolver()); resolvers.add(new UriComponentsBuilderMethodArgumentResolver()); // Custom arguments if (getCustomArgumentResolvers() != null) { resolvers.addAll(getCustomArgumentResolvers()); } // Catch-all resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true)); resolvers.add(new ServletModelAttributeMethodProcessor(true)); return resolvers; }这个方法在resolvers中注册了许多解析器，我们可以看到resolvers最终被注入到argumentResolvers中，这是一个HandlerMethodArgumentResolverComposite类型，这个类型有两个属性：
//存放所有的解析器，注意到这是一个链表 private final List<HandlerMethodArgumentResolver> argumentResolvers = new LinkedList<>(); //使用过的参数解析器会被缓存，以便加快查找，注意到这个一个Map，速度比链表块 private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =new ConcurrentHashMap<>(256);至此，初始化完毕，接下来看看springmvc是如何进行参数匹配的
解析器匹配
之前的博客中有总结DispatcherServlet的工作流程，首先会根据HandleMapping获得HandlerExecutionChain，接着获得HandlerAdapter，然后调用HandlerAdapter的handle方法，我们来看看RequestMappingHandlerAdapter的handle方法，如下：
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return handleInternal(request, response, (HandlerMethod) handler);
}该方法来自父类AbstractHandlerMethodAdapter，RequestMappingHandlerAdapter覆盖了handleInternal方法，这个方法最终会执行invokeHandlerMethod方法，这个方法冗余信息比较多，我不打算贴代码，核心是会实例化ServletInvocableHandlerMethod类（继承了HandlerMethod接口以及InvocableHandlerMethod类），并设置其部分值，如下：
- HandlerMethod：DispatcherServlet传递过来的，即HandleMapping解析得到的HandlerMethod，这个对象的更多信息请查看之前的博客：https://blog.csdn.net/dhaiuda/article/details/82958485
- argumentResolvers：HandlerMethodArgumentResolverComposite类型，这个对象含有所有解析器，上面写了
- returnValueHandlers：HandlerMethodReturnValueHandlerComposite类型，这个对象主要对方法的返回值进行解析
- binderFactory：WebDataBinderFactory类型，实际上是ServletRequestDataBinderFactory类型，返回WebDAtaBinder，可用于类型转换
- parameterNameDiscoverer：parameterNameDiscoverer类型，必要时可用于解析方法参数名
可以看到这个对象含有控制器形参有关的一切信息，包括控制器方法的信息（HandlerMethod）、解析器（rgumentResolvers）等，那么还缺少http请求的相关信息，这个方法内部还会初始化ServletWebRequest类型（包含servlet的response以及request）以及ModelAndViewContainer类型
接着这个对象会调用如下方法，ServletWebRequest中包含有HttpServletRequest和HttpServletResponse的实例对象，此时缺少的http请求相关信息也有了
void InvokeAndHandle（ServletWebRequest request，ModelAndViewContainer mavContainer，Object .....providedArgs）InvokeAndHandle方法内部会首先调用如下方法：
Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs)invokeForRequest方法内部会首先调用如下方法：
Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs)invokeForRequest、getMethodArgumentValues方法均来自ServletInvocableHandlerMethod的父类InvocableHandlerMethod，getMethodArgumentValues方法完成参数解析与匹配，如下：
private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//获得控制器形参的所有信息
MethodParameter[] parameters = getMethodParameters();
//存储控制器形参的值
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
//尝试从形参providedArgs获得控制器形参的值，但前面的方法调用都没有传递providedArg的值，所以args[i]=null
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
//重点，此时会遍历解析器，选择合适的解析器进行转换
if (this.argumentResolvers.supportsParameter(parameter)) {
try {
args[i] = this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);
continue;
}
catch (Exception ex) {
// Leave stack trace for later, e.g. AbstractHandlerExceptionResolver
if (logger.isDebugEnabled()) {
String message = ex.getMessage();
if (message != null && !message.contains(parameter.getExecutable().toGenericString())) {
logger.debug(formatArgumentError(parameter, message));
}
}
throw ex;
}
}
if (args[i] == null) {
throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
}
}
return args;
}HandlerMethodArgumentResolverComposite的supportsParameter只会调用getArgumentResolver方法，如下：
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
//首先查看缓存，是否有对应的解析器
HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
//不存在，进行遍历，调用每个解析器的supportsParameter方法，若返回为True，则将其加入到缓存中并返回
if (result == null) {
for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
if (methodArgumentResolver.supportsParameter(parameter)) {
result = methodArgumentResolver;
this.argumentResolverCache.put(parameter, result);
break;
}
}
}
return result;
}接着来看HandlerMethodArgumentResolverComposite的resolveArgument方法：
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
//内部还是会调用一次getArgumentResolver，由于之前缓存过，所以速度会比较快
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
if (resolver == null) {
throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
}
//调用resolver的resolveArgument方法
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}至此，解析器寻找完毕，并且进行参数解析，不同的解析器执行的方法不同，但都大同小异，基本是根据参数的注解以及参数的Type去http请求中拿值，这里我们看看RequestParamMethodArgumentResolver解析器，这个解析器负责处理@RequestParam注解以及http参数名与形参名一致的情况，这个类的resolveArgument方法是调用父类AbstractNamedValueMethodArgumentResolver中的：
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
省略部分代码
..............
//获得形参的名字，resolveStringValue用于占位符的解析，最终获得的resolvedname为形参的名字
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
MethodParameter nestedParameter = parameter.nestedIfOptional();
Object resolvedName = resolveStringValue(namedValueInfo.name);
//从http请求中获取参数
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
............省略部分代码
//进行参数类型呢转换
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());
}
}重点是resolveName(resolvedName.toString(), nestedParameter, webRequest)方法，这个方法在RequestParamMethodArgumentResolver中：
protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
...........省略部分代码
//获取name的参数值
if (arg == null) {
String[] paramValues = request.getParameterValues(name);
if (paramValues != null) {
arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
}
}
return arg;
}request是ServletWebRequest类型，它会调用父类ServletRequestAttributes的getParameterValues方法，这个方法会使用HttpServletRequest对象，最终调用HttpServletRequest的getParameterValues方法，至此，我们终于看到了servlet API的影子，此时返回的参数值都是String类型，接下来会进行参数类型转换，我们来看看WebDataBinder类型的convertIfNecessary方法，如下：
public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
@Nullable MethodParameter methodParam) throws TypeMismatchException {
//获得类型转换器，调用convertIfNecessary方法进行类型转换
return getTypeConverter().convertIfNecessary(value, requiredType, methodParam);
}最终看到了转换器的影子，这个转换方法经过了许多封装，我找到的部分如下：
public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException{
............省略部分代码
// Custom editor for this type?
PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
ConversionFailedException conversionAttemptEx = null;
// No custom editor but custom ConversionService specified?
ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
try {
//调用convert方法，终于见到了与转换器有关的方法
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
}
catch (ConversionFailedException ex) {
// fallback to default conversion logic below
conversionAttemptEx = ex;
}
}
}
.............省略很多代码
}默认情况下，使用conversionService的实现类DefaultConversionService，在这个类中，可以看到转换器的注册（还有其他方法注册转换器，这里就不贴了）：
public static void addDefaultConverters(ConverterRegistry converterRegistry) {
addScalarConverters(converterRegistry);
addCollectionConverters(converterRegistry);
converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new StringToTimeZoneConverter());
converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());
converterRegistry.addConverter(new ObjectToObjectConverter());
converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new FallbackObjectToStringConverter());
converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}convert会遍历这些转换器，获得对应的转换器进行转换
总结
- RequestMappingHandlerAdapter初始化，实例化各种各样的HandlerMethodArgumentResolver（即请求参数转换器），同时会初始化HttpMessageConveter的实现类
- DispatcherServlet调用RequestMappingHandlerAdapter的handle方法，这个方法最终调用getMethodArgumentValues方法
- getMethodArgumentValues方法内部完成解析器的匹配（通过参数的注解或是参数的Type）
- 调用解析器的resolveArgument方法，这个方法内部可以看到转换器以及servlet API的身影，将参数转换为控制器所需要的类型
综上，SpringMVC的请求参数绑定解析完毕，但是似乎没有看到HttpMessageConveter的身影，这是因为在某些解析器中才会使用HttpMessageConveter
2595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
