序言

最近小明接手了前同事的程式碼，意料之外、情理之中的遇到了坑。

為了避免掉入同一個坑兩次，小明決定把這個坑記下來，並在坑前立一個大牌子，避免其他小夥伴掉進去。

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 {}

}

然後就可以發現一切都好起來了，小明嘴角又漏出了龍王的微笑。

小結

文中對原始問題進行了簡化，實際遇到這個問題的時候，直接就是一個攔截器+引數和body的請求。

所以整個問題排查起來有些浪費時間。

不過浪費的時間如果沒有任何反思，那就是真的浪費了。

最核心的兩點在於：

（1）對於 servlet 標準的理解。

（2）對於流讀取的理解，以及一些 spring 的相關知識。

我是老馬，期待與你的下次重逢。