SpringBoot之请求参数解析

淩亂°似流年 2022-10-07 15:50 169阅读 0赞

# 一：SpringBoot之请求参数解析 #

1.  前言  
     对于平时我们工作中经常使用类似于@Requestparam等这些注解，SpringBoot底层到底是如何解析这些参数的,下面我们一起来探究一下参数解析的底层原理。
2.  测试程序  
    首先我们先给出一个测试demo,然后再一起探究其原理:

paramController实体类：

package com.example.springbootparam.controller;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /** * @author lizhangyu * @date 2021/6/19 13:56 */
    @RestController
    public class paramController { 
    
        private static final Logger log = LoggerFactory.getLogger(paramController.class);
    
        @GetMapping("/user")
        public void paramTest(@RequestParam(value = "id") String id,
                              @RequestParam(value = "userName") String userName) { 
            log.info("id:" + id);
            log.info("userName:" + userName);
        }
    }

使用postman进行测试:

![postman测试][postman]

1.  原理分析  
    对于任何的服务端请求,都要从DispatcherServlet开始入手,首先我们看一下DispatchServlet调用栈:  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 1]  
    从这里可以看到整个的调用过程其实是先在唤醒一个线程，然后让线程处于可运行状态，然后通过invoke方法执行一些环境运行需要的准备，然后通过一系列的过滤器进行过滤，然后通过DispatchServelt进行处理，在通过拦截器进行做一些拦截，最后才真正的找到对应的方法去执行对应的业务逻辑。

DispatchServelt依赖树  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 2]  
【注】:虚线表示实现，实线表示继承

由此我们可以看出,我们来寻找处理http请求的doGet()、doPost()方法，我们在FrameworkServlet中找到了doGet()方法，如下：

@Override
    	protected final void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException { 
    		//执行request方法
    		processRequest(request, response);
    	}
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException { 
    
    		try { 
          //关键步骤
    			doService(request, response);
    		}catch (ServletException | IOException ex) { 
    			failureCause = ex;
    			throw ex;
    	}
    	
      //抽象方法，在DispatcherServlet方法中进行实现
       protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
    			throws Exception;

由步骤1我们可以看到我们接下来寻找DispatcherServlet中重写的doService()方法就可以了，如下：

@Override
    	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { 
    		try { 
    			doDispatch(request, response);
        }
    	}

接下来来一起探究doDisatcher()，源码如下：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { 
    		HttpServletRequest processedRequest = request;
    		HandlerExecutionChain mappedHandler = null;
    		boolean multipartRequestParsed = false;
    
    		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    
    		try { 
    			ModelAndView mv = null;
    			Exception dispatchException = null;
    
    			try { 
    				processedRequest = checkMultipart(request);
    				multipartRequestParsed = (processedRequest != request);
    
    				// 关键点1⃣️：获取能够处理此请求的HandlerExcutionChain
    				mappedHandler = getHandler(processedRequest);
    				if (mappedHandler == null) { 
    					noHandlerFound(processedRequest, response);
    					return;
    				}
    
    				// 关键点2⃣️：获取处理器适配器：@RequestMappingHandlerAdapter
    				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
    				// Process last-modified header, if supported by the handler.
    				String method = request.getMethod();
    				boolean isGet = HttpMethod.GET.matches(method);
    				if (isGet || HttpMethod.HEAD.matches(method)) { 
    					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
    					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) { 
    						return;
    					}
    				}
    
    				if (!mappedHandler.applyPreHandle(processedRequest, response)) { 
    					return;
    				}
    
    				// 关键点3⃣️：执行目标方法
    				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
    				if (asyncManager.isConcurrentHandlingStarted()) { 
    					return;
    				}
    
    				applyDefaultViewName(processedRequest, mv);
    				mappedHandler.applyPostHandle(processedRequest, response, mv);
    			}
    			
    			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    		}
    		}

下面分析步骤2中的关键点3⃣️，如下：  
我们跟随方法的调用栈找到了ServletInvocableHandlerMethod中的invokeAndHandle(),如下：

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception { 
    
        //解析请求参数，获取返回值
    		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    		setResponseStatus(webRequest);
    	}
    
    	@Nullable
    	public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs) throws Exception { 
        //获取参数的值
    		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Arguments: " + Arrays.toString(args));
    		}
        //通过反射工具类执行目标方法
    		return doInvoke(args);
    	}

getMethodArgumentValues():此方法包含了参数解析的核心逻辑

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception { 
    		//1⃣️首先封装一个MethodParameter数组，将请求参数的相关信息封装到MethodParameter[]方法
    		MethodParameter[] parameters = getMethodParameters();
    		if (ObjectUtils.isEmpty(parameters)) { 
    			return EMPTY_ARGS;
    		}
    
    		  
    		Object[] args = new Object[parameters.length];
    		for (int i = 0; i < parameters.length; i++) { 
    			MethodParameter parameter = parameters[i];
    			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
    			args[i] = findProvidedArgument(parameter, providedArgs);
    			if (args[i] != null) { 
    				continue;
    			}
          //2⃣️判断27个参数解析器是否支持此参数类型,挨个进行循环，如果找到此参数解析器，则进行解析并返回true
    			if (!this.resolvers.supportsParameter(parameter)) { 
    				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
    			}
    			try { 
            //3⃣️解析参数的值，放到数组中
    				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
    			}
    			catch (Exception ex) { 
    				// Leave stack trace for later, exception may actually be resolved and handled...
    				if (logger.isDebugEnabled()) { 
    					String exMsg = ex.getMessage();
    					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) { 
    						logger.debug(formatArgumentError(parameter, exMsg));
    					}
    				}
    				throw ex;
    			}
    		}
    		return args;
    	}

针对于3中的要点2⃣️我们贴出源码，如下：

@Override
    	public boolean supportsParameter(MethodParameter parameter) { 
    		return getArgumentResolver(parameter) != null;
    	}
    
    //获取方法参数解析器，
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) { 	
      HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    		if (result == null) { 
          //this.argumentResolvers有27个值，见下图
    			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) { 
    				if (resolver.supportsParameter(parameter)) { 
    					result = resolver;
              //获取一次参数解析器后会放到缓存中，以便下次直接从缓存中获取
    					this.argumentResolverCache.put(parameter, result);
    					break;
    				}
    			}
    		}
    		return result;
    	}

针对于步骤3中的要点3⃣️,我们来分析一下解析参数的核心步骤：

public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
    			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception { 
    
    		NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    		MethodParameter nestedParameter = parameter.nestedIfOptional();
    		//获取参数的名称，如id
    		Object resolvedName = resolveEmbeddedValuesAndExpressions(namedValueInfo.name);
    		if (resolvedName == null) { 
    			throw new IllegalArgumentException(
    					"Specified name must not resolve to null: [" + namedValueInfo.name + "]");
    		}
    		//解析id对应的值，如1
    		Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    		if (arg == null) { 
    			if (namedValueInfo.defaultValue != null) { 
    				arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
    			}
          //如果参数是必须传递的并且没有传，则客户端请求400
    			else if (namedValueInfo.required && !nestedParameter.isOptional()) { 
    				handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
    			}
    			arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
    		}
    		else if ("".equals(arg) && namedValueInfo.defaultValue != null) { 
    			arg = resolveEmbeddedValuesAndExpressions(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());
    			}
    			// Check for null value after conversion of incoming argument value
    			if (arg == null && namedValueInfo.defaultValue == null &&
    					namedValueInfo.required && !nestedParameter.isOptional()) { 
    				handleMissingValueAfterConversion(namedValueInfo.name, nestedParameter, webRequest);
    			}
    		}
    
    		handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
    
    		return arg;
    	}

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 3]

[postman]: /images/20221005/5a9536cca4554612b546378ef7c1d48d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70]: /images/20221005/b7293162b2954b878e761b6c4549689a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 1]: /images/20221005/c7f72d25b868427cae27db50f819ac49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 2]: /images/20221005/0271cd5a26474a78b7a3336110dd5925.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NDY5MDU1_size_16_color_FFFFFF_t_70 3]: /images/20221005/4d926981a9a54eee922112a183bb1963.png