AsyncHttpClient使用示例：java http异步请求和websocket客户端

妖狐艹你老母 2023-09-27 09:01 143阅读 0赞

> [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.

## maven依赖 ##

<dependency>
        <groupId>com.ning</groupId>
        <artifactId>async-http-client</artifactId>
        <version>1.9.39</version>
    </dependency>

## 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();
    }

### 在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();
    }

## 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();
    }

### 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);

## 最佳实践 ##

### 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;
        }
    }

### 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;
        }
    }

### 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;
        }
    }

--------------------

参考资料

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

[https://github.com/AsyncHttpClient/async-http-client/tree/1.7.x][https_github.com_AsyncHttpClient_async-http-client_tree_1.7.x]

[AsyncHttpClient]: https://github.com/AsyncHttpClient/async-http-client
[https_github.com_AsyncHttpClient_async-http-client_tree_1.7.x]: https://github.com/AsyncHttpClient/async-http-client/tree/1.7.x