HttpClient优化思路

HttpClient优化思路：

池化

长连接

httpclient和httpget复用

合理的配置参数（最大并发请求数，各种超时时间，重试次数）

异步

多读源码

1.背景

我们有个业务，会调用其他部门提供的一个基于http的服务，日调用量在千万级别。使用了httpclient来完成业务。之前因为qps上不去，就看了一下业务代码，并做了一些优化，记录在这里。

先对比前后：优化之前，平均执行时间是250ms；

优化之后，平均执行时间是80ms，降低了三分之二的消耗，容器不再动不动就报警线程耗尽了，清爽~

2.分析

项目的原实现比较粗略，就是每次请求时初始化一个httpclient，生成一个httpPost对象，执行，然后从返回结果取出entity，保存成一个字符串，最后显式关闭response和client。

我们一点点分析和优化：

2.1 httpclient反复创建开销

httpclient是一个线程安全的类，没有必要由每个线程在每次使用时创建，全局保留一个即可。

2.2 反复创建tcp连接的开销

tcp的三次握手与四次挥手两大裹脚布过程，对于高频次的请求来说，消耗实在太大。试想如果每次请求我们需要花费5ms用于协商过程，那么对于qps为100的单系统，1秒钟我们就要花500ms用于握手和挥手。又不是高级领导，我们程序员就不要搞这么大做派了，改成keep alive方式以实现连接复用！

2.3 重复缓存entity的开销

原本的逻辑里，使用了如下代码：

HttpEntityentity=httpResponse.getEntity();

Stringresponse=EntityUtils.toString(entity);

这里我们相当于额外复制了一份content到一个字符串里，而原本的httpResponse仍然保留了一份content，需要被consume掉，在高并发且content非常大的情况下，会消耗大量内存。并且，我们需要显式的关闭连接，ugly。

3.实现

按上面的分析，我们主要要做三件事：一是单例的client，二是缓存的保活连接，三是更好的处理返回结果。一就不说了，来说说二。

提到连接缓存，很容易联想到数据库连接池。httpclient4提供了一个PoolingHttpClientConnectionManager 作为连接池。接下来我们通过以下步骤来优化：

3.1 定义一个keep alive strategy

关于keep-alive，本文不展开说明，只提一点，是否使用keep-alive要根据业务情况来定，它并不是灵丹妙药。还有一点，keep-alive和time_wait/close_wait之间也有不少故事。

在本业务场景里，我们相当于有少数固定客户端，长时间极高频次的访问服务器，启用keep-alive非常合适

再多提一嘴，http的keep-alive 和tcp的KEEPALIVE不是一个东西。回到正文，定义一个strategy如下：

ConnectionKeepAliveStrategymyStrategy=newConnectionKeepAliveStrategy(){
@Override
publiclonggetKeepAliveDuration(HttpResponseresponse,HttpContextcontext){
HeaderElementIteratorit=newBasicHeaderElementIterator
(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
while(it.hasNext()){
HeaderElementhe=it.nextElement();
Stringparam=he.getName();
Stringvalue=he.getValue();
if(value!=null&¶m.equalsIgnoreCase
("timeout")){
returnLong.parseLong(value)*1000;
}
}
return60*1000;//如果没有约定，则默认定义时长为60s
}
};

3.2 配置一个PoolingHttpClientConnectionManager

PoolingHttpClientConnectionManagerconnectionManager=newPoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(500);
connectionManager.setDefaultMaxPerRoute(50);//例如默认每路由最高50并发，具体依据业务来定

也可以针对每个路由设置并发数。

3.3 生成httpclient

httpClient=HttpClients.custom()
.setConnectionManager(connectionManager)
.setKeepAliveStrategy(kaStrategy)
.setDefaultRequestConfig(RequestConfig.custom().setStaleConnectionCheckEnabled(true).build())
.build();

❝

注意：使用setStaleConnectionCheckEnabled方法来逐出已被关闭的链接不被推荐。更好的方式是手动启用一个线程，定时运行closeExpiredConnections 和closeIdleConnections方法，如下所示。

❞

publicstaticclassIdleConnectionMonitorThreadextendsThread{

privatefinalHttpClientConnectionManagerconnMgr;
privatevolatilebooleanshutdown;

publicIdleConnectionMonitorThread(HttpClientConnectionManagerconnMgr){
super();
this.connMgr=connMgr;
}

@Override
publicvoidrun(){
try{
while(!shutdown){
synchronized(this){
wait(5000);
//Closeexpiredconnections
connMgr.closeExpiredConnections();
//Optionally,closeconnections
//thathavebeenidlelongerthan30sec
connMgr.closeIdleConnections(30,TimeUnit.SECONDS);
}
}
}catch(InterruptedExceptionex){
//terminate
}
}

publicvoidshutdown(){
shutdown=true;
synchronized(this){
notifyAll();
}
}

}

3.4 使用httpclient执行method时降低开销

这里要注意的是，不要关闭connection。

一种可行的获取内容的方式类似于，把entity里的东西复制一份：

res=EntityUtils.toString(response.getEntity(),"UTF-8");
EntityUtils.consume(response1.getEntity());

但是，更推荐的方式是定义一个ResponseHandler，方便你我他，不再自己catch异常和关闭流。在此我们可以看一下相关的源码：

publicTexecute(finalHttpHosttarget,finalHttpRequestrequest,
finalResponseHandlerresponseHandler,finalHttpContextcontext)
throwsIOException,ClientProtocolException{
Args.notNull(responseHandler,"Responsehandler");

finalHttpResponseresponse=execute(target,request,context);

finalTresult;
try{
result=responseHandler.handleResponse(response);
}catch(finalExceptiont){
finalHttpEntityentity=response.getEntity();
try{
EntityUtils.consume(entity);
}catch(finalExceptiont2){
//Logthisexception.Theoriginalexceptionismore
//importantandwillbethrowntothecaller.
this.log.warn("Errorconsumingcontentafteranexception.",t2);
}
if(tinstanceofRuntimeException){
throw(RuntimeException)t;
}
if(tinstanceofIOException){
throw(IOException)t;
}
thrownewUndeclaredThrowableException(t);
}

//Handlingtheresponsewassuccessful.Ensurethatthecontenthas
//beenfullyconsumed.
finalHttpEntityentity=response.getEntity();
EntityUtils.consume(entity);//看这里看这里
returnresult;
}

可以看到，如果我们使用resultHandler执行execute方法，会最终自动调用consume方法，而这个consume方法如下所示：

publicstaticvoidconsume(finalHttpEntityentity)throwsIOException{
if(entity==null){
return;
}
if(entity.isStreaming()){
finalInputStreaminstream=entity.getContent();
if(instream!=null){
instream.close();
}
}
}

可以看到最终它关闭了输入流。

4.其他

通过以上步骤，基本就完成了一个支持高并发的httpclient的写法，下面是一些额外的配置和提醒：

4.1 httpclient的一些超时配置

CONNECTION_TIMEOUT是连接超时时间，SO_TIMEOUT是socket超时时间，这两者是不同的。连接超时时间是发起请求前的等待时间；socket超时时间是等待数据的超时时间。

HttpParamsparams=newBasicHttpParams();
//设置连接超时时间
IntegerCONNECTION_TIMEOUT=2*1000;//设置请求超时2秒钟根据业务调整
IntegerSO_TIMEOUT=2*1000;//设置等待数据超时时间2秒钟根据业务调整

//定义了当从ClientConnectionManager中检索ManagedClientConnection实例时使用的毫秒级的超时时间
//这个参数期望得到一个java.lang.Long类型的值。如果这个参数没有被设置，默认等于CONNECTION_TIMEOUT，因此一定要设置。
LongCONN_MANAGER_TIMEOUT=500L;//在httpclient4.2.3中我记得它被改成了一个对象导致直接用long会报错，后来又改回来了

params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT,CONNECTION_TIMEOUT);
params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT,SO_TIMEOUT);
params.setLongParameter(ClientPNames.CONN_MANAGER_TIMEOUT,CONN_MANAGER_TIMEOUT);
//在提交请求之前测试连接是否可用
params.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK,true);

//另外设置http client的重试次数，默认是3次；当前是禁用掉（如果项目量不到，这个默认即可）
httpClient.setHttpRequestRetryHandler(newDefaultHttpRequestRetryHandler(0,false));

4.2 如果配置了nginx的话，nginx也要设置面向两端的keep-alive

现在的业务里，没有nginx的情况反而比较稀少。nginx默认和client端打开长连接而和server端使用短链接。

注意client端的keepalive_timeout和keepalive_requests参数，以及upstream端的keepalive参数设置，这三个参数的意义在此也不再赘述。

以上就是我的全部设置。通过这些设置，成功地将原本每次请求250ms的耗时降低到了80左右，效果显著。

JAR包如下：

 

org.apache.httpcomponents
httpclient
4.5.6

代码如下：

//Basic认证
privatestaticfinalCredentialsProvidercredsProvider=newBasicCredentialsProvider();
//httpClient
privatestaticfinalCloseableHttpClienthttpclient;
//httpGet方法
privatestaticfinalHttpGethttpget;
//
privatestaticfinalRequestConfigreqestConfig;
//响应处理器
privatestaticfinalResponseHandlerresponseHandler;
//jackson解析工具
privatestaticfinalObjectMappermapper=newObjectMapper();

static{
System.setProperty("http.maxConnections","50");
System.setProperty("http.keepAlive","true");
//设置basic校验
credsProvider.setCredentials(
newAuthScope(AuthScope.ANY_HOST,AuthScope.ANY_PORT,AuthScope.ANY_REALM),
newUsernamePasswordCredentials("",""));
//创建http客户端
httpclient=HttpClients.custom()
.useSystemProperties()
.setRetryHandler(newDefaultHttpRequestRetryHandler(3,true))
.setDefaultCredentialsProvider(credsProvider)
.build();
//初始化httpGet
httpget=newHttpGet();
//初始化HTTP请求配置
reqestConfig=RequestConfig.custom()
.setContentCompressionEnabled(true)
.setSocketTimeout(100)
.setAuthenticationEnabled(true)
.setConnectionRequestTimeout(100)
.setConnectTimeout(100).build();
httpget.setConfig(reqestConfig);
//初始化response解析器
responseHandler=newBasicResponseHandler();
}
/*
*功能：返回响应
*@authorzhangdaquan
*@param[url]
*@returnorg.apache.http.client.methods.CloseableHttpResponse
*@exception
*/
publicstaticStringgetResponse(Stringurl)throwsIOException{
HttpGetget=newHttpGet(url);
Stringresponse=httpclient.execute(get,responseHandler);
returnresponse;
}

/*
*功能：发送http请求，并用net.sf.json工具解析
*@authorzhangdaquan
*@param[url]
*@returnorg.json.JSONObject
*@exception
*/
publicstaticJSONObjectgetUrl(Stringurl)throwsException{
try{
httpget.setURI(URI.create(url));
Stringresponse=httpclient.execute(httpget,responseHandler);
JSONObjectjson=JSONObject.fromObject(response);
returnjson;
}catch(IOExceptione){
e.printStackTrace();
}
returnnull;
}

/*
*功能：发送http请求，并用jackson工具解析
*@authorzhangdaquan
*@param[url]
*@returncom.fasterxml.jackson.databind.JsonNode
*@exception
*/
publicstaticJsonNodegetUrl2(Stringurl){
try{
httpget.setURI(URI.create(url));
Stringresponse=httpclient.execute(httpget,responseHandler);
JsonNodenode=mapper.readTree(response);
returnnode;
}catch(IOExceptione){
e.printStackTrace();
}
returnnull;
}
/*
*功能：发送http请求，并用fastjson工具解析
*@authorzhangdaquan
*@param[url]
*@returncom.fasterxml.jackson.databind.JsonNode
*@exception
*/
publicstaticcom.alibaba.fastjson.JSONObjectgetUrl3(Stringurl){
try{
httpget.setURI(URI.create(url));
Stringresponse=httpclient.execute(httpget,responseHandler);
com.alibaba.fastjson.JSONObjectjsonObject=com.alibaba.fastjson.JSONObject.parseObject(response);
returnjsonObject;
}catch(IOExceptione){
e.printStackTrace();
}
returnnull;
}

审核编辑：汤梓红