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” 的值拿到的。
小结
一切都在代码里。只要找到了入口,知道了套路,学会单步调试,类似问题解决起来就相对容易了。