SpringMVC @RequestBody 为null问题的排查及解决

目录
  • SpringMVC @RequestBody为null
    • 关于inputsteam的一些理解
    • @RequestBody 自动映射原理的简单介绍
  • 关于@requestBody的一些说明
    • 1、@requestBody注解
    • 2、通过@requestBody
    • 3、在一些特殊情况

SpringMVC @RequestBody为null

今天写一个springmvc接口,希望入参为json,然后自动转成自己定义的封装对象,于是有了下面的代码

@PostMapping("/update")
@ApiOperation("更新用户信息")
public CumResponseBody update(@RequestBody UserInfoParam param) {
     int userId = getUserId();
     userService.updateUserInfo(userId, param);
     return ResponseFactory.createSuccessResponse("ok");
}
//UserInfoParam.java
public class UserInfoParam {
    private String tel;
    private String email;
    public String getTel() {
        return tel;
    }
    public void setTel(String tel) {
        this.tel = tel;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
}

程序正常启动后,使用swaggerUI发起测试

curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' -d '{ \
   "email": "12%40mail.com", \
   "tel": "13677682911" \
 }' 'http://127.0.0.1:9998/api/user/update'

最后程序报错

org.springframework.http.converter.HttpMessageNotReadableException: Required request body is missing: public com.pingguiyuan.shop.common.response.CumResponseBody com.pingguiyuan.shop.weixinapi.controller.UserController.update(com.pingguiyuan.shop.common.param.weixin.UserInfoParam)

对了几遍,接口的编写和请求内容都确定没有问题,但是请求的json就是没注入进来转成param对象。查了一圈资料也没找到满意的答案,就只能给springMVC的源码打断点跟一遍,看一下具体是哪里出了问题。

由于本篇不是介绍springMVC实现原理的,就不具体介绍springMVC的源码。

最后断点发现springMVC从request的inputstream没取出内容来(inputstream.read()出来的直接是-1)。由于有在一个拦截器输出请求的参数内容—>【当请求时get时,通过request.getParameterMap();获取参数,当请求时post时,则是直接输出request的inpustream里面的内容】。所以请求的body里面是肯定有内容的,也就是说request.getInputstream()的流是有内容的,那为什么到springMVC这read出来的就是-1呢。

稍微理了下思路,发现是自己给自己挖了个坑。答案是:request的inputstream只能读一次,博主在拦截器中把inputstream的内容都输出来了,到springMVC这,就没有内容可以读了。

关于inputsteam的一些理解

servlet request的inpustream是面向流的,这意味着读取该inputstream时是一个字节一个字节读的,直到整个流的字节全部读回来,这期间没有对这些数据做任何缓存。因此,整个流一旦被读完,是无法再继续读的。

这和nio的处理方式就完全不同,如果是nio的话,数据是先被读取到一块缓存中,然后程序去读取这块缓存的内容,这时候就允许程序重复读取缓存的内容,比如mark()然后reset()或者直接clear()重新读。

特意去看了下InputStream的源码,发现其实是有mark()和reset()方法的,但是默认的实现表示这是不能用的,源码如下

public boolean markSupported() {
    return false;
}
public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
}
public synchronized void mark(int readlimit) {}

其中mark是一个空函数,reset函数直接抛出异常。同时,inputstream还提供了markSupported()方法,默认是返回false,表示不支持mark,也就是标记(用于重新读)。

但是并不是所有的Inputstream实现都不允许重复读,比如BufferedInputStream就是允许重复读的,从类名来看,就知道这个类其实就是将读出来的数据进行缓存,来达到可以重复读的效果。下面是BufferedInputStream重写的3个方法

    public synchronized void mark(int readlimit) {
        marklimit = readlimit;
        markpos = pos;
    }
    public synchronized void reset() throws IOException {
        getBufIfOpen(); // Cause exception if closed
        if (markpos < 0)
            throw new IOException("Resetting to invalid mark");
        pos = markpos;
    }
    public boolean markSupported() {
        return true;
    }

可以看到BufferedInputStream的markSupported()方法返回的是true,说明它应该是支持重复读的。我们可以通过mark()和reset()来实现重复读的效果。

@RequestBody 自动映射原理的简单介绍

springMVC在处理请求时,先找到对应controller处理该请求的方法,然后遍历整个方法的所有参数,进行封装。在处理参数的过程中,会调用AbstractMessageConverterMethodArgumentResolver#readWithMessageConverters()类的方法进行进行一些转换操作,源码如下

protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
            Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
        MediaType contentType;
        boolean noContentType = false;
        try {
            contentType = inputMessage.getHeaders().getContentType();
        }
        catch (InvalidMediaTypeException ex) {
            throw new HttpMediaTypeNotSupportedException(ex.getMessage());
        }
        if (contentType == null) {
            noContentType = true;
            contentType = MediaType.APPLICATION_OCTET_STREAM;
        }
        Class<?> contextClass = parameter.getContainingClass();
        Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
        if (targetClass == null) {
            ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
            targetClass = (Class<T>) resolvableType.resolve();
        }
        HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
        Object body = NO_VALUE;
        EmptyBodyCheckingHttpInputMessage message;
        try {
            message = new EmptyBodyCheckingHttpInputMessage(inputMessage);
            for (HttpMessageConverter<?> converter : this.messageConverters) {
                Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
                GenericHttpMessageConverter<?> genericConverter =
                        (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
                if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
                        (targetClass != null && converter.canRead(targetClass, contentType))) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    }
                    if (message.hasBody()) {
                        HttpInputMessage msgToUse =
                                getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
                        body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
                                ((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
                        body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
                    }
                    else {
                        body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
                    }
                    break;
                }
            }
        }
        catch (IOException ex) {
            throw new HttpMessageNotReadableException("I/O error while reading input message", ex);
        }
        if (body == NO_VALUE) {
            if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
                    (noContentType && !message.hasBody())) {
                return null;
            }
            throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
        }
        return body;
    }

上面这段代码主要做的事情大概就是获取请求的contentType,然后遍历配置的HttpMessageConverter—>this.messageConverters,如果该HttpMessageConverter可以用于解析这种contentType(genericConverter.canRead方法),就用这种HttpMessageConverter解析请求的请求体内容,最后返回具体的对象。

在spring5.0.7版本中,messageConverters默认似乎配置了8种convert。分别是

  • ByteArrayMessageConverter
  • StringHttpMessageConverter
  • ResourceHttpMessageConverter
  • ResourceRegionHttpMessageConverter
  • SourceHttpMessageConverter
  • AllEncompassingFormHttpMessageConverter
  • MappingJackson2HttpMessageConverter
  • Jaxb2RootElementHttpMessageConverter

具体的convert是哪些contentType并怎么解析的,这里不多做介绍,感兴趣的朋友可以自行查看源码。

比如我们请求的header中的contentType是application/json,那么在遍历messageConverters的时候,其他genericConverter.canRead()都会返回false,说明没有适配上。

然后遍历到MappingJackson2HttpMessageConverter时genericConverter.canRead()返回true,接着就去获取请求的请求体,并通过json解析成我们@RequestBody定义的对象。

因此,如果我们的请求的contentType和数据协议都是自定义的,我们完全可以自己实现一个HttpMessageConverter,然后解析特定的contentType。

最后记得将这个实现放入messageConverters中,这样springMVC就会自动帮我们把请求内容解析成对象了。

关于@requestBody的一些说明

1、@requestBody注解

常用来处理content-type不是默认的application/x-www-form-urlcoded编码的内容,比如说:application/json或者是application/xml等。一般情况下来说常用其来处理application/json类型。

2、通过@requestBody

可以将请求体中的JSON字符串绑定到相应的bean上,当然也可以将其分别绑定到对应的字符串上。

例如说以下情况:

$.ajax({       
         url:"/login",       
         type:"POST",        
          data:'{"userName":"admin","pwd","admin123"}',      
        content-type:"application/json charset=utf-8",        
          success:function(data)
             {          
                alert("request success ! ");       
            }    
});
@requestMapping("/login")    
  public void login(@requestBody String userName,@requestBody String pwd){      
  System.out.println(userName+" :"+pwd);    
}

这种情况是将JSON字符串中的两个变量的值分别赋予了两个字符串,但是呢假如我有一个User类,拥有如下字段:

String userName;
String pwd;

那么上述参数可以改为以下形式:@requestBody User user 这种形式会将JSON字符串中的值赋予user中对应的属性上

需要注意的是,JSON字符串中的key必须对应user中的属性名,否则是请求不过去的。

3、在一些特殊情况

@requestBody也可以用来处理content-type类型为application/x-www-form-urlcoded的内容,只不过这种方式不是很常用,在处理这类请求的时候,@requestBody会将处理结果放到一个MultiValueMap<String,String>中,这种情况一般在特殊情况下才会使用,例如jQuery easyUI的datagrid请求数据的时候需要使用到这种方式、小型项目只创建一个POJO类的话也可以使用这种接受方式。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 解决SpringMVC使用@RequestBody注解报400错误的问题

    一般使用@RequestBody接收的时候报400都是传入的json字符串和对应封装的对象不对应造成的 首先要注意 封装的对象中的字段类型有没有Date类型或者int等类型的,如果有的话,在set方法中统一将传入的参数要调整为String类型 在set方法中进行参数的转换 比如有一个Date类型的字段 private Date startTime; public Date getStartTime() { return startTime; } public void setStartTime(

  • SpringMVC restful 注解之@RequestBody进行json与object转换

    由于快过年的原因,项目组没有太多任务,闲来无事研究了一下spring中restful调用.发现spring竟然已经强大到如此境界,程序员已经不需要在关心在写接口的过程中数据的转换以及调用,只需要专注业务.下面我总结一下步骤及其在研究过程的遇到的问题. 步骤: 1.git clone https://github.com/spring-guides/gs-rest-service.git 从spring官网上下载了源码 2.进行maven编译(gradle也行) 3.运行.访问http://loc

  • 快速解决SpringMVC @RequestBody 用map接收请求参数的问题

    一:遇到个跨域调用,因为传个我的参数不定,所以需要通过map来接收参数并进行签名验证等操作 理所当然的写出了下面的代码,但是发现map里并没有获取到传来的key-value值 @RequestMapping(value = "/callback", produces = "text/html;charset=UTF-8") @ResponseBody public String callback(@RequestBody Map<String, String&

  • 详解SpringMVC @RequestBody接收Json对象字符串

    页面提交请求参数有两种,一种是form格式提交,一种json格式提交 通常情况下我们使用的都是form格式提交的数据,数据格式:k=v&k=v,这个时候用springMVC接收参数没有问题,但有时候前端会通过json向后端传递数据,就会出现springMVC获取不到参数值的情况 注意:jQuery的$.post方法虽然也可以传递json格式数据,但实际上是用的form格式提交,jquery会帮你把json转成form格式提交后台 所以其实可以通过$.post,$.get来提交json格式,让jq

  • springmvc 获取@Requestbody转换的异常处理方式

    1.引入问题 使用spring 自动的@RequestBody,可以很方便的将参数转换成对象,然而在自动转换中出现如果出现异常,会默认直接发送HTTP异常代码和错误信息,如何才能自定义自己的异常呢. 2.解决方案 解答问题的方式有可以有很多,一种通用的解答方式是使用@ExceptionHandler 2.1 例如传递的请求体为JSON时 Spring 可以自动封装成一个Map @PostMapping(value = "/check",consumes = "applicat

  • springMvc注解之@ResponseBody和@RequestBody详解

    简介 springmvc对json的前后台传输做了很好封装,避免了重复编码的过程,下面来看看常用的@ResponseBody和@RequestBody注解 添加依赖 springmvc对json的处理依赖jackson <dependency> <groupId>org.codehaus.jackson</groupId> <artifactId>jackson-core-asl</artifactId> <version>1.9.1

  • SpringMVC @RequestBody 为null问题的排查及解决

    目录 SpringMVC @RequestBody为null 关于inputsteam的一些理解 @RequestBody 自动映射原理的简单介绍 关于@requestBody的一些说明 1.@requestBody注解 2.通过@requestBody 3.在一些特殊情况 SpringMVC @RequestBody为null 今天写一个springmvc接口,希望入参为json,然后自动转成自己定义的封装对象,于是有了下面的代码 @PostMapping("/update") @A

  • springmvc @RequestBody String类型参数的使用

    目录 springmvc @RequestBody String类型参数 springmvc用Map接收请求参数分析 第一种情况,什么也不设置,无参数传递 第二种情况,加个参数试试 => .../testmap?test1=2342 第三种情况,给Map参数添加@RequestParam注解 小结一下吧 springmvc @RequestBody String类型参数 通过如下配置: <bean id="mappingJacksonHttpMessageConverter"

  • SpringMVC @RequestBody的使用解析

    目录 SpringMVC @RequestBody的使用 @RequestBody使用的一些注意事项 SpringMVC @RequestBody的使用 Spring mvc是一个非常轻量的mvc框架,注解可以大大减少配置,让请求的拦截变得比较简单.这次记录下@RequestBody 注解接收参数尤其是数组参数的用法. 关于容器的配置不再多说,这里写出spring-servlet.xml的sechme: <?xml version="1.0" encoding="UTF

  • SpringMVC @RequestBody Date类型的Json转换方式

    目录 SpringMVC @RequestBody Date类型的Json转换 通过GsonBuilder设置DateFormat的格式 以零配置框架为例 以零配置形式框架下的代码实现为例讲解 @RequestBody接收json字符串,自动将日期字符串转换为java.util.Date 1.配置springMVC可以接收json字符串 2.@Controller类代码 3.实体类对象代码 4.DateJsonSerializer类代码 5.DateJsonDeserializer类代码 Spr

  • Mybatis resultType返回结果为null的问题排查方式

    目录 resultType返回结果为null的问题 sql语句大致如下 解决办法有下面几种 resultType获取结果一些有值一些为null 原因 配置如下 resultType返回结果为null的问题 sql语句大致如下   <select id="findFinancialProductConfigList" resultType="com.xxx.FinancialProductConfigDTO">     select  <includ

  • Java内存泄漏问题排查与解决

    前言 Java 最牛逼的一个特性就是垃圾回收机制,不用像 C++ 需要手动管理内存,所以作为 Java 程序员很幸福,只管 New New New 即可,反正 Java 会自动回收过期的对象... 那么 Java 都自动管理内存了,那怎么会出现内存泄漏,难道 Jvm 有 bug? 不要急,且听我慢慢道来.. 1. 怎么判断可以被回收 先了解一下 Jvm 是怎么判断一个对象可以被回收.一般有两种方式,一种是引用计数法,一种是可达性分析. 引用计数法:每个对象有一个引用计数属性,新增一个引用时计数加

  • fastjson生成json时Null属性不显示的解决方法

    举个例子 Map < String , Object > jsonMap = new HashMap< String , Object>(); jsonMap.put("a",1); jsonMap.put("b",""); jsonMap.put("c",null); jsonMap.put("d","wuzhuti.cn"); String str = JSO

  • Go中http超时问题的排查及解决方法

    背景 最新有同事反馈,服务间有调用超时的现象,在业务高峰期发生的概率和次数比较高.从日志中调用关系来看,有2个调用链经常发生超时问题. 问题1: A服务使用 http1.1 发送请求到 B 服务超时. 问题2: A服务使用一个轻量级http-sdk(内部http2.0) 发送请求到 C 服务超时. Golang给出的报错信息时: Post http://host/v1/xxxx: net/http: request canceled while waiting for connection (C

  • 记一次django内存异常排查及解决方法

    起因 Django 作为 Python著名的Web框架,相信很多人都在用,自己工作中也有项目项目在用,而在最近几天的使用中发现,部署Django程序的服务器出现了内存问题,现象就是运行一段时间之后,内存占用非常高,最终会把服务器的内存耗尽,对于Python项目出现内存问题,自己之前处理过一次,所以并没有第一次解决时的慌张,自己之前把解决方法也整理了:https://www.jb51.net/article/151604.htm 但是事情似乎并没有我想的那么简单,自己尝试用之前的的方法tracem

随机推荐