SpringMVC-嵌套对象传参及原理解析

引子

在涉及前后端交互的 Java 应用中,SpringMVC 可以说是很流行的一种框架。那么在 SpringMVC 中,如何将较复杂的嵌套对象从前端传给后端呢?可以使用注解 @RequestBody 。 @RequestBody 的实现原理是:根据指定的前端传参类型及 Media Type 来选择适当的 HttpMessageConverter 来进行参数转换。

传参

后端接收:

@RequestMapping(value = "/save")
@ResponseBody
public BaseResult save(@RequestBody BookInfo bookInfo) {
    Assert.notNull(bookInfo, "商品对象不能为空");
    Assert.notNull(bookInfo.getGoods().getGoodsId(), "商品ID不能为空");

    complete(bookInfo);
    boolean isSaved = goodsSnapshotService.save(bookInfo);
    BookSaveResponse bookSaveResponse = new BookSaveResponse(bookInfo.getOrder().getOrderNo(), bookInfo.getGoods().getGoodsId());
    return isSaved ? BaseResult.succ(bookSaveResponse): BaseResult.failed(Errors.BookError);
}

public class BookInfo {

    /** 下单的商品信息 */
    private GoodsInfo goods;

    /** 下单的订单信息 */
    private Order order;
}

public class GoodsInfo {

    /** 商品ID */
    private Long goodsId;

    /** 店铺ID */
    private Long shopId;

    /** 商品标题 */
    private String title;

    /** 商品描述 */
    private String desc;

    /** 商品服务 keys */
    private String serviceKeys;

    /** 商品规格选择 */
    private String choice;

    /** 商品关联的订单号 */
    private String orderNo;
}

public class Order {

    /** 订单号 */
    private String orderNo;

    /** 店铺ID */
    private Long shopId;

    /** 下单时间 */
    private Long bookTime;

    /** 下单人ID */
    private Long userId;

    /** 是否货到付款 */
    private Boolean isCodPay;

    /** 是否担保交易 */
    private Boolean isSecuredOrder;

    /** 是否有线下门店 */
    private Boolean hasRetailShop;

    /** 配送方式 0 快递 1 自提 2 同城送 */
    private DeliveryType deliveryType;

    /** 订单金额, 分为单位 */
    private Long price;

    /** 快递配送金额 */
    private Long expressFee;

    /** 同城配送起送金额 */
    private Long localDeliveryBasePrice;

    /** 同城配送金额 */
    private Long localDeliveryPrice;

    /** 订单的服务 keys */
    private List<String> keys;
}

前端传参:


    var bookInfo = {
       'goods': {
            'shopId': shopId,
            'goodsId': goodsId,
            'price': priceNum,
            'title': title,
            'desc': desc,
            'serviceKeys' : serviceKeys,
            'choice': choice
        },
        'order': {
            'shopId': shopId,
            'userId': userId,
            'deliveryType': deliveryType,
            'price': priceNum,
            'isCodPay' : isCodPay,
        }
    };

    var jqXHR = jQuery.ajax({
        dataType: "json",
        contentType: "application/json; charset=utf-8",
        url: 'http://localhost:8080/api/goodsnapshot/save',
        data: JSON.stringify(bookInfo),
        timeout: 90000,
        type: 'POST'
    });


原理

@RequestBody 的作用就是做参数校验和参数转换,将前端的 JSON 字符串转换成后端给定的 Java 对象。那么,它的参数转换功能是如何实现的呢? 要回答这个问题,就要找到这个注解的实现类。

找到入口方法

可以在 IDEA 搜索类 RequestBody,得到与之相关的几个类如下图所示:

在可能实现类的 public 方法入口打上断点,然后单步调试。可以找到入口方法是 RequestResponseBodyMethodProcessor.resolveArgument 。这个方法进一步调用了方法 AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters , 该方法会拿到若干个 HttpMessageConverter 的实现类(如下图所示),判断其中是否有可以处理请求对象 InputMessage 的类。只要任一能处理即可。

AbstractMessageConverterMethodArgumentResolver.java


        Object inputMessage;
        try {
            inputMessage = new AbstractMessageConverterMethodArgumentResolver.EmptyBodyCheckingHttpInputMessage(inputMessage);
            Iterator var10 = this.messageConverters.iterator();

            while(var10.hasNext()) {
                HttpMessageConverter<?> converter = (HttpMessageConverter)var10.next();
                Class<HttpMessageConverter<?>> converterType = converter.getClass();
                if (converter instanceof GenericHttpMessageConverter) {
                    GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter)converter;
                    if (genericConverter.canRead(targetType, contextClass, contentType)) {
                        if (this.logger.isDebugEnabled()) {
                            this.logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                        }

                        if (((HttpInputMessage)inputMessage).getBody() != null) {     // HttpMessageConverter 进行参数转换时有切面
                            inputMessage = this.getAdvice().beforeBodyRead((HttpInputMessage)inputMessage, parameter, targetType, converterType);
                            body = genericConverter.read(targetType, contextClass, (HttpInputMessage)inputMessage);
                            body = this.getAdvice().afterBodyRead(body, (HttpInputMessage)inputMessage, parameter, targetType, converterType);
                        } else {
                            body = this.getAdvice().handleEmptyBody((Object)null, (HttpInputMessage)inputMessage, parameter, targetType, converterType);
                        }
                        break;
                    }
                } else if (targetClass != null && converter.canRead(targetClass, contentType)) {
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    }

                    if (((HttpInputMessage)inputMessage).getBody() != null) {   // HttpMessageConverter 进行参数转换时有切面
                        inputMessage = this.getAdvice().beforeBodyRead((HttpInputMessage)inputMessage, parameter, targetType, converterType);  
                        body = converter.read(targetClass, (HttpInputMessage)inputMessage);
                        body = this.getAdvice().afterBodyRead(body, (HttpInputMessage)inputMessage, parameter, targetType, converterType);
                    } else {
                        body = this.getAdvice().handleEmptyBody((Object)null, (HttpInputMessage)inputMessage, parameter, targetType, converterType);
                    }
                    break;
                }
            }


找到参数转换类

如何判断 HttpMessageConverter 是否能够处理 InputMessage 呢?要满足两个基本条件:

  • 能够处理请求参数类,比如,这里是 BookInfo ;
  • 要能处理给定的 Content-type ,比如,这里是 JSON , UTF-8。

AbstractHttpMessageConverter.java


    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return this.supports(clazz) && this.canRead(mediaType);
    }

    protected boolean canRead(MediaType mediaType) {
        if (mediaType == null) {
            return true;
        } else {
            Iterator var2 = this.getSupportedMediaTypes().iterator();

            MediaType supportedMediaType;
            do {
                if (!var2.hasNext()) {
                    return false;
                }

                supportedMediaType = (MediaType)var2.next();
            } while(!supportedMediaType.includes(mediaType));

            return true;
        }
    }

可以逐一查看上述截图中的 HttpMessageConverter 实现类(支持的 Media Type 如截图所示):

  • ByteArrayHttpMessageConverter: 支持字节数组的处理;
  • StringHttpMessageConverter: 支持字符串的处理;
  • ResourceHttpMessageConverter: 支持 Resource 类型的处理;
  • SourceHttpMessageConverter: 支持 DOMSource, SAXSource, StAXSource, StreamSource, Source 类型;
  • AllEncompassingFormHttpMessageConverter: 支持表单的处理;
  • MappingJackson2HttpMessageConverter: 支持 JSON 字符串的处理;
  • Jaxb2RootElementHttpMessageConverter:参数类带有 XmlRootElement 或 XmlType 。

最终发现,能够处理 JSON 字符串及 JSON media 的是类 MappingJackson2HttpMessageConverter 。 注意到,在这个类处理 InputMessage 的时候,还有一个切面。这个切面的实现类是 RequestResponseBodyAdviceChain ,里面应用了责任链设计模式来处理请求 InputMessage。对应于 @RequestBody 的切面类是 JsonViewRequestBodyAdvice, 仅在参数上有 @JsonView 注解时才处理。

向前追溯

为什么入口类是 RequestResponseBodyMethodProcessor 呢?可以看看方法 RequestResponseBodyMethodProcessor.resolveArgument 的调用者。进一步追溯可知:

  • Spring 应用里的参数类(比如 BookInfo)对应于 Spring 框架里的 MethodParam ;

  • 在类 HandlerMethodArgumentResolverComposite (应用了组合设计模式)里面含有一个参数解析映射缓存 Map[MethodParam, HandlerMethodArgumentResolver] argumentResolverCache,可以根据指定的 MethodParam 拿到对应的 HandlerMethodArgumentResolver 实现类,即 RequestResponseBodyMethodProcessor。

argumentResolverCache 的内容是获取参数解析类的时候动态添加进去的,它依赖于一个实例成员 List[HandlerMethodArgumentResolver] argumentResolvers ,而 argumentResolvers 是在方法 RequestMappingHandlerAdapter.getDefaultArgumentResolvers 里添加的,该方法在类 RequestMappingHandlerAdapter 初始化完成后调用。

HandlerMethodArgumentResolverComposite.java


         private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
			for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
				if (logger.isTraceEnabled()) {
					logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
							parameter.getGenericParameterType() + "]");
				}
				if (methodArgumentResolver.supportsParameter(parameter)) {
					result = methodArgumentResolver;
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
       	}

看来,参数类解析相关的初始化的奥秘在类 RequestMappingHandlerAdapter 里。

RequestMappingHandlerAdapter.java


	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);
		}
		if (this.initBinderArgumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		if (this.returnValueHandlers == null) {
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
	}


请求的处理

类 RequestMappingHandlerAdapter 既然负责初始化,那很可能也负责请求处理。可以在 RequestMappingHandlerAdapter 的 public 方法打断点,然后发请求。果然,经过 RequestMappingHandlerAdapter.invokeHandlerMethod 方法。再查看方法 invokeHandlerMethod 的调用,一直向前追溯调用链,最终,可以找到源头处,即: DispatcherServlet.doService 方法。 好了,可以在这里打个断点,一步步跟踪,看看一路经过了哪些类,数据是怎样的,这样,就可以理解 MVC 的整个请求处理流程。


引申

不同的参数注解,就对应不同的参数解析类。 比如:

  • @RequestParam => RequestParamMethodArgumentResolver & RequestParamMapMethodArgumentResolver
  • @PathVariable => PathVariableMethodArgumentResolver

这些参数解析类,有两个主要方法:

  • supportsParameter : 支持解析怎样的参数形式;
  • resolveName : 具体地解析参数的实现。

RequestParamMethodArgumentResolver

RequestParamMethodArgumentResolver 适用的情况可以看它的 supportsParameter 方法:

  • @RequestPart MultipartFile
  • @RequestPart Part
  • @RequestParam + simple type

后台代码如下:


@RequestMapping(value = "/searchForSelect")
@ResponseBody
public Map<String, Object> searchForSelect(
    @RequestParam(value = "k", required = false) String title,
    @RequestParam(value = "page", defaultValue = "1") Integer page,
    @RequestParam(value = "rows", defaultValue = "10") Integer pageSize) {
    CreativeQuery query = buildCreativeQuery(title, page, pageSize);
    return searchForSelect2(query,
                            (q) -> creativeService.search(q),
                            (q) -> creativeService.count(q));
  }

发送请求: http://localhost:8080/api/creatives//searchForSelect?page=2&rows=20 ,就会使用类 RequestParamMethodArgumentResolver 来解析参数,得到 page = 2, pageSize = 20。这个值是怎么拿到的呢 ? 是从 request.coyoteRequest.parameters.paramHashValues 里面取到的。


RequestParamMapMethodArgumentResolver

RequestParamMapMethodArgumentResolver 的实现方式与 RequestParamMethodArgumentResolver 相同,也是从 request.coyoteRequest.parameters.paramHashValues 里面取到的。所不同的是,它修饰的参数类型是 Map 。 如下代码所示:


@RequestMapping(value = "/updateByMap")
@ResponseBody
public BaseResult updateByMap(@RequestParam  Map creative) {
    Assert.notNull(creative, "对象不能为空");
    Assert.notNull(creative.get("creativeId"), "创意ID不能为空");
    CreativeDO creativeObj = JSONObject.parseObject(JSONObject.toJSONString(creative), CreativeDO.class);
    creativeService.update(creativeObj);
    return BaseResult.succ("创意更新成功");
}

发送请求: http://localhost:8080/api/creatives//updateByMap?creativeId=2&content=newContent22&title=newtitle222 ,就会使用类 RequestParamMapMethodArgumentResolver 来解析参数,将 creative 设置为 Map["creativeId"=>2, "content"=>"newContent22", "title" => newtitle222] 。

PathVariableMethodArgumentResolver

适用于请求路径中含有可变参数的情形。比如 /get/{creativeId} 。 后台代码如下:


@RequestMapping(value = "/get/{creativeId}")
public String get(@PathVariable Long creativeId, ModelMap model) {
    Assert.notNull(creativeId, "请选择要查询的创意id");
    CreativeDO creativeObj = creativeService.get(creativeId);
    model.put("creative", creativeObj);
    return "/creative/detail";
}

发送请求:http://localhost:8080/api/creatives/get/1 ,使用类 PathVariableMethodArgumentResolver 来解析路径参数,得到请求参数 creativeId = 1 。这个 1 是怎么得到的呢 ? 是方法 PathVariableMethodArgumentResolver.resolveName 从 request.attributes 取出 key = “org.springframework.web.servlet.HandlerMapping.uriTemplateVariables” 的值拿到的。

小结

一切都在代码里。只要找到了入口,知道了套路,学会单步调试,类似问题解决起来就相对容易了。


posted @ 2020-12-26 15:50  琴水玉  阅读(3001)  评论(0编辑  收藏  举报