Springboot 中InputStream 神秘消失之谜

开发 前端
最近小明接手了前同事的代码,意料之外、情理之中的遇到了坑。为了避免掉入同一个坑两次,小明决定把这个坑记下来,并在坑前立一个大牌子,避免其他小伙伴掉进去。

[[417933]]

序言

最近小明接手了前同事的代码,意料之外、情理之中的遇到了坑。

为了避免掉入同一个坑两次,小明决定把这个坑记下来,并在坑前立一个大牌子,避免其他小伙伴掉进去。

HTTPClient 模拟调用

为了把这个问题说明,我们首先从最简单的 http 调用说起。

设置 body

服务端

服务端的代码如下:

  1. @Controller 
  2. @RequestMapping("/"
  3. public class ReqController { 
  4.  
  5.     @PostMapping(value = "/body"
  6.     @ResponseBody 
  7.     public String body(HttpServletRequest httpServletRequest) { 
  8.         try { 
  9.             String body = StreamUtil.toString(httpServletRequest.getInputStream()); 
  10.             System.out.println("请求的 body: " + body); 
  11.  
  12.             // 从参数中获取 
  13.             return body; 
  14.         } catch (IOException e) { 
  15.             e.printStackTrace(); 
  16.             return e.getMessage(); 
  17.         } 
  18.     } 
  19.  

java 客户端要如何请求才能让服务端读取到传递的 body 呢?

客户端

这个问题一定难不到你,实现的方式有很多种。

我们以 apache httpclient 为例:

  1. //post请求,带集合参数 
  2. public static String post(String url, String body) { 
  3.     try { 
  4.         // 通过HttpPost来发送post请求 
  5.         HttpPost httpPost = new HttpPost(url); 
  6.         StringEntity stringEntity = new StringEntity(body); 
  7.         // 通过setEntity 将我们的entity对象传递过去 
  8.         httpPost.setEntity(stringEntity); 
  9.         return execute(httpPost); 
  10.     } catch (UnsupportedEncodingException e) { 
  11.         throw new RuntimeException(e); 
  12.     } 
  13.  
  14. //执行请求返回响应数据 
  15. private static String execute(HttpRequestBase http) { 
  16.     try { 
  17.         CloseableHttpClient client = HttpClients.createDefault(); 
  18.         // 通过client调用execute方法 
  19.         CloseableHttpResponse Response = client.execute(http); 
  20.         //获取响应数据 
  21.         HttpEntity entity = Response.getEntity(); 
  22.         //将数据转换成字符串 
  23.         String str = EntityUtils.toString(entity, "UTF-8"); 
  24.         //关闭 
  25.         Response.close(); 
  26.         return str; 
  27.     } catch (IOException e) { 
  28.         throw new RuntimeException(e); 
  29.     } 

可以发现 httpclient 封装之后还是非常方便的。

我们设置 setEntity 为对应入参的 StringEntity 即可。

测试

为了验证正确性,小明本地实现了一个验证方法。

  1. @Test 
  2. public void bodyTest() { 
  3.     String url = "http://localhost:8080/body"
  4.     String body = buildBody(); 
  5.     String result = HttpClientUtils.post(url, body); 
  6.  
  7.     Assert.assertEquals("body", result); 
  8.  
  9. private String buildBody() { 
  10.     return "body"

很轻松,小明漏出了龙王的微笑。

设置 parameter

服务端

小明又看到有一个服务端的代码实现如下:

  1. @PostMapping(value = "/param"
  2. @ResponseBody 
  3. public String param(HttpServletRequest httpServletRequest) { 
  4.     // 从参数中获取 
  5.     String param = httpServletRequest.getParameter("id"); 
  6.     System.out.println("param: " + param); 
  7.     return param; 
  8.  
  9. private Map<String,String> buildParamMap() { 
  10.     Map<String,String> map = new HashMap<>(); 
  11.     map.put("id""123456"); 
  12.  
  13.     return map; 

所有的参数是通过 getParameter 方法获取,应该如何实现呢?

客户端

这个倒也不难,小明心想。

因为以前很多代码都是这样实现的,于是 ctrl+CV 搞定了下面的代码:

  1. //post请求,带集合参数 
  2. public static String post(String url, Map<String, String> paramMap) { 
  3.     List<NameValuePair> nameValuePairs = new ArrayList<>(); 
  4.     for (Map.Entry<String, String> entry : paramMap.entrySet()) { 
  5.         NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue()); 
  6.         nameValuePairs.add(pair); 
  7.     } 
  8.     return post(url, nameValuePairs); 
  9.  
  10. //post请求,带集合参数 
  11. private static String post(String url, List<NameValuePair> list) { 
  12.     try { 
  13.         // 通过HttpPost来发送post请求 
  14.         HttpPost httpPost = new HttpPost(url); 
  15.         // 我们发现Entity是一个接口,所以只能找实现类,发现实现类又需要一个集合,集合的泛型是NameValuePair类型 
  16.         UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(list); 
  17.         // 通过setEntity 将我们的entity对象传递过去 
  18.         httpPost.setEntity(formEntity); 
  19.         return execute(httpPost); 
  20.     } catch (Exception exception) { 
  21.         throw new RuntimeException(exception); 
  22.     } 

如此是最常用的 paramMap,便于构建;和具体的实现方式脱离,也便于后期拓展。

servlet 标准

UrlEncodedFormEntity 看似平平无奇,表示这是一个 post 表单请求。

里面还涉及到 servlet 3.1 的一个标准,必须满足下面的标准,post 表单的 parameter 集合才可用。

1. 请求是 http 或 https

2. 请求的方法是 POST

3. content type 为: application/x-www-form-urlencoded

4. servlet 已经在 request 对象上调用了相关的 getParameter 方法。

当以上条件不满足时,POST 表单的数据并不会设置到 parameter 集合中,但依然可以通过 request 对象的 inputstream 来获取。

当以上条件满足时,POST 表单的数据在 request 对象的 inputstream 将不再可用了。

这是很重要的一个约定,导致很多小伙伴比较蒙圈。

测试

于是,小明也写好了对应的测试用例:

  1. @Test 
  2. public void paramTest() { 
  3.     String url = "http://localhost:8080/param"
  4.  
  5.     Map<String,String> map = buildParamMap(); 
  6.     String result = HttpClientUtils.post(url, map); 
  7.  
  8.     Assert.assertEquals("123456", result); 

小明想着,却不由得眉头一皱,发现事情并不简单。

设置 parameter 和 body

服务端

有一个请求的入参是比较大,所以放在 body 中,其他参数依然放在 paramter 中。

  1. @PostMapping(value = "/paramAndBody"
  2. @ResponseBody 
  3. public String paramAndBody(HttpServletRequest httpServletRequest) { 
  4.     try { 
  5.         // 从参数中获取 
  6.         String param = httpServletRequest.getParameter("id"); 
  7.         System.out.println("param: " + param); 
  8.         String body = StreamUtil.toString(httpServletRequest.getInputStream()); 
  9.         System.out.println("请求的 body: " + body); 
  10.         // 从参数中获取 
  11.         return param+"-"+body; 
  12.     } catch (IOException e) { 
  13.         e.printStackTrace(); 
  14.         return e.getMessage(); 
  15.     } 

其中 StreamUtil#toString 是一个对流简单处理的工具类。

  1. /** 
  2.  * 转换为字符串 
  3.  * @param inputStream 流 
  4.  * @return 结果 
  5.  * @since 1.0.0 
  6.  */ 
  7. public static String toString(final InputStream inputStream)  { 
  8.     if (inputStream == null) { 
  9.         return null
  10.     } 
  11.     try { 
  12.         int length = inputStream.available(); 
  13.         final Reader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8); 
  14.         final CharArrayBuffer buffer = new CharArrayBuffer(length); 
  15.         final char[] tmp = new char[1024]; 
  16.         int l; 
  17.         while((l = reader.read(tmp)) != -1) { 
  18.             buffer.append(tmp, 0, l); 
  19.         } 
  20.         return buffer.toString(); 
  21.     } catch (Exception exception) { 
  22.         throw new RuntimeException(exception); 
  23.     } 

客户端

那么问题来了,如何同时在 HttpClient 中设置 parameter 和 body 呢?

机智的小伙伴们可以自己先尝试一下。

小明尝试了多种方法,发现一个残酷的现实—— httpPost 只能设置一个 Entity,也尝试看了各种子类,然并LUAN。

就在小明想要放弃的时候,小明忽然想到,paramter 完全可以通过拼接 URL 的方式实现。

也就是我们把 parameter 和 url 并且为一个新的 URL,body 和以前设置方式一样。

实现代码如下:

  1. //post请求,带集合参数 
  2. public static String post(String url, Map<String, String> paramMap, 
  3.                           String body) { 
  4.     try { 
  5.         List<NameValuePair> nameValuePairs = new ArrayList<>(); 
  6.         for (Map.Entry<String, String> entry : paramMap.entrySet()) { 
  7.             NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue()); 
  8.             nameValuePairs.add(pair); 
  9.         } 
  10.  
  11.         // 构建 url 
  12.         //构造请求路径,并添加参数 
  13.         URI uri = new URIBuilder(url).addParameters(nameValuePairs).build(); 
  14.  
  15.         //构造HttpClient 
  16.         CloseableHttpClient httpClient = HttpClients.createDefault(); 
  17.         // 通过HttpPost来发送post请求 
  18.         HttpPost httpPost = new HttpPost(uri); 
  19.         httpPost.setEntity(new StringEntity(body)); 
  20.  
  21.         // 获取响应 
  22.         // 通过client调用execute方法 
  23.         CloseableHttpResponse Response = httpClient.execute(httpPost); 
  24.         //获取响应数据 
  25.         HttpEntity entity = Response.getEntity(); 
  26.         //将数据转换成字符串 
  27.         String str = EntityUtils.toString(entity, "UTF-8"); 
  28.         //关闭 
  29.         Response.close(); 
  30.         return str; 
  31.     } catch (URISyntaxException | IOException | ParseException e) { 
  32.         throw new RuntimeException(e); 
  33.     } 

这里通过 new URIBuilder(url).addParameters(nameValuePairs).build() 构建新的 URL,当然你可以使用 &key=value 的方式自己拼接。

测试代码

  1. @Test 
  2. public void paramAndBodyTest() { 
  3.     String url = "http://localhost:8080/paramAndBody"
  4.     Map<String,String> map = buildParamMap(); 
  5.     String body = buildBody(); 
  6.     String result = HttpClientUtils.post(url, map, body); 
  7.  
  8.     Assert.assertEquals("123456-body", result); 

测试通过,非常完美。

新的征程

当然,一般的文章到这里就该结束了。

不过上面并不是本文的重点,我们的故事才刚刚开始。

日志需求

大雁飞过,天空一定会留下他的痕迹。

程序更应如此。

为了方便的跟踪问题,我们一般都是对调用的入参进行日志留痕。

为了便于代码拓展和可维护性,小明当然采用拦截器的方式。

日志拦截器

  1. import org.slf4j.Logger; 
  2. import org.slf4j.LoggerFactory; 
  3. import org.springframework.stereotype.Component; 
  4. import org.springframework.util.StreamUtils; 
  5. import org.springframework.web.servlet.HandlerInterceptor; 
  6. import org.springframework.web.servlet.ModelAndView; 
  7.  
  8. import javax.servlet.http.HttpServletRequest; 
  9. import javax.servlet.http.HttpServletResponse; 
  10. import java.nio.charset.StandardCharsets; 
  11. import java.util.Enumeration; 
  12.  
  13. /** 
  14.  * 日志拦截器 
  15.  
  16.  * @author 老马啸西风 
  17.  * @since 1.0.0 
  18.  */ 
  19. @Component 
  20. public class LogHandlerInterceptor implements HandlerInterceptor { 
  21.  
  22.     private Logger logger = LoggerFactory.getLogger(LogHandlerInterceptor.class); 
  23.  
  24.     @Override 
  25.     public boolean preHandle(HttpServletRequest httpServletRequest, 
  26.                              HttpServletResponse httpServletResponse, Object o) throws Exception { 
  27.         // 获取参数信息 
  28.         Enumeration<String> enumeration = httpServletRequest.getParameterNames(); 
  29.         while (enumeration.hasMoreElements()) { 
  30.             String paraName = enumeration.nextElement(); 
  31.             logger.info("Param name: {}, value: {}", paraName, httpServletRequest.getParameter(paraName)); 
  32.         } 
  33.  
  34.         // 获取 body 信息 
  35.         String body = StreamUtils.copyToString(httpServletRequest.getInputStream(), StandardCharsets.UTF_8); 
  36.         logger.info("body: {}", body); 
  37.  
  38.         return true
  39.     } 
  40.  
  41.     @Override 
  42.     public void postHandle(HttpServletRequest httpServletRequest, 
  43.                            HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception { 
  44.  
  45.     } 
  46.  
  47.     @Override 
  48.     public void afterCompletion(HttpServletRequest httpServletRequest, 
  49.                                 HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception { 
  50.  
  51.     } 
  52.  

非常的简单易懂,输出入参中的 parameter 参数和 body 信息。

然后指定一下生效的范围:

  1. @Configuration 
  2. public class SpringMvcConfig extends WebMvcConfigurerAdapter { 
  3.  
  4.     @Autowired 
  5.     private LogHandlerInterceptor logHandlerInterceptor; 
  6.  
  7.     @Override 
  8.     public void addInterceptors(InterceptorRegistry registry) { 
  9.         registry.addInterceptor(logHandlerInterceptor) 
  10.                 .addPathPatterns("/**"); 
  11.  
  12.         super.addInterceptors(registry); 
  13.     } 
  14.  

所有的请求都会生效。

我的 inputStream 呢?

小伙伴们觉得刚才的日志拦截器有没有问题?

如果有,又应该怎么解决呢?

小明写完心想一切顺利,一运行测试用例,整个人都裂开了。

所有 Controller 方法中的

httpServletRequest.getInputStream() 的内容都变成空了。

是谁?偷走了我的 inputStream?

转念一想,小明发现了问题所在。

肯定是自己刚才新增的日志拦截器有问题,因为 stream 作为流只能被读取一遍,日志中读取一遍之后,后面就读不到了。

可是日志中必须要输出,那应该怎么办呢?

遇事不决

遇事不决,技术问 google,八卦去围脖。

于是小明去查了一下,解决方案也比较直接,重写。

重写 HttpServletRequestWrapper

首先重写 HttpServletRequestWrapper,把每次读取的流信息保存起来,便于重复读取。

  1. /** 
  2.  * @author binbin.hou 
  3.  * @since 1.0.0 
  4.  */ 
  5. public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper { 
  6.  
  7.     private byte[] requestBody = null;//用于将流保存下来 
  8.  
  9.     public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException { 
  10.         super(request); 
  11.         requestBody = StreamUtils.copyToByteArray(request.getInputStream()); 
  12.     } 
  13.  
  14.  
  15.     @Override 
  16.     public ServletInputStream getInputStream() { 
  17.         final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody); 
  18.         return new ServletInputStream() { 
  19.             @Override 
  20.             public int read() { 
  21.                 return bais.read();  // 读取 requestBody 中的数据 
  22.             } 
  23.  
  24.             @Override 
  25.             public boolean isFinished() { 
  26.                 return false
  27.             } 
  28.  
  29.             @Override 
  30.             public boolean isReady() { 
  31.                 return false
  32.             } 
  33.  
  34.             @Override 
  35.             public void setReadListener(ReadListener readListener) { 
  36.             } 
  37.         }; 
  38.     } 
  39.  
  40.     @Override 
  41.     public BufferedReader getReader() throws IOException { 
  42.         return new BufferedReader(new InputStreamReader(getInputStream())); 
  43.     } 
  44.  

实现 Filter

我们上面重写的

MyHttpServletRequestWrapper 什么时候生效呢?

我们可以自己实现一个 Filter,对原有的请求进行替换:

  1. import org.springframework.stereotype.Component; 
  2.  
  3. import javax.servlet.*; 
  4. import javax.servlet.http.HttpServletRequest; 
  5. import java.io.IOException; 
  6.  
  7. /** 
  8.  * @author binbin.hou 
  9.  * @since 1.0.0 
  10.  */ 
  11. @Component 
  12. public class HttpServletRequestReplacedFilter implements Filter { 
  13.  
  14.     @Override 
  15.     public void destroy() {} 
  16.  
  17.     @Override 
  18.     public void doFilter(ServletRequest request, ServletResponse response, 
  19.                          FilterChain chain) throws IOException, ServletException { 
  20.         ServletRequest requestWrapper = null
  21.  
  22.         // 进行替换 
  23.         if(request instanceof HttpServletRequest) { 
  24.             requestWrapper = new MyHttpServletRequestWrapper((HttpServletRequest) request); 
  25.         } 
  26.  
  27.         if(requestWrapper == null) { 
  28.             chain.doFilter(request, response); 
  29.         } else { 
  30.             chain.doFilter(requestWrapper, response); 
  31.         } 
  32.     } 
  33.     @Override 
  34.     public void init(FilterConfig arg0) throws ServletException {} 
  35.  

然后就可以发现一切都好起来了,小明嘴角又漏出了龙王的微笑。

小结

文中对原始问题进行了简化,实际遇到这个问题的时候,直接就是一个拦截器+参数和body的请求。

所以整个问题排查起来有些浪费时间。

不过浪费的时间如果没有任何反思,那就是真的浪费了。

最核心的两点在于:

(1)对于 servlet 标准的理解。

(2)对于流读取的理解,以及一些 spring 的相关知识。

 

责任编辑:姜华 来源: 今日头条
相关推荐

2021-04-26 05:45:43

字符串制表符PyCharm

2021-07-15 10:38:36

REvil勒索软件黑客

2014-06-17 10:37:43

2011-07-06 12:04:53

架构

2021-07-28 21:49:01

JVM对象内存

2009-11-19 11:03:51

Oracle LogM

2013-03-01 11:00:23

2012-03-28 09:48:45

2023-09-22 11:48:37

2013-07-19 14:00:13

iOS中BlockiOS开发学习

2013-07-19 14:35:59

iOS中BlockiOS开发学习

2011-06-28 13:43:50

Java EE

2017-01-13 10:35:23

2020-09-29 09:50:45

淘宝差评移动应用

2010-02-03 17:25:07

CentOS服务器

2021-05-30 19:29:12

内存Go语言

2022-04-01 08:23:17

InputstreString字符串

2017-02-24 14:53:16

iOSRunLoop

2015-08-20 13:43:17

NFV网络功能虚拟化

2015-03-24 11:34:53

深圳互联网
点赞
收藏

51CTO技术栈公众号