• SpringMVC源码-不同类型的参数解析

            随便写一个demo:

    1.     @RequestMapping("/car/{id}")
    2.     public Map getCar(@PathVariable("id") Integer id,
    3.                                       @RequestParam("type") String type,
    4.                                       @RequestParam("hobby") List hobby){
    5.         Map map = new HashMap<>();
    6.         map.put("id",id);
    7.         map.put("type",type);
    8.         map.put("hobby", hobby);
    9.         return map;
    10.     }

            之前说过通过获取到的mapperHandler中以及找到了控制器以及具体的方法，接下来就需要来处理方法中的各种类型的参数，也就是需要用的SpringMVC中提供的HandlerAdapter。

     一、HandlerAdapter

            

             该接口主要就两个方法，一个supports用来判断是否支持这类适配器，如果支持就进行处理（handle方法）。

              SpringMVC给我们创建了四种Adapter ：      

            0—针对含有RequestMapping注解的处理器

            ......

    1.1 RequestMappingHandlerAdapter

             获取到第一个适配器RequestMappingHandlerAdapter，调用其supports方法，判断是否支持请求。

            supports()

             最后就获取到了适合当前请求的适配器了。

    1.2 执行获取到的适配器

            

             在上一步中获取到的适配器在这里进行处理。

             在该方法内部会唤醒控制器的方法

             可以看到无论是否满足if条件，都会执行invokeHandlerMethod这个方法

    1.  @Nullable
    2.     protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    3.         ServletWebRequest webRequest = new ServletWebRequest(request, response);
    4.  
    5.         ModelAndView var15;
    6.         try {
    7.             WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
    8.             ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
    9.             ServletInvocableHandlerMethod invocableMethod = this.createInvocableHandlerMethod(handlerMethod);
    10.             if (this.argumentResolvers != null) {
    11.                 invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    12.             }
    13.  
    14.             if (this.returnValueHandlers != null) {
    15.                 invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    16.             }
    17.  
    18.             invocableMethod.setDataBinderFactory(binderFactory);
    19.             invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    20.             ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    21.             mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
    22.             modelFactory.initModel(webRequest, mavContainer, invocableMethod);
    23.             mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
    24.             AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
    25.             asyncWebRequest.setTimeout(this.asyncRequestTimeout);
    26.             WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    27.             asyncManager.setTaskExecutor(this.taskExecutor);
    28.             asyncManager.setAsyncWebRequest(asyncWebRequest);
    29.             asyncManager.registerCallableInterceptors(this.callableInterceptors);
    30.             asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
    31.             Object result;
    32.             if (asyncManager.hasConcurrentResult()) {
    33.                 result = asyncManager.getConcurrentResult();
    34.                 mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
    35.                 asyncManager.clearConcurrentResult();
    36.                 LogFormatUtils.traceDebug(this.logger, (traceOn) -> {
    37.                     String formatted = LogFormatUtils.formatValue(result, !traceOn);
    38.                     return "Resume with async result [" + formatted + "]";
    39.                 });
    40.                 invocableMethod = invocableMethod.wrapConcurrentResult(result);
    41.             }
    42.  
    43.             invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
    44.             if (asyncManager.isConcurrentHandlingStarted()) {
    45.                 result = null;
    46.                 return (ModelAndView)result;
    47.             }
    48.  
    49.             var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
    50.         } finally {
    51.             webRequest.requestCompleted();
    52.         }
    53.  
    54.         return var15;
    55.     }

            在这个方法内部，注意到：

             argumentResolvers参数解析器（SpringMVC提供的）。

             里面共有27个参数解析器，每一个参数和其注解都会进行一一匹配。

            和上面的HandlerAdapter一样的结构，先判断然后去执行。

            准备工作完成之后开始给参数赋值，具体的赋值过程如下：

    1.     public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    2.         Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
    3.         this.setResponseStatus(webRequest);
    4.         if (returnValue == null) {
    5.             if (this.isRequestNotModified(webRequest) || this.getResponseStatus() != null || mavContainer.isRequestHandled()) {
    6.                 this.disableContentCachingIfNecessary(webRequest);
    7.                 mavContainer.setRequestHandled(true);
    8.                 return;
    9.             }
    10.         } else if (StringUtils.hasText(this.getResponseStatusReason())) {
    11.             mavContainer.setRequestHandled(true);
    12.             return;
    13.         }
    14.  
    15.         mavContainer.setRequestHandled(false);
    16.         Assert.state(this.returnValueHandlers != null, "No return value handlers");
    17.  
    18.         try {
    19.             this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
    20.         } catch (Exception var6) {
    21.             if (logger.isTraceEnabled()) {
    22.                 logger.trace(this.formatErrorForReturnValue(returnValue), var6);
    23.             }
    24.  
    25.             throw var6;
    26.         }
    27.     }

             其中这一步是真正的执行目标方法，里面有doInvoke方法，利用反射执行控制器的方法

             执行完之后获取到了请求方法中的参数并且也都赋值了。

            所以看看invokeForRequest方法内部是如何获取参数并赋值的

    1.3 获取方法中的参数并赋值

    1.     @Nullable
    2.     public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    3.         Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
    4.         if (logger.isTraceEnabled()) {
    5.             logger.trace("Arguments: " + Arrays.toString(args));
    6.         }
    7.  
    8.         return this.doInvoke(args);
    9.     }

            该方法内部调用了getMethodArgumentValues方法，说明是通过这个方法来获取参数值的：

    1. protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    2.         MethodParameter[] parameters = this.getMethodParameters();
    3.         if (ObjectUtils.isEmpty(parameters)) {
    4.             return EMPTY_ARGS;
    5.         } else {
    6.             Object[] args = new Object[parameters.length];
    7.  
    8.             for(int i = 0; i < parameters.length; ++i) {
    9.                 MethodParameter parameter = parameters[i];
    10.                 parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
    11.                 args[i] = findProvidedArgument(parameter, providedArgs);
    12.                 if (args[i] == null) {
    13.                     if (!this.resolvers.supportsParameter(parameter)) {
    14.                         throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
    15.                     }
    16.  
    17.                     try {
    18.                         args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
    19.                     } catch (Exception var10) {
    20.                         if (logger.isDebugEnabled()) {
    21.                             String exMsg = var10.getMessage();
    22.                             if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
    23.                                 logger.debug(formatArgumentError(parameter, exMsg));
    24.                             }
    25.                         }
    26.  
    27.                         throw var10;
    28.                     }
    29.                 }
    30.             }
    31.  
    32.             return args;
    33.         }
    34.     }

            第一步获取到的parameters

    内部的基本过程就是：在获取到的parameters集合中的参数一个一个进行迭代然后选择合适的解析器，并且根据url中的路径来进行赋值，即可！

    第二类：自定义对象参数

            简单Demo：

            HTML页面表单：

    1.     <form action="/getPerson" method="get">
    2.         姓名:<input name="userName" value="zhangsan"><br/>
    3.         年龄：<input name="age" value="25"><br/>
    4.         宠物名：<input name="pet.name" value="dahua"><br/>
    5.         宠物年龄<input name="pet.age" value="2"><br/>
    6.         <input type="submit" value="保存">
    7.     </form>

            Controller：

    1.     @RequestMapping("/getPerson")
    2.     public Person getPerson(Person person){
    3.         return person;
    4.     }

            结果：

             现在问题是如何将表单中提交的数据封装成了一个Person对象的？

            再一次说到getMethodArgumentValues中

    1. protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
    2.        ......
    3.  
    4.                     try {
    5.                         args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
    6.                     } 
    7.  
    8.        ......
    9.     }

            这里的大概逻辑就是 先是获取到了控制器方法中的参数，初步判断是否为空（没赋值的时候肯定为空），然后再try里头有这个方法

             也就是一个一个给参数赋值的过程。最终到达参数赋值的方法体中：

    1.     @Nullable
    2.     public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
    3.         Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    4.         Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");
    5.         String name = ModelFactory.getNameForParameter(parameter);
    6.         ModelAttribute ann = (ModelAttribute)parameter.getParameterAnnotation(ModelAttribute.class);
    7.         if (ann != null) {
    8.             mavContainer.setBinding(name, ann.binding());
    9.         }
    10.  
    11.         Object attribute = null;
    12.         BindingResult bindingResult = null;
    13.         if (mavContainer.containsAttribute(name)) {
    14.             attribute = mavContainer.getModel().get(name);
    15.         } else {
    16.             try {
    17.                 attribute = this.createAttribute(name, parameter, binderFactory, webRequest);
    18.             } catch (BindException var10) {
    19.                 if (this.isBindExceptionRequired(parameter)) {
    20.                     throw var10;
    21.                 }
    22.  
    23.                 if (parameter.getParameterType() == Optional.class) {
    24.                     attribute = Optional.empty();
    25.                 } else {
    26.                     attribute = var10.getTarget();
    27.                 }
    28.  
    29.                 bindingResult = var10.getBindingResult();
    30.             }
    31.         }
    32.  
    33.         if (bindingResult == null) {
    34.             WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
    35.             if (binder.getTarget() != null) {
    36.                 if (!mavContainer.isBindingDisabled(name)) {
    37.                     this.bindRequestParameters(binder, webRequest);
    38.                 }
    39.  
    40.                 this.validateIfApplicable(binder, parameter);
    41.                 if (binder.getBindingResult().hasErrors() && this.isBindExceptionRequired(binder, parameter)) {
    42.                     throw new BindException(binder.getBindingResult());
    43.                 }
    44.             }
    45.  
    46.             if (!parameter.getParameterType().isInstance(attribute)) {
    47.                 attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
    48.             }
    49.  
    50.             bindingResult = binder.getBindingResult();
    51.         }
    52.  
    53.         Map<String, Object> bindingResultModel = bindingResult.getModel();
    54.         mavContainer.removeAttributes(bindingResultModel);
    55.         mavContainer.addAllAttributes(bindingResultModel);
    56.         return attribute;
    57.     }

             在这里利用反射创建了一个对象，此例就是Person对象

            之后通过 WebDataBinder 绑定器来给attribute赋值。

           

     binder中的target属性就是刚刚创建的attribute

            然后再conversionService业务中有一个converts

             有124个转换器。

            因为HTML 中的 参数值都会作为文本传递过来，也就是String类型的，Person对象中的属性age是Integer类型的，所以就将age的文本值转换为Integer类型即可赋值。

            具体转换方法是在这里：

             就暂时不进行深究了。

    最后需要注意的是赋值的过程就是调用 对象属性中的set方法，所以再html表单中的 name 要和属性中的set方法名后的值相同，应该是称为属性或者是字段值？否则无法将值赋给参数。

            

    这里增加了个性别，表单中属性名为SEX，bean对象中属性名为sex。

    发送请求后无法赋值：

    所以，表单中的属性值一定要和字段值相同！

  • 相关阅读:
    利用pytorch自定义CNN网络（四）：损失函数和优化器
    Unity3D 多人战场Animation优化详解
    倍福--两台TwinCAT3之间做Ethernet IP通信
    SQL语法之AND & OR 运算符
    Matlab自学笔记二十三：字符串的提取、替换、插入和删除
    韦东山linux驱动开发学习【常更】
    LeetCode561. 数组拆分
    尚硅谷Flink（四）处理函数
    获取图片信息
    IAB视频广告标准《数字视频和有线电视广告格式指南》之 概述- IAB受众和技术标准 - 我为什么要翻译介绍美国人工智能科技公司IAB系列（2）
  • 原文地址：https://blog.csdn.net/weixin_42196338/article/details/127842877