用谷歌的AsyncHttpClient简单模仿安卓的AsyncHttpClient，实现异步请求回调函数返回值

AsyncHttpClient解决异步问题之前的版本
AsyncHttpClient异步请求工具箱/简单使用(异步的同步支持)

实现思路

既然要调用Future.get() 才能激发访问，那么就想到了使用一个线程去访问。我们就不需要等待阻塞了。
模仿安卓的AsyncHttpClient回调。根据状态回调不同的函数。

实现的效果

    执行代码...
    异步请求..不需要等待返回的结果，继续执行下面的代码
    执行代码...

AsyncHttpClient 主工具类

import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.ning.http.client.AsyncHttpClient;
import com.ning.http.client.Response;

/**
 * AsyncHttpClient请求工具箱
 * 
 * @author Zq
 *
 */
public class AsyncHttpKit {
    private AsyncHttpKit() {
    };
    /** 默认编码 **/
    private static final String DEFAULT_CHARSET = "UTF-8";
    /** 异步请求对象 **/
    private static AsyncHttpClient http = new AsyncHttpClient();
    /** 缓存线程池 **/
    private static ExecutorService pool = Executors.newCachedThreadPool();

    /**
     * 
     * @param url 访问链接,但是请注意，接收的url 必须符合URI协议，否则抛出异常
     * @param params 参数，其中不能有为null的参数值
     * @param handler 异步回调辅助类
     */
    public static void post(String url, Map<String, String> params,AsyncHttpResponseHandler handler){
        handler.setFuture(post(url, params));
        pool.execute(handler);
    }


    /**
     * 异步Post请求
     * 
     * @param http
     * @param url
     * @param params
     *            请求参数
     * @return
     */
    private static Future<Response> post(String url, Map<String, String> params) {
        AsyncHttpClient.BoundRequestBuilder builder = http.preparePost(url);
        builder.setBodyEncoding(DEFAULT_CHARSET);
        if (params != null && !params.isEmpty()) {
            Set<String> keys = params.keySet();
            for (String key : keys) {
                builder.addParameter(key, params.get(key));
            }
        }
        Future<Response> f = null;
        try {
            f = builder.execute();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return f;
    }

    /**
     * 异步post请求
     * @param url 请求地址
     * @param s 参数为 json串 {xx:xx,...}
     * @param handler
     */
    public static void post(String url,String s,AsyncHttpResponseHandler handler){
        handler.setFuture(post(url, s));
        pool.execute(handler);
    }

    /**
     * 异步POST请求
     * 
     * @param http
     * @param url
     * @param s
     *            json串
     * @return
     */
    private static Future<Response> post(String url, String s) {
        AsyncHttpClient.BoundRequestBuilder builder = http.preparePost(url);
        builder.setBodyEncoding(DEFAULT_CHARSET);
        builder.setBody(s);
        Future<Response> f = null;
        try {
            f = builder.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return f;
    }
}

辅助类，模仿安卓的AsyncHttpResponseHandler

安卓的异步请求
<dependency>  
    <groupId>com.loopj.android</groupId>  
    <artifactId>android-async-http</artifactId>  
    <version>1.4.5</version>  
</dependency>  

import java.util.concurrent.Future;

import com.ning.http.client.Response;

/**
 * 异步请求辅助类
 * @author Zq
 *
 */
public abstract class AsyncHttpResponseHandler implements Runnable {
    private Future<Response> future = null;

    @Override
    public void run() {
        int statusCode = 0;
        try {
            Response response = future.get(/*timout, TimeUnit.SECONDS*/);
            statusCode = response.getStatusCode();
            String responseBody = response.getResponseBody("UTF-8");
            if (statusCode == 200) { //只有200状态调用成功方法
                this.onSuccess(statusCode, responseBody);
            } else { //其他状态调用失败方法
                this.onFailure(statusCode, responseBody,null);
            }
        } catch (InterruptedException e) { //请求过程中出现错误，请求状态变成0，调用失败的方法
            this.onFailure(0, null, e);
        } catch (ExecutionException e) {
            this.onFailure(0, null, e);
        } catch (IOException e) {
            this.onFailure(statusCode, null, e);
        }
        /**
         * 上面的处理过程，需要子类实现者手动的try掉onFailure和 onSuccess中的所有异常，否则会出现调用结果不准确的现象
         */
    }


    /**
     * 请求成功：回调函数
     * 
     * @param status
     *            状态码 200
     * @param body
     *            返回结果
     */
    public abstract void onSuccess(int status, String body);

    /**
     * 请求失败回调函数
     * 
     * @param status
     *            除了200意外的所有状态码；如果返回0 请求的时候发生了异常，throwable属性有值
     * @param body
     *            返回的结果
     * @param throwable
     *            抛出错误异常
     */
    public abstract void onFailure(int status, String body, Throwable throwable);

    public Future<Response> getFuture() {
        return future;
    }

    public void setFuture(Future<Response> future) {
        this.future = future;
    }
}