springboot中inputStream神秘消失的示例分析

這篇文章主要為大家展示了“springboot中inputStream神秘消失的示例分析”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“springboot中inputStream神秘消失的示例分析”這篇文章吧。

HTTPClient 模擬調用

為了把這個問題說明，我們首先從最簡單的 http 調用說起。

設置 body

服務端

服務端的代碼如下：

@Controller
@RequestMapping("/")
public class ReqController {

    @PostMapping(value = "/body")
    @ResponseBody
    public String body(HttpServletRequest httpServletRequest) {
        try {
            String body = StreamUtil.toString(httpServletRequest.getInputStream());
            System.out.println("請求的 body: " + body);

            // 從參數中獲取
            return body;
        } catch (IOException e) {
            e.printStackTrace();
            return e.getMessage();
        }
    }

}

java 客戶端要如何請求才能讓服務端讀取到傳遞的 body 呢？

客戶端

這個問題一定難不到你，實現的方式有很多種。

我們以 apache httpclient 為例：

//post請求，帶集合參數
public static String post(String url, String body) {
    try {
        // 通過HttpPost來發送post請求
        HttpPost httpPost = new HttpPost(url);
        StringEntity stringEntity = new StringEntity(body);
        // 通過setEntity 將我們的entity對象傳遞過去
        httpPost.setEntity(stringEntity);
        return execute(httpPost);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}

//執行請求返回響應數據
private static String execute(HttpRequestBase http) {
    try {
        CloseableHttpClient client = HttpClients.createDefault();
        // 通過client調用execute方法
        CloseableHttpResponse Response = client.execute(http);
        //獲取響應數據
        HttpEntity entity = Response.getEntity();
        //將數據轉換成字符串
        String str = EntityUtils.toString(entity, "UTF-8");
        //關閉
        Response.close();
        return str;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

可以發現 httpclient 封裝之后還是非常方便的。

我們設置 setEntity 為對應入參的 StringEntity 即可。

測試

為了驗證正確性，小明本地實現了一個驗證方法。

@Test
public void bodyTest() {
    String url = "http://localhost:8080/body";
    String body = buildBody();
    String result = HttpClientUtils.post(url, body);

    Assert.assertEquals("body", result);
}

private String buildBody() {
    return "body";
}

很輕松，小明漏出了龍王的微笑。

設置 parameter

服務端

小明又看到有一個服務端的代碼實現如下：

@PostMapping(value = "/param")
@ResponseBody
public String param(HttpServletRequest httpServletRequest) {
    // 從參數中獲取
    String param = httpServletRequest.getParameter("id");
    System.out.println("param: " + param);
    return param;
}

private Map<String,String> buildParamMap() {
    Map<String,String> map = new HashMap<>();
    map.put("id", "123456");

    return map;
}

所有的參數是通過 getParameter 方法獲取，應該如何實現呢？

客戶端

這個倒也不難，小明心想。

因為以前很多代碼都是這樣實現的，于是 ctrl+CV 搞定了下面的代碼：

//post請求，帶集合參數
public static String post(String url, Map<String, String> paramMap) {
    List<NameValuePair> nameValuePairs = new ArrayList<>();
    for (Map.Entry<String, String> entry : paramMap.entrySet()) {
        NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
        nameValuePairs.add(pair);
    }
    return post(url, nameValuePairs);
}

//post請求，帶集合參數
private static String post(String url, List<NameValuePair> list) {
    try {
        // 通過HttpPost來發送post請求
        HttpPost httpPost = new HttpPost(url);
        // 我們發現Entity是一個接口，所以只能找實現類，發現實現類又需要一個集合，集合的泛型是NameValuePair類型
        UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(list);
        // 通過setEntity 將我們的entity對象傳遞過去
        httpPost.setEntity(formEntity);
        return execute(httpPost);
    } catch (Exception exception) {
        throw new RuntimeException(exception);
    }
}

如此是最常用的 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 將不再可用了。

這是很重要的一個約定，導致很多小伙伴比較蒙圈。

測試

于是，小明也寫好了對應的測試用例：

@Test
public void paramTest() {
    String url = "http://localhost:8080/param";

    Map<String,String> map = buildParamMap();
    String result = HttpClientUtils.post(url, map);

    Assert.assertEquals("123456", result);
}

如果談戀愛能像編程一樣，那該多好。

小明想著，卻不由得眉頭一皺，發現事情并不簡單。

設置 parameter 和 body

服務端

有一個請求的入參是比較大，所以放在 body 中，其他參數依然放在 paramter 中。

@PostMapping(value = "/paramAndBody")
@ResponseBody
public String paramAndBody(HttpServletRequest httpServletRequest) {
    try {
        // 從參數中獲取
        String param = httpServletRequest.getParameter("id");
        System.out.println("param: " + param);
        String body = StreamUtil.toString(httpServletRequest.getInputStream());
        System.out.println("請求的 body: " + body);
        // 從參數中獲取
        return param+"-"+body;
    } catch (IOException e) {
        e.printStackTrace();
        return e.getMessage();
    }
}

其中 StreamUtil#toString 是一個對流簡單處理的工具類。

/**
 * 轉換為字符串
 * @param inputStream 流
 * @return 結果
 * @since 1.0.0
 */
public static String toString(final InputStream inputStream)  {
    if (inputStream == null) {
        return null;
    }
    try {
        int length = inputStream.available();
        final Reader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
        final CharArrayBuffer buffer = new CharArrayBuffer(length);
        final char[] tmp = new char[1024];
        int l;
        while((l = reader.read(tmp)) != -1) {
            buffer.append(tmp, 0, l);
        }
        return buffer.toString();
    } catch (Exception exception) {
        throw new RuntimeException(exception);
    }
}

客戶端

那么問題來了，如何同時在 HttpClient 中設置 parameter 和 body 呢？

機智的小伙伴們可以自己先嘗試一下。

小明嘗試了多種方法，發現一個殘酷的現實—— httpPost 只能設置一個 Entity，也嘗試看了各種子類，然并LUAN。

就在小明想要放棄的時候，小明忽然想到，paramter 完全可以通過拼接 URL 的方式實現。

也就是我們把 parameter 和 url 并且為一個新的 URL，body 和以前設置方式一樣。

實現代碼如下：

//post請求，帶集合參數
public static String post(String url, Map<String, String> paramMap,
                          String body) {
    try {
        List<NameValuePair> nameValuePairs = new ArrayList<>();
        for (Map.Entry<String, String> entry : paramMap.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());
            nameValuePairs.add(pair);
        }

        // 構建 url
        //構造請求路徑，并添加參數
        URI uri = new URIBuilder(url).addParameters(nameValuePairs).build();

        //構造HttpClient
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 通過HttpPost來發送post請求
        HttpPost httpPost = new HttpPost(uri);
        httpPost.setEntity(new StringEntity(body));

        // 獲取響應
        // 通過client調用execute方法
        CloseableHttpResponse Response = httpClient.execute(httpPost);
        //獲取響應數據
        HttpEntity entity = Response.getEntity();
        //將數據轉換成字符串
        String str = EntityUtils.toString(entity, "UTF-8");
        //關閉
        Response.close();
        return str;
    } catch (URISyntaxException | IOException | ParseException e) {
        throw new RuntimeException(e);
    }
}

這里通過 new URIBuilder(url).addParameters(nameValuePairs).build() 構建新的 URL，當然你可以使用 &key=value 的方式自己拼接。

測試代碼

@Test
public void paramAndBodyTest() {
    String url = "http://localhost:8080/paramAndBody";
    Map<String,String> map = buildParamMap();
    String body = buildBody();
    String result = HttpClientUtils.post(url, map, body);

    Assert.assertEquals("123456-body", result);
}

測試通過，非常完美。

新的征程

當然，一般的文章到這里就該結束了。

不過上面并不是本文的重點，我們的故事才剛剛開始。

日志需求

大雁飛過，天空一定會留下他的痕跡。

程序更應如此。

為了方便的跟蹤問題，我們一般都是對調用的入參進行日志留痕。

為了便于代碼拓展和可維護性，小明當然采用攔截器的方式。

日志攔截器

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StreamUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;

/**
 * 日志攔截器

 * @author 老馬嘯西風
 * @since 1.0.0
 */
@Component
public class LogHandlerInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(LogHandlerInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest,
                             HttpServletResponse httpServletResponse, Object o) throws Exception {
        // 獲取參數信息
        Enumeration<String> enumeration = httpServletRequest.getParameterNames();
        while (enumeration.hasMoreElements()) {
            String paraName = enumeration.nextElement();
            logger.info("Param name: {}, value: {}", paraName, httpServletRequest.getParameter(paraName));
        }

        // 獲取 body 信息
        String body = StreamUtils.copyToString(httpServletRequest.getInputStream(), StandardCharsets.UTF_8);
        logger.info("body: {}", body);

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest httpServletRequest,
                           HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest,
                                HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }

}

非常的簡單易懂，輸出入參中的 parameter 參數和 body 信息。

然后指定一下生效的范圍：

@Configuration
public class SpringMvcConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private LogHandlerInterceptor logHandlerInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(logHandlerInterceptor)
                .addPathPatterns("/**");

        super.addInterceptors(registry);
    }

}

所有的請求都會生效。

我的 inputStream 呢？

小伙伴們覺得剛才的日志攔截器有沒有問題？

如果有，又應該怎么解決呢？

小明寫完心想一切順利，一運行測試用例，整個人都裂開了。

所有 Controller 方法中的 httpServletRequest.getInputStream() 的內容都變成空了。

是誰？偷走了我的 inputStream？

轉念一想，小明發現了問題所在。

肯定是自己剛才新增的日志攔截器有問題，因為 stream 作為流只能被讀取一遍，日志中讀取一遍之后，后面就讀不到了。

可是日志中必須要輸出，那應該怎么辦呢？

遇事不決

遇事不決，技術問 google，八卦去圍脖。

于是小明去查了一下，解決方案也比較直接，重寫。

重寫 HttpServletRequestWrapper

首先重寫 HttpServletRequestWrapper，把每次讀取的流信息保存起來，便于重復讀取。

/**
 * @author binbin.hou
 * @since 1.0.0
 */
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private byte[] requestBody = null;//用于將流保存下來

    public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        requestBody = StreamUtils.copyToByteArray(request.getInputStream());
    }


    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);
        return new ServletInputStream() {
            @Override
            public int read() {
                return bais.read();  // 讀取 requestBody 中的數據
            }

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }
        };
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

}

實現 Filter

我們上面重寫的 MyHttpServletRequestWrapper 什么時候生效呢？

我們可以自己實現一個 Filter，對原有的請求進行替換：

import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
@Component
public class HttpServletRequestReplacedFilter implements Filter {

    @Override
    public void destroy() {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;

        // 進行替換
        if(request instanceof HttpServletRequest) {
            requestWrapper = new MyHttpServletRequestWrapper((HttpServletRequest) request);
        }

        if(requestWrapper == null) {
            chain.doFilter(request, response);
        } else {
            chain.doFilter(requestWrapper, response);
        }
    }
    @Override
    public void init(FilterConfig arg0) throws ServletException {}

}

然后就可以發現一切都好起來了。

以上是“springboot中inputStream神秘消失的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！