个人中心
gpt4 book ai didi

SpringMVC 参数绑定相关知识总结

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章SpringMVC 参数绑定相关知识总结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

请求进入DispatcherServlet的doDispatch后，获取HandlerMethod。然后根据HandlerMethod来确认HandlerApapter，确认后执行HandlerAdapter的handle方法。这里确认HandlerApater为RequestMappingHandlerAdapter，在执行handlerMethod之前，需要处理参数的绑定.

1. 简单参数绑定

执行HandlerAdapter的handler方法后，进入RequestMappingHandlerAdapter的invokeHandleMethod方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private ModelAndView invokeHandleMethod(HttpServletRequest request,
    HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
 
  ServletWebRequest webRequest = new ServletWebRequest(request, response);
 
  WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
  ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory); //根据handlerMethod和binderFactory创建一个ServletInvocableHandlerMethod。后续把请求直接交给ServletInvocableHandlerMethod执行。
  //createRequestMappingMethod方法比较简单，把之前RequestMappingHandlerAdapter初始化的argumentResolvers和returnValueHandlers添加至ServletInvocableHandlerMethod中
  ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);
 
  ModelAndViewContainer mavContainer = new ModelAndViewContainer();
  mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
  modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);
  mavContainer.setIgnoreDefaultModelOnRedirect( this .ignoreDefaultModelOnRedirect);
 
  AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
  asyncWebRequest.setTimeout( this .asyncRequestTimeout); final WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  asyncManager.setTaskExecutor( this .taskExecutor);
  asyncManager.setAsyncWebRequest(asyncWebRequest);
  asyncManager.registerCallableInterceptors( this .callableInterceptors);
  asyncManager.registerDeferredResultInterceptors( this .deferredResultInterceptors); if (asyncManager.hasConcurrentResult()) {
   Object result = asyncManager.getConcurrentResult();
   mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[ 0 ];
   asyncManager.clearConcurrentResult();  if (logger.isDebugEnabled()) {
    logger.debug( "Found concurrent result value [" + result + "]" );
   }
   requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);
  }
 
  requestMappingMethod.invokeAndHandle(webRequest, mavContainer); if (asyncManager.isConcurrentHandlingStarted()) {  return null ;
  } return getModelAndView(mavContainer, modelFactory, webRequest);
}

然后进入invokeAndHanldle方法，然后进入invokeForRequest方法，这个方法的职责是从request中解析出HandlerMethod方法所需要的参数，然后通过反射调用HandlerMethod中的method 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public final Object invokeForRequest(NativeWebRequest request,
           ModelAndViewContainer mavContainer,          Object... providedArgs) throws Exception {  //从request中解析出HandlerMethod方法所需要的参数，并返回Object[]
   Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);  if (logger.isTraceEnabled()) {
    StringBuilder builder = new StringBuilder( "Invoking [" );
    builder.append( this .getMethod().getName()).append( "] method with arguments " );
    builder.append(Arrays.asList(args));
    logger.trace(builder.toString());
   } 
   //通过反射执行HandleMethod中的method，方法参数为args。并返回方法执行的返回值
   Object returnValue = invoke(args);  if (logger.isTraceEnabled()) {
    logger.trace( "Method [" + this .getMethod().getName() + "] returned [" + returnValue + "]" );
   }  return returnValue;
  }

进入getMethodArgumentValues方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private Object[] getMethodArgumentValues(
   NativeWebRequest request, ModelAndViewContainer mavContainer,  Object... providedArgs) throws Exception {
   //获取方法参数数组
  MethodParameter[] parameters = getMethodParameters();
  //创建一个参数数组，保存从request解析出的方法参数
  Object[] args = new Object[parameters.length]; for ( int i = 0 ; i < parameters.length; i++) {
   MethodParameter parameter = parameters[i];
   parameter.initParameterNameDiscovery(parameterNameDiscoverer);
   GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
 
   args[i] = resolveProvidedArgument(parameter, providedArgs);  if (args[i] != null ) {   continue ;
   } 
   //判断之前RequestMappingHandlerAdapter初始化的那24个HandlerMethodArgumentResolver（参数解析器），是否存在支持该参数解析的解析器
   if (argumentResolvers.supportsParameter(parameter)) {   try {
     args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);    continue ;
    } catch (Exception ex) {    if (logger.isTraceEnabled()) {
      logger.trace(getArgumentResolutionErrorMessage( "Error resolving argument" , i), ex);
     }    throw ex;
    }
   }  if (args[i] == null ) {   String msg = getArgumentResolutionErrorMessage( "No suitable resolver for argument" , i);   throw new IllegalStateException(msg);
   }
  } return args;
}

进入HandlerMethodArgumentResolverComposite的resolveArgument方法 。

?
1
2
3
4
5
6
7
8
9
10
public Object resolveArgument(
    MethodParameter parameter, ModelAndViewContainer mavContainer,
    NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
    throws Exception { 
    //首先获取参数解析器，这里获取的逻辑是首先从argumentResolverCache缓存中获取该MethodParameter匹配的HandlerMethodArgumentResolver。如果为空，遍历初始化定义的那24个。查找匹配的HandlerMethodArgumentResolver，然后添加至argumentResolverCache缓存中
   HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
   Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]" ); 
   //解析参数
   return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
  }

再进入HandlerMethodArgumentResolver的resolverArgument方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public final Object resolveArgument(
    MethodParameter parameter, ModelAndViewContainer mavContainer,
    NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
    throws Exception { 
    //获取int的Class对象
   Class<?> paramType = parameter.getParameterType(); 
   //根据参数定义创建一个NamedValueInfo对象
   NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);  //根据参数名解析出对象的值
   Object arg = resolveName(namedValueInfo.name, parameter, webRequest);  if (arg == null ) {   if (namedValueInfo.defaultValue != null ) {
     arg = resolveDefaultValue(namedValueInfo.defaultValue);
    }   else if (namedValueInfo.required) {
     handleMissingValue(namedValueInfo.name, parameter);
    }
    arg = handleNullValue(namedValueInfo.name, arg, paramType);
   }  else if ( "" .equals(arg) && (namedValueInfo.defaultValue != null )) {
    arg = resolveDefaultValue(namedValueInfo.defaultValue);
   } 
   //上面步骤获取的args是String类型，然后转换为方法参数所需要的类型(int)
   if (binderFactory != null ) {
    WebDataBinder binder = binderFactory.createBinder(webRequest, null , namedValueInfo.name);
    arg = binder.convertIfNecessary(arg, paramType, parameter);
   }
 
   handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest); 
   return arg;
  }

这个方法的职责是根据parameter对象创建一个NamedValueInfo对象。这个对象存放的就是参数名、是否必须、参数默认值3个成员变量。然后进入resolverName方法解析参数，最后返回 。

2. 对象参数绑定

对象参数解析绑定会交给ServletModelAttributeMethodProcessor这个类进行解析，进入supportsParameter方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
*带有@ModelAttribute注解返回true
* parameter不是简单类型也返回true.
*/
public boolean supportsParameter(MethodParameter parameter) {
  if (parameter.hasParameterAnnotation(ModelAttribute. class )) { 
   return true ;
  } else if ( this .annotationNotRequired) {  
   return !BeanUtils.isSimpleProperty(parameter.getParameterType());
  } else {  
   return false ;
  }
}

进入ServletModelAttributeMethodProcessor的resolveArgument方法。它的resolveArgument是由父类ModelAttributeMethodProcessor具体实现的 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
* 解析model中的参数，如果从ModelAndViewContainer未找到，直接通过反射实例化一个对象。具体实例化是通过父类的createAttribute方法，通过调用BeanUtils.instantiateClass方法来实例化的。这个对象便是后续传给test2(User u)方法的对象，但是此时创建的对象里面的值都还为空，注入值是通过bindRequestParameters方法来实现的。
*/
public final Object resolveArgument(
  MethodParameter parameter, ModelAndViewContainer mavContainer,
    NativeWebRequest request, WebDataBinderFactory binderFactory)
   throws Exception { 
  String name = ModelFactory.getNameForParameter(parameter);  Object attribute = (mavContainer.containsAttribute(name)) ?
  mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);
  WebDataBinder binder = binderFactory.createBinder(request, attribute, name); 
  if (binder.getTarget() != null ) {  
  //将请求绑定至目标binder的target对象，也就是刚刚创建的attribute对象。
  bindRequestParameters(binder, request);  
  //如果有验证，则验证参数
  validateIfApplicable(binder, parameter);  
  if (binder.getBindingResult().hasErrors()) {   
   if (isBindExceptionRequired(binder, parameter)) {  
    throw new BindException(binder.getBindingResult());
     }
    }
   } 
   // Add resolved attribute and BindingResult at the end of the model
 
   Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
   mavContainer.removeAttributes(bindingResultModel);
   mavContainer.addAllAttributes(bindingResultModel); 
   return binder.getTarget();
  }
  1. 该方法根据request和attribute、name创建一个WebDataBinder对象，其中。然后进入bindRequestParameters方法绑定，根据reqeust中的参数创建一个MutablePropertyValues对象。MutablePropertyValues里面存放了一个或多个PropertyValue，其中PropertyValue用于保存,单个bean属性的相关信息，比如参数名、参数值。这里需要注意的是PropertyValue并不是保存request对象的所有参数属性信息。而是一个参数属性对应一个PropertyValue。比如这里的reqeust对象，携带了两个参数，name和age，便会分别创建两个PropertyValue对象。
  2. 创建MutablePropertyValues对象化后，进入DataBinder.applyPropertyValues(DataBinder.java line737)。会根据刚刚创建的User对象。创建一个BeanWrapperImpl对象，BeanWrapperImpl实现了PropertyAccessor（属性访问器）接口。这是spring-bean下的一个类，在Sping中，对Bean属性的存取都是通过BeanWrapperImpl类来实现的。BeanWarapperImpl在这里作用就是通过PropertyValue中的属性相关描述，注入到BeanWarapperImpl对应的java对象的属性中去。具体注入的方法是setPropertyValues，这个方法略复杂。它的职责简单总结起来就是根据属性名调用对应的set...方法。比如注入User对象的name属性时，通过反射获取setName方法。如果有该方法便调用。这也是为什么在定义SpringMVC model 对象需要set...方法。

3. 参数绑定解析总结

  1. SpringMVC初始化时，RequestMappingHandlerAdapter类会把一些默认的参数解析器添加到argumentResolvers中。当SpringMVC接收到请求后首先根据url查找对应的HandlerMethod。
  2. 遍历HandlerMethod的MethodParameter数组
  3. 根据MethodParameter的类型来查找确认使用哪个HandlerMethodArgumentResolver，遍历所有的argumentResolvers的supportsParameter(MethodParameter parameter)方法。。如果返回true，则表示查找成功，当前MethodParameter，使用该HandlerMethodArgumentResolver。这里确认大多都是根据参数的注解已经参数的Type来确认。
  4. 解析参数，从request中解析出MethodParameter对应的参数，这里解析出来的结果都是String类型。
  5. 转换参数，把对应String转换成具体方法所需要的类型，这里就包括了基本类型、对象、List、Set、Map。

以上就是SpringMVC 参数绑定相关知识总结的详细内容，更多关于SpringMVC 参数绑定的资料请关注我其它相关文章！ 。

原文链接：https://segmentfault.com/a/1190000039411057 。

最后此篇关于SpringMVC 参数绑定相关知识总结的文章就讲到这里了,如果你想了解更多关于SpringMVC 参数绑定相关知识总结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： Python实现定时执行任务的三种方式简单示例
文章推荐： OpenCV-Python实现多模板匹配
文章推荐： 详解Python解决抓取内容乱码问题（decode和encode解码）
文章推荐： OpenCV-Python使用分水岭算法实现图像的分割与提取
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com