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

原创

a772304419 2022-09-10 00:22:15 ©著作权

文章标签 java websocket http ide post请求 文章分类 运维

©著作权归作者所有：来自51CTO博客作者a772304419的原创作品，请联系作者获取转载授权，否则将追究法律责任

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