共计 9817 个字符,预计需要花费 25 分钟才能阅读完成。
序言
最近小明接手了前共事的代码,意料之外、情理之中的遇到了坑。
为了防止掉入同一个坑两次,小明决定把这个坑记下来,并在坑前立一个大牌子,防止其余小伙伴掉进去。
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 的相干常识。
我是老马,期待与你的下次重逢。