AsyncHttpClient使用示例：java http异步请求和websocket客户端_com.ning async-http-client

AsyncHttpClient是一款开源的Java异步Http和WebSocket 客户端。

文档原文

Asynchronous Http and WebSocket Client library for Java
Async Http Client library purpose is to allow Java applications to easily execute HTTP requests and asynchronously process the HTTP responses. The library also supports the WebSocket Protocol. The Async HTTP Client library is simple to use.
1
2

maven依赖

<dependency>
    <groupId>com.ning</groupId>
    <artifactId>async-http-client</artifactId>
    <version>1.9.39</version>
</dependency>
1
2
3
4
5

get请求

import com.ning.http.client.*;
import java.util.concurrent.Future;    

public String get(String url){
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Future<Response> f = asyncHttpClient.prepareGet(url).execute();
    Response r = f.get();
    return r.getResponseBody();
}
1
2
3
4
5
6
7
8
9

在handler中接、处理response

public String get(String url){
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Future<Response> f = asyncHttpClient.prepareGet(url).execute(new AsyncCompletionHandler<Response>(){

        @Override
        public Response onCompleted(Response response) throws Exception{
            // Do something with the Response
            // ...
            return response;
        }

        @Override
        public void onThrowable(Throwable t){
            // Something wrong happened.
        }
    });
    Response r = f.get();
    return r.getResponseBody();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

post请求

public String post(String url, List<FormParam> params){
    List<Param> formparams = new ArrayList<Param>();
    for(FormParam param : params){
        formparams.add(new Param(param.getName(), param.getValue()));
    }
    AsyncHttpClient asyncHttpClient = new AsyncHttpClient();
    Future<Response> f = asyncHttpClient.preparePost(url).setFormParams(formparams).execute();
    Response r = f.get();
    return r.getResponseBody();
}
1
2
3
4
5
6
7
8
9
10

configure AsyncHttpClient

AsyncHttpClientConfig cf = new AsyncHttpClientConfig.Builder()
        .setProxyServer(new ProxyServer("127.0.0.1", 38080))
        .setConnectTimeout(6000)
        .setReadTimeout(6000)
        .setMaxConnections(200)
        .setMaxConnectionsPerHost(50)
        .build();
AsyncHttpClient asyncHttpClient = new AsyncHttpClient(cf);
1
2
3
4
5
6
7
8

最佳实践

AsyncHttpClientImpl类

package com.bytebeats.toolkit.http.impl;

import com.bytebeats.toolkit.annotation.ThreadSafe;
import com.bytebeats.toolkit.http.HttpRequestException;
import com.bytebeats.toolkit.http.config.FormParam;
import com.bytebeats.toolkit.http.config.HttpRequestConfig;
import com.ning.http.client.AsyncHttpClient;
import com.ning.http.client.AsyncHttpClientConfig;
import com.ning.http.client.Param;
import com.ning.http.client.Response;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * AsyncHttpClient 实现
 * https://github.com/AsyncHttpClient/async-http-client/tree/1.9.x
 *
 */
@ThreadSafe
public class AsyncHttpClientImpl extends HttpClient {

    private AsyncHttpClient asyncHttpClient;

    public AsyncHttpClientImpl(HttpRequestConfig config) {
        super(config);
        AsyncHttpClientConfig cf = new AsyncHttpClientConfig.Builder()
                //.setProxyServer(new ProxyServer("127.0.0.1", 38080))
                .setConnectTimeout(this.config.getConnectTimeout())
                .setReadTimeout(this.config.getReadTimeout())
                .setMaxConnections(this.config.getMaxConnections())
                .setMaxConnectionsPerHost(this.config.getMaxConnectionPerHost())
                .build();
        asyncHttpClient = new AsyncHttpClient(cf);
    }

    @Override
    public String get(String url) throws HttpRequestException {
        try {
            Response r = prepareGet(asyncHttpClient, url);
            return r.getResponseBody();
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient get error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient get error", e);
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient get error", e);
        }
    }

    @Override
    public byte[] getBytes(String url) throws HttpRequestException {
        try {
            Response r = prepareGet(asyncHttpClient, url);
            return r.getResponseBodyAsBytes();
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient getBytes error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient getBytes error", e);
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient getBytes error", e);
        }
    }

    @Override
    public String postWithForm(String url, List<FormParam> params) throws HttpRequestException {
        try {
            Response r = preparePostForm(url, params);
            return r.getResponseBody();
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient postWithForm error", e);
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient postWithForm error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient postWithForm error", e);
        }
    }

    @Override
    public byte[] postWithFormBytes(String url, List<FormParam> params) throws HttpRequestException {
        try {
            Response r = preparePostForm(url, params);
            return r.getResponseBodyAsBytes();
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient postWithFormBytes error", e);
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient postWithFormBytes error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient postWithFormBytes error", e);
        }
    }

    @Override
    public String postWithBody(String url, String data) throws HttpRequestException {
        try {
            Response r = preparePostBody(url, data);
            return r.getResponseBody();
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBody error", e);
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBody error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBody error", e);
        }
    }

    @Override
    public byte[] postWithBodyBytes(String url, String data) throws HttpRequestException {
        try {
            Response r = preparePostBody(url, data);
            return r.getResponseBodyAsBytes();
        } catch (IOException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBodyBytes error", e);
        } catch (InterruptedException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBodyBytes error", e);
        } catch (ExecutionException e) {
            throw new HttpRequestException("AsyncHttpClient postWithBodyBytes error", e);
        }
    }

    public Response preparePostBody(String url, String data) throws ExecutionException, InterruptedException {
        Future<Response> f = asyncHttpClient.preparePost(url).setBody(data).addHeader("Content-type", "application/json").execute();
        return f.get();
    }

    public Response preparePostForm(String url, List<FormParam> params) throws ExecutionException, InterruptedException {
        List<Param> formparams = new ArrayList<Param>();
        for(FormParam param : params){
            formparams.add(new Param(param.getName(), param.getValue()));
        }
        Future<Response> f = asyncHttpClient.preparePost(url).setFormParams(formparams).execute();
        return f.get();
    }

    public Response prepareGet(AsyncHttpClient asyncHttpClient, String url) throws ExecutionException, InterruptedException {
        Future<Response> f = asyncHttpClient.prepareGet(url).execute();
        Response r = f.get();
        return r;
    }
}
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

FormParam 类

package com.bytebeats.toolkit.http.config;

public class FormParam {
    private final String name;
    private final String value;

    public FormParam(String name, String value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public String getValue() {
        return this.value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

HttpRequestConfig类

package com.bytebeats.toolkit.http.config;

/**
 * ${DESCRIPTION}
 *
 * @author Ricky Fung
 * @create 2016-08-24 19:06
 */
public class HttpRequestConfig {

    public static final HttpRequestConfig DEFAULT = new HttpRequestConfig();

    private int readTimeout = 6000;
    private int socketTimeout = 6000;
    private int connectTimeout = 6000;
    private int connectionRequestTimeout = 6000;

    private int maxConnections = 200;
    private int maxConnectionPerHost = 50;

    private boolean requestRetryEnabled;
    private boolean retryCount;

    //代理服务器
    private HttpHost proxy;

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    public int getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public int getConnectionRequestTimeout() {
        return connectionRequestTimeout;
    }

    public void setConnectionRequestTimeout(int connectionRequestTimeout) {
        this.connectionRequestTimeout = connectionRequestTimeout;
    }

    public int getMaxConnectionPerHost() {
        return maxConnectionPerHost;
    }

    public void setMaxConnectionPerHost(int maxConnectionPerHost) {
        this.maxConnectionPerHost = maxConnectionPerHost;
    }

    public boolean isRequestRetryEnabled() {
        return requestRetryEnabled;
    }

    public void setRequestRetryEnabled(boolean requestRetryEnabled) {
        this.requestRetryEnabled = requestRetryEnabled;
    }

    public boolean isRetryCount() {
        return retryCount;
    }

    public void setRetryCount(boolean retryCount) {
        this.retryCount = retryCount;
    }

    public int getMaxConnections() {
        return maxConnections;
    }

    public void setMaxConnections(int maxConnections) {
        this.maxConnections = maxConnections;
    }

    public HttpHost getProxy() {
        return proxy;
    }

    public void setProxy(HttpHost proxy) {
        this.proxy = proxy;
    }
}
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
89
90
91
92
93
94
95
96
97
98

---

参考资料

https://github.com/AsyncHttpClient/async-http-client

https://github.com/AsyncHttpClient/async-http-client/tree/1.7.x