AsyncHttpClient使用

 

github地址：AsyncHttpClient，

API：API

1.X和2.X差別很大，我用的1.X中的最新版 1.9.39。

這是一個異步請求的工具，越簡單越好，不喜歡再結合netty使用。AsyncHttpClient底層使用java線程池

this.applicationThreadPool = Executors.newCachedThreadPool(new ThreadFactory() {
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, "AsyncHttpClient-Callback");
 t.setDaemon(true);
        return t;
    }
});

這樣的線程池最大線程數沒有限制（Integer.MAX_VALUE），就知道開開開線程，在某種情況下會很容易搞垮我們的系統，所以在下面的單例類中做了限制

configBuilder.setMaxConnections(2);

限制提交的數量。可以看出線程池中的線程是daemon的，當所有非daemon線程退出后jvm將退出！！！

 

 

寫了個單例類，供參考

import com.ning.http.client.*;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;

/**
 * Created by yhzh on 2016/9/19.
 */
public class MlsAsyncHttpClient {
    private AsyncHttpClient client;

    private static class HttpClientHolder{
        private static MlsAsyncHttpClient httpClient=new MlsAsyncHttpClient();
    }

    private MlsAsyncHttpClient(){
        AsyncHttpClientConfig.Builder configBuilder=new AsyncHttpClientConfig.Builder();
        configBuilder.setMaxConnections(2);
        /*使用默認值：
        configBuilder.setConnectTimeout(3000);
        configBuilder.setReadTimeout(5000);*/
        configBuilder.setRequestTimeout(60000);
        this.client=new AsyncHttpClient(configBuilder.build());
    }

    public static MlsAsyncHttpClient getAsyncHttpClient(){
        return HttpClientHolder.httpClient;
    }

    public Future<Response> get(String url) {
        return this.client.prepareGet(url).execute();
    }

    public void get(String url, AsyncHandler resHandler) {
        this.client.prepareGet(url).execute(resHandler);
    }

    public Future<Response> post(String url) {
        return this.client.preparePost(url).execute();
    }

    public void post(String url,AsyncHandler resHandler) {
        this.client.preparePost(url).execute(resHandler);
    }

    private Request buildRequest(String url, Map<String,String> paramsMap){
        RequestBuilder requestBuilder = new RequestBuilder();
        if(paramsMap != null && paramsMap.size() > 0) {
            Set<Map.Entry<String, String>> entrySet = paramsMap.entrySet();
            Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
            while(iterator.hasNext()) {
                Map.Entry<String, String> entry = iterator.next();
                if(entry.getKey() != null) {
                    requestBuilder.addFormParam(entry.getKey(), entry.getValue());
                }
            }
        }
        // 添加RequestHeader，key
        requestBuilder.addHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
        requestBuilder.setMethod("POST");
        requestBuilder.setUrl(url);

        return requestBuilder.build();
    }

    public Future<Response> post(String url, Map<String,String> paramsMap) {
        Request req=this.buildRequest(url,paramsMap);

        return this.client.executeRequest(req);
    }

    public void post(String url, Map<String,String> paramsMap, AsyncHandler resHandler) {
        Request req=this.buildRequest(url,paramsMap);

        this.client.executeRequest(req,resHandler);
        //this.client.preparePost(url).execute(responseHandler);
    }
}

 

測試代碼

@Test
    public void testSelectLoanResultOfLoanResultsOfZgController() throws InterruptedException {
        CountDownLatch completionLatch = new CountDownLatch(2);
        //com.ning.http.client.providers.netty.NettyAsyncHttpProvider
        MlsAsyncHttpClient.getAsyncHttpClient().get("http://127.0.0.1:8081/assetmgmt/ploanouter/repayplan?lrid=0",new AsyncHandler() {
            private ByteArrayOutputStream bytes = new ByteArrayOutputStream();
            boolean done=false;
            @Override
            public STATE onStatusReceived(HttpResponseStatus status) throws Exception {
                int statusCode = status.getStatusCode();
                if (statusCode >= 500) {
                    return STATE.ABORT;
                }
                return STATE.CONTINUE;
            }

            @Override
            public STATE onHeadersReceived(HttpResponseHeaders httpResponseHeaders) throws Exception {
                FluentCaseInsensitiveStringsMap str=httpResponseHeaders.getHeaders();
                return STATE.CONTINUE;
            }

            @Override
            public STATE onBodyPartReceived(HttpResponseBodyPart httpResponseBodyPart) throws Exception {
                bytes.write(httpResponseBodyPart.getBodyPartBytes());
                return STATE.CONTINUE;
            }

            @Override
            public Object onCompleted() throws Exception {
                String str=bytes.toString("utf-8");
                System.out.println("get baidu:");
                completionLatch.countDown();
                return null;
            }

            @Override
            public void onThrowable(Throwable t){
                if(!done){
                    completionLatch.countDown();
                    done=true;
                }
                System.out.println("get exception:"+t.getMessage());
            }
        });

        Map<String,String> m=new HashMap<String,String>();
        m.put("lrid","-1");
        MlsAsyncHttpClient.getAsyncHttpClient().post("http://127.0.0.1:8080/assetmgmt/ploanouter/repayplan",m,new AsyncCompletionHandler() {
            boolean done=false;
            @Override
            public Object onCompleted(Response response) throws Exception {
                String str=response.getResponseBody();
                String name=Thread.currentThread().getName();
                boolean daemon=Thread.currentThread().isDaemon();
                System.out.println("post baidu:");
                completionLatch.countDown();
                return null;
            }

            @Override
            public void onThrowable(Throwable t){
                if(!done){
                    completionLatch.countDown();
                    done=true;
                }
                System.out.println("post exception:"+t.getMessage());
            }
        });

        completionLatch.await();
        System.out.println("異步請求結束！！！");
    }

正如一開始所說（當所有非daemon線程退出后jvm將退出），所以我加了個CountDownLatch，在每個請求可以結束的地方

completionLatch.countDown();

最后

completionLatch.await();

完成退出。

其實如果允許請求無限等待，這樣還是有可能導致程序阻塞在await這，可以使用

await(long timeout, TimeUnit unit)

設置時間等待，這個時候請求的響應可能會丟失（參數設置等問題），所以我設置了等待響應的時間

configBuilder.setRequestTimeout(60000);

什么東西還是明確的好，各種參數都要經過調試才能確定

 

 

 

參考文章：

1. java之httpClient 3.x、AsyncHttpClient1.9.x使用總結

2. Async Http Client：異步HTTP和WebSocket客戶端