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

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

2. pom文件
本文依赖4.1.2,当前最新的客户端版本是4.1.3maven repository 地址

<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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
3. 简单的实例
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() {

}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
4. 几个重要的参数
4.1 TimeOut(3个)的设置

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

在实际项目开发过程中,这三个值可根据具体情况设置。

(1) 下面针对ConnectionRequestTimeout的情况进行分析

实验条件:设置连接池最大连接数为1,每一个异步请求从开始到回调的执行时间在100ms以上;

实验过程:连续发送2次请求

public class TestHttpClient {
public static void main(String[] args){

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(50000)
.setSocketTimeout(50000)
.setConnectionRequestTimeout(10)//设置为10ms
.build();

final CloseableHttpAsyncClient client = HttpAsyncClients.custom().
setConnectionManager(connManager)
.setDefaultRequestConfig(requestConfig)
.build();

//构造请求
String url = "http://127.0.0.1:9200/_bulk";
List<HttpPost> list = new ArrayList<HttpPost>();
for(int i=0;i<2;i++){
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);
list.add(httpPost);
}

client.start();

for(int i=0;i<2;i++){
client.execute(list.get(i), 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 failed(Exception e) {
e.printStackTrace();
System.err.println(" cost is:"+(System.currentTimeMillis()-start)+":"+e);
}

public void cancelled() {

}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
实验结果 :
第一次请求执行时间在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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
结果分析：由于连接池大小是1,第一次请求执行后连接被占用(时间在100ms),第二次请求在规定的时间内无法获取连接,于是直接连接获取的TimeOutException

(2) 修改ConnectionRequestTimeout

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(50000)
.setSocketTimeout(50000)
.setConnectionRequestTimeout(1000)//设置为1000ms
.build();
1
2
3
4
5
上述两次请求正常执行。

下面进一步看一下代码中抛异常的地方：

从上面的代码中可以看到如果要设置永不ConnectionRequestTimeout，只需要将ConnectionRequestTimeout设置为小于0即可,当然后这种设置一定要慎用, 如果处理不当,请求堆积会导致OOM。

4.2 连接池大小的设置

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

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

后续：本文重点在于使用，后续会对源码进行分析与解读

HttpAsyncClient 的简单使用

下载地址：http://hc.apache.org/downloads.cgi

在NetBeans中导入以下jar文件：

1：一次请求：

 public static void oneReuest(){

        final CloseableHttpAsyncClient httpClient = HttpAsyncClients.createDefault();

        httpClient.start();

        final HttpGet request = new HttpGet("http://www.apache.org/");

        final Future future = httpClient.execute(request, null);

        try {

            HttpResponse response = (HttpResponse) future.get();

            System.out.println("Response:" + response.getStatusLine());

            System.out.println("Shutting down");

        } catch (Exception ex) {

            Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);

        }finally{

            try {

                httpClient.close();

            } catch (IOException ex) {

                Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);

            }

        }

        System.out.println("执行完毕");

    }

2：多次异步请求：

 public static void moreRequest(){

        final RequestConfig requestConfitg = RequestConfig.custom()

                .setSocketTimeout(3000)

                .setConnectTimeout(3000).build();

        final CloseableHttpAsyncClient httpClient = HttpAsyncClients.custom()

                .setDefaultRequestConfig(requestConfitg)

                .build();

        httpClient.start();

        final HttpGet[] requests = new HttpGet[]{

            new HttpGet("http://www.apache.org/"),

            new HttpGet("http://www.baidu.com/"),

            new HttpGet("http://www.oschina.net/")

        };

        final CountDownLatch latch = new CountDownLatch(requests.length);

        for(final HttpGet request: requests){

                httpClient.execute(request, new FutureCallback(){

                    @Override

                    public void completed(Object obj) {

                       final HttpResponse response = (HttpResponse)obj;

                       latch.countDown();

                       System.out.println(request.getRequestLine() + "->" + response.getStatusLine());

                    }

                    @Override

                    public void failed(Exception excptn) {

                        latch.countDown();

                        System.out.println(request.getRequestLine() + "->" + excptn);

                    }

                    @Override

                    public void cancelled() {

                        latch.countDown();

                        System.out.println(request.getRequestLine() + "cancelled");

                    }

                });

         }       

        try {

            latch.await();

            System.out.println("Shutting Down");

        } catch (InterruptedException ex) {

            Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);

        }finally{

            try {

                httpClient.close();

            } catch (IOException ex) {

                Logger.getLogger(Httpasyncclient.class.getName()).log(Level.SEVERE, null, ex);

            }

        }

        System.out.println("Finish!");

    }

运行结果：

run:

GET http://www.baidu.com/ HTTP/1.1->HTTP/1.1 200 OK

GET http://www.oschina.net/ HTTP/1.1->HTTP/1.1 200 OK

GET http://www.apache.org/ HTTP/1.1->HTTP/1.1 200 OK

Shutting Down

Finish!

成功构建 (总时间: 2 秒)

可以看出是异步执行的！不是按照我们传入的URL参数顺序执行的！

篇提到了高性能处理的关键是异步，而我们当中许多人依旧在使用同步模式的HttpClient访问第三方Web资源，我认为原因之一是：异步的HttpClient诞生较晚，许多人不知道；另外也可能是大多数Web程序其实不在意这点性能损失了。

而要自己实现一个异步的HttpClient则比较困难，通常都是自己开一个新的工作线程，利用HttpClient的同步去访问，完成后再回调这种形式，这样做其实不是真正的异步，因为依旧会有一个线程处于阻塞中，等待着第三方Web资源的返回。

而如今访问第三方Web资源的情景越来越多，最典型就是使用第三方登录平台，如QQ或微信等，我们需要访问腾讯的服务器去验证登录者的身份，根据我的经验，这个过程可能会阻塞好几秒钟，可看作是一个“长时间调用”，所以最好要使用异步方式。

OK，废话少说，要使用异步的HttpClient，请Maven中带上：

        <dependency>

            <groupId>org.apache.httpcomponents</groupId>

            <artifactId>httpasyncclient</artifactId>

            <version>4.1.1</version>

        </dependency>

接下来是一个完整的Demo代码：

import org.apache.http.HttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.concurrent.FutureCallback;

import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;

import org.apache.http.impl.nio.client.HttpAsyncClients;

import org.apache.http.util.EntityUtils;

import java.io.IOException;

import java.util.concurrent.CountDownLatch;

public class Main {

    public static void main(String[] argv) {

        CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault();

        httpclient.start();

        final CountDownLatch latch = new CountDownLatch(1);

        final HttpGet request = new HttpGet("https://www.alipay.com/");

        System.out.println(" caller thread id is : " + Thread.currentThread().getId());

        httpclient.execute(request, new FutureCallback<HttpResponse>() {

            public void completed(final HttpResponse response) {

                latch.countDown();

                System.out.println(" callback thread id is : " + Thread.currentThread().getId());

                System.out.println(request.getRequestLine() + "->" + response.getStatusLine());

                try {

                    String content = EntityUtils.toString(response.getEntity(), "UTF-8");

                    System.out.println(" response content is : " + content);

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            public void failed(final Exception ex) {

                latch.countDown();

                System.out.println(request.getRequestLine() + "->" + ex);

                System.out.println(" callback thread id is : " + Thread.currentThread().getId());

            }

            public void cancelled() {

                latch.countDown();

                System.out.println(request.getRequestLine() + " cancelled");

                System.out.println(" callback thread id is : " + Thread.currentThread().getId());

            }

        });

        try {

            latch.await();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        try {

            httpclient.close();

        } catch (IOException ignore) {

        }

    }

}

呃……代码很简单，好像也没什么好说的了，稍作封装就可以实现如“getJson()”这样的方法。

也许你还注意到了，这个HttpClient跟同步的版本一样，直接支持https，但如果网站的证书是自签的，默认还是不行的，解决方法当然有，但代码有些麻烦，我觉得还不如直接买张证书来得简单，如果网站是你管的话。

参考：Java的异步HttpClient

参考：HttpAsyncClient 的简单使用

异步httpclient(httpasyncclient)的使用与总结的更多相关文章

异步HttpClient大量请求
由于项目中有用到HttpClient异步发送大量http请求,所以做已记录思路:使用HttpClient连接池,多线程 public class HttpAsyncClient { private ...
android 学习随笔十二（网络：使用异步HttpClient框架）
使用异步HttpClient框架发送get.post请求在https://github.com/ 搜索 asyn-http https://github.com/search?utf8=✓& ...
使用异步httpclient框架做get，post提交数据
1.将异步httpclient框架导入下载地址:http://download.csdn.net/detail/sinat_32804317/9555641 2.代码实现 public class ...
Java的异步HttpClient
上篇提到了高性能处理的关键是异步,而我们当中许多人依旧在使用同步模式的HttpClient访问第三方Web资源,我认为原因之一是:异步的HttpClient诞生较晚,许多人不知道:另外也可能是大多数W ...
httpClient 深入浅出~
本文偏重使用,简单讲述httpclient,其实在网络编程中,基于java的实现几乎都是包装了socket的通信,然后来模拟各种各样的协议:httpclient其实就是模拟浏览器发起想服务器端的请求, ...
[转]Tornado get/post请求异步处理框架分析
转自: http://m.blog.csdn.net/blog/joeyon/41956027 首先说下环境,python2.7,Tornado3.0 然后本文讨论的不是Tornado底层如何用epo ...
flink---实时项目----day03---1.练习讲解（全局参数，数据以parquet格式写入hdfs中） 2 异步查询 3 BroadcastState
1 练习讲解(此处自己没跑通,以后debug) 题目见flink---实时项目---day02 kafka中的数据,见day02的文档 GeoUtils package cn._51doit.flin ...
用IntelliJ IDEA创建Gradle项目简单入门
Gradle和Maven一样,是Java用得最多的构建工具之一,在Maven之前,解决jar包引用的问题真是令人抓狂,有了Maven后日子就好过起来了,而现在又有了Gradle,Maven有的功能它都 ...
【转】异步的AsyncHttpClient使用详解
http://blog.csdn.net/angjunqiang/article/details/55259170 背景前面的一篇文章[同步的HttpClient使用详解]中,提到了服务端通进行网络 ...

随机推荐

php实现TXT小说章节解析、小说章节在线阅读
每天学习一点点编程PDF电子书.视频教程免费下载:http://www.shitanlife.com/code 要实现TXT文本章节的解析,大概思路是在每个章节加入了特定的字符,然后根据字符的起始位 ...
ESP32入门示例 - SD卡Web服务器
这个是来自ESP32官方示例的改版,官方的示例由于存在一些问题所以我进行了修改原本的示例有点逻辑上的问题,所以进行了一些修改主要修改有:1.新增SD卡测试部分复制自官方SD卡示例2.新增一个根目录 ...
SSH远程SOLARIS11时被拒绝
在虚拟机中新安装的solaris11,安装过程中配置了静态IP地址用以方便ssh连接,使用root用户ssh连接时,密码没有错,但总是提示密码被拒绝,连接established 代表是通的,telne ...
Linux 系统负载查询及分析说明
Linux 系统出现死机或卡顿时,可以参阅如下步骤进行整体排查: 检查服务器进程与服务否占用了过多内存,或者内存没有正常释放,导致出现内存溢出,系统宕机. 检查 /var/spool/cron 等系统 ...
mybatis错误之org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
玩了MyBatis差不多有两年了,中间也玩过MyBatis-Plus,这个MyBatis-Plus其实与MyBatis的区别并不大.今天写博客业务代码的时候,犯一个初学者犯过的错误. 错误信息如下:o ...
【mongoDB查询进阶】聚合管道(一) -- 初识
https://segmentfault.com/a/1190000010618355 前言:一般查询可以通过find方法,但如果是比较复杂的查询或者数据统计的话,find可能就无能为力了,这时也许你 ...
Java多线程（七）——线程休眠
一.sleep()介绍 sleep() 定义在Thread.java中.sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”.sleep()会指定休眠时间,线程 ...
Mybatis学习总结（八）——延迟加载
一.什么是延迟加载 resultMap可以实现高级映射(使用association.collection实现一对一及一对多映射),association.collection具备延迟加载功能. 需求: ...
面试 5：手写 Java 的 pow() 实现
我们在处理一道编程面试题的时候,通常除了注意代码规范以外,千万要记得自己心中模拟一个单元测试.主要通过三方面来处理. 功能性测试边界值测试负面性测试不管如何,一定要保证自己代码考虑的全面,而不要 ...
每秒高达1.6亿次操作的并发键值存储库 FASTER 诞生
FASTER 在过去十年中,云中的数据密集型应用程序和服务有了巨大的增长.数据在各种边设施(例如,设备,浏览器和服务器)上创建,并由云应用程序处理用来获得数据价值或做出决策.应用程序和服务可以处理收集 ...

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

HttpAsyncClient 的简单使用

异步httpclient(httpasyncclient)的使用与总结的更多相关文章

随机推荐

热门专题