异步httpclient(httpasyncclient)的使用与总结

浅浅的花香味﹌ 2021-06-22 15:37 720阅读 0赞

## 1. 前言 ##

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了， JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说。HttpClient 是Apache HttpComponents 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，特点：

*  实现了所有 HTTP 的方法（GET,POST,PUT,DELETE 等）；
 *  支持自动转向
 *  支持 HTTPS 协议
 *  支持代理服务器等
 *  具有连接池、异步功能，提升效率

我们知道可以用HttpClient来发送同步请求，在并发量大的情况下使用HttpClient的连接池来提高性能。此方法虽然很有效果，但是当访问量极大或网络不好的情况下也会出现某些网络请求慢导致其它请求阻塞的情况。所以我们可以将网络请求变成一个异步的请求，不影响其它的请求。

应用层的网络模型有同步与异步。同步意味当前线程是阻塞的，只有本次请求完成后才能进行下一次请求；异步意味着所有的请求可以同时塞入缓冲区，不阻塞当前的线程。

httpclient在4.x之后开始提供基于nio的异步版本httpasyncclient，httpasyncclient借助了Java并发库和nio进行封装(虽说NIO是同步非阻塞IO，但是HttpAsyncClient提供了回调的机制,与netty类似,所以可以模拟类似于AIO的效果),其调用方式非常便捷,但是其中也有许多需要注意的地方。

注：HttpClient 3 版本和 HttpClient 4 版本差别很大，代码不兼容。

## 2、pom依赖 ##

<dependency>  
    	<groupId>org.apache.httpcomponents</groupId>  
    	<artifactId>httpclient</artifactId>  
    	<version>4.5.2</version>  
    </dependency>  
    
    <dependency>  
    	<groupId>org.apache.httpcomponents</groupId>  
    	<artifactId>httpcore</artifactId>  
    	<version>4.4.5</version>  
    </dependency>  
    
    <dependency>  
    	<groupId>org.apache.httpcomponents</groupId>
    	<artifactId>httpcore-nio</artifactId>
    	<version>4.4.5</version>
    </dependency>  
    
    <dependency>  
    	<groupId>org.apache.httpcomponents</groupId>  
    	<artifactId>httpasyncclient</artifactId>  
    	<version>4.1.2</version>  
    </dependency>

简单示例：

public class TestHttpClient {
        public static void main(String[] args){
    
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(50000)
                    .setSocketTimeout(50000)
                    .setConnectionRequestTimeout(1000)
                    .build();
    
            //配置io线程
            IOReactorConfig ioReactorConfig = IOReactorConfig.custom().
                    setIoThreadCount(Runtime.getRuntime().availableProcessors())
                    .setSoKeepAlive(true)
                    .build();
            //设置连接池大小
            ConnectingIOReactor ioReactor=null;
            try {
                ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
            } catch (IOReactorException e) {
                e.printStackTrace();
            }
            PoolingNHttpClientConnectionManager connManager = new PoolingNHttpClientConnectionManager(ioReactor);
            connManager.setMaxTotal(100);
            connManager.setDefaultMaxPerRoute(100);
    
    
            final CloseableHttpAsyncClient client = HttpAsyncClients.custom().
                    setConnectionManager(connManager)
                    .setDefaultRequestConfig(requestConfig)
                    .build();
    
    
            //构造请求
            String url = "http://127.0.0.1:9200/_bulk";
            HttpPost httpPost = new HttpPost(url);
            StringEntity entity = null;
            try {
                String a = "{ \"index\": { \"_index\": \"test\", \"_type\": \"test\"} }\n" +
                        "{\"name\": \"上海\",\"age\":33}\n";
                entity = new StringEntity(a);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            httpPost.setEntity(entity);
    
            //start
            client.start();
    
            //异步请求
            client.execute(httpPost, new Back());
    
            while(true){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        static class Back implements FutureCallback<HttpResponse>{
    
            private long start = System.currentTimeMillis();
            Back(){
            }
    
            public void completed(HttpResponse httpResponse) {
                try {
                    System.out.println("cost is:"+(System.currentTimeMillis()-start)+":"+EntityUtils.toString(httpResponse.getEntity()));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            public void failed(Exception e) {
                System.err.println(" cost is:"+(System.currentTimeMillis()-start)+":"+e);
            }
    
            public void cancelled() {
    
            }
        }
    }

## 3、参数配置 ##

1）三个timeout：

RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(50000)
                    .setSocketTimeout(50000)
                    .setConnectionRequestTimeout(1000)
                    .build();

*  ConnectTimeout：连接超时，连接建立时间、三次握手完成时间。
 *  SocketTimeout：请求超时，数据传输过程中数据包之间间隔的最大时间。
 *  ConnectionRequestTimeout：使用连接池来管理连接，从连接池获取连接的超时时间。

下面针对ConnectionRequestTimeout的情况进行分析。实验条件：

1.  设置连接池最大连接数为1,每一个异步请求从开始到回调的执行时间在100ms以上;
2.  实验过程:连续发送2次请求

client.start();
    
    for(int i=0;i<2;i++){
    	client.execute(list.get(i), new Back());
    }

实验结果：  
第一次请求执行时间在200ms左右  
第二请求回调直接抛出TimeOutException

java.util.concurrent.TimeoutException
        at org.apache.http.nio.pool.AbstractNIOConnPool.processPendingRequest(AbstractNIOConnPool.java:364)
        at org.apache.http.nio.pool.AbstractNIOConnPool.processNextPendingRequest(AbstractNIOConnPool.java:344)
        at org.apache.http.nio.pool.AbstractNIOConnPool.release(AbstractNIOConnPool.java:318)
        at org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager.releaseConnection(PoolingNHttpClientConnectionManager.java:303)
        at org.apache.http.impl.nio.client.AbstractClientExchangeHandler.releaseConnection(AbstractClientExchangeHandler.java:239)
        at org.apache.http.impl.nio.client.MainClientExec.responseCompleted(MainClientExec.java:387)
        at org.apache.http.impl.nio.client.DefaultClientExchangeHandlerImpl.responseCompleted(DefaultClientExchangeHandlerImpl.java:168)
        at org.apache.http.nio.protocol.HttpAsyncRequestExecutor.processResponse(HttpAsyncRequestExecutor.java:436)
        at org.apache.http.nio.protocol.HttpAsyncRequestExecutor.inputReady(HttpAsyncRequestExecutor.java:326)
        at org.apache.http.impl.nio.DefaultNHttpClientConnection.consumeInput(DefaultNHttpClientConnection.java:265)
        at org.apache.http.impl.nio.client.InternalIODispatch.onInputReady(InternalIODispatch.java:81)
        at org.apache.http.impl.nio.client.InternalIODispatch.onInputReady(InternalIODispatch.java:39)
        at org.apache.http.impl.nio.reactor.AbstractIODispatch.inputReady(AbstractIODispatch.java:114)
        at org.apache.http.impl.nio.reactor.BaseIOReactor.readable(BaseIOReactor.java:162)
        at org.apache.http.impl.nio.reactor.AbstractIOReactor.processEvent(AbstractIOReactor.java:337)
        at org.apache.http.impl.nio.reactor.AbstractIOReactor.processEvents(AbstractIOReactor.java:315)
        at org.apache.http.impl.nio.reactor.AbstractIOReactor.execute(AbstractIOReactor.java:276)
        at org.apache.http.impl.nio.reactor.BaseIOReactor.execute(BaseIOReactor.java:104)
        at org.apache.http.impl.nio.reactor.AbstractMultiworkerIOReactor$Worker.run(AbstractMultiworkerIOReactor.java:588)
        at java.lang.Thread.run(Thread.java:745)

结果分析：由于连接池大小是1,第一次请求执行后连接被占用(时间在100ms),第二次请求在规定的时间内无法获取连接,于是直接连接获取的TimeOutException。

修改ConnectionRequestTimeout=1000,上述两次请求正常执行。

注：如果要设置永不ConnectionRequestTimeout，只需要将ConnectionRequestTimeout设置为小于0即可。

2）连接池配置：

*  ConnTotal：连接池中最大连接数;
 *  ConnPerRoute(1000)：分配给同一个route(路由)最大的并发连接数,route为运行环境机器到目标机器的一条线路,举例来说,我们使用HttpClient的实现来分别请求 www.baidu.com 的资源和 www.bing.com 的资源那么他就会产生两个route;

对于上述的实验，在一定程度上也可以通过增大最大连接数来解决ConnectionRequestTimeout的问题！

参考：[https://juejin.im/post/5deb49be6fb9a01613801262][https_juejin.im_post_5deb49be6fb9a01613801262]

[https_juejin.im_post_5deb49be6fb9a01613801262]: https://juejin.im/post/5deb49be6fb9a01613801262