SpringBoot系列（一）请求参数解析

SpringBoot系列（一）请求参数解析

前言

​ 对于平时我们工作中经常使用,类似于@Requestparam、@Pathvariable等这些注解，SpringBoot底层到底是如何解析这些参数的,下面我们一起来探究一下参数解析的底层原理。

一、测试程序

首先我们先给出一个测试demo,然后再一起探究其原理:

controller:

@RestController
@Slf4j
public class ParamsAnnotationController {
    @GetMapping(value = "/user")
    public Map<String , String> requestParamTest(
      																		 @RequestParam(value = "id")String id,
                                           @RequestParam(value = "userName")String userName,
                                           @RequestParam Map<String , String> map
    																			){
        log.info("id:" + id);
        log.info("userName:" + userName);
        log.info("map:" + map);
        return map;
    }
}

使用postman进行测试:

二、原理分析

对于任何的服务端请求,都要从DispatcherServlet开始入手,首先我们看一下DispatchServlet调用栈:

1. DispatchServelt依赖树

【注】:虚线表示实现，实线表示继承

由此我们可以看出,我们来寻找处理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;

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

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

3. 接下来来一起探究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);
		}
		}
	

3. 下面分析步骤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;
	}

4. 针对于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;
	}