目录
前言
这篇博客过后,我的基本疑问也就解决了,这个国庆节,了解了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