android-async-http 封装

概要

在 2013年之前这个网络请求库还是不错！随着技术的更新，这个逐渐被放弃使用！接近年关，更多的是闲暇无事，看到老项目中在使用网络请求并没有为此做二次封装，在接口回调当中写下了很多Json解析等其他的逻辑为此，简单的封装了改网络请求！并统一的管理Gson数据的处理。

介绍

• 本示例Demo 封装了get/post（文件上传）等等····
• 统一的异常管理
• 虽然说 android-async-http 这个网络请求库，本人已经不再使用了，但是可以学习当中
  的设计思想和编码规范。为此做出封装。
• 针对这个框架的思想，自己做的请求框架，可以参考了解。地址：https://github.com/wanglyGithub/AsynHttpClient

层次结构

AsyncHttpUtils 代码

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.loopj.android.http.AsyncHttpClient;
import com.loopj.android.http.AsyncHttpResponseHandler;
import com.loopj.android.http.RequestParams;

import java.util.Map;

import cz.msebera.android.httpclient.Header;

public class AsyncHttpUtils {
    private static AsyncHttpUtils instance;
    private AsyncHttpClient httpClient;
    private RequestParams requestParams;
    private static final int TIME_OUT = 1000;
    private static final int MAX_CONNECT_TIME = 1000;
    private final Gson gson;

    private AsyncHttpUtils() {
        httpClient = new AsyncHttpClient();
        httpClient.setTimeout(TIME_OUT);
        httpClient.setMaxConnections(MAX_CONNECT_TIME);

        gson = new Gson();


    }

    public static AsyncHttpUtils getInstance() {
        if (instance == null) {
            instance = new AsyncHttpUtils();
        }
        return instance;
    }

    /**
     * GET
     *
     * @param url
     * @param callBack
     */
    public void get(String url, ResultCallBack callBack) {
        httpClient.get(url, new HttpResponseHandler(callBack));

    }

    /**
     * GET
     *
     * @param url
     * @param params
     * @param callback
     */
    public void get(String url, Map<String, Object> params, ResultCallBack callback) {
        RequestParams requestParams = doRequestParams(params);
        httpClient.get(url, requestParams, new HttpResponseHandler(callback));
    }


    /**
     * POST
     *
     * @param url
     * @param params
     * @param callback
     */
    public void post(String url, Map<String, Object> params, final ResultCallBack callback) {
        RequestParams requestParams = doRequestParams(params);
        httpClient.post(url, requestParams, new HttpResponseHandler(callback));

    }


    public RequestParams doRequestParams(Map<String, Object> params) {
        requestParams = new RequestParams();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            requestParams.put(entry.getKey(), entry.getValue());
        }
        return requestParams;
    }


    // exectue AsyncHttpClient
    class HttpResponseHandler extends AsyncHttpResponseHandler {
        private ResultCallBack callBack;

        public HttpResponseHandler(ResultCallBack back) {
            this.callBack = back;

        }

        @Override
        public void onStart() {
            super.onStart();
            if (callBack != null) {
                callBack.onStart();
            }
        }

        @Override
        public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
            if (statusCode == 200) {
                String result = new String(responseBody);
                if (!"".equals(result) && null != result) {
                    if (result.startsWith("\uFEFF")) {
                        result = result.substring(1, result.length());
                    }

                    if (callBack.mType == String.class) {
                        doSuccess(callBack, statusCode, result);
                    } else {
                        try {
                            Object object = gson.fromJson(result, callBack.mType);
                            if (callBack != null) {
                                doSuccess(callBack, statusCode, object);
                            }
                        } catch (JsonSyntaxException e) {
                            e.printStackTrace();
                            ApiException.getApiExceptionMessage(e.getCause());
                        }

                    }
                }

            }
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
            doFailed(callBack, statusCode, error);
        }
    }


    public void doSuccess(ResultCallBack callBack, int stateCode, Object object) {
        if (callBack != null) {
            callBack.Success(stateCode, object);
        }
    }

    public void doFailed(ResultCallBack callBack, int errorCode, Throwable throwable) {
        if (callBack != null) {
            callBack.Failure(errorCode, ApiException.getApiExceptionMessage(throwable));
        }
    }


    // 其他类型，不在封装，
    // 如：追踪源码可知:JsonHttpResponseHandler 是 AsyncHttpResponseHandler 的子类
    // 所以可以共用 同一个，但是需要进行转型
    //以下提供了枚举类型，可供参考，封装

    enum OtherType {
        down_json,
        down_byte
    }

}

ApiException 异常管理

import com.google.gson.JsonParseException;

import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;

import cz.msebera.android.httpclient.client.HttpResponseException;

/**
 *
 * @description 描述: 异常管理类
 */

public class ApiException {
    public static final String NET_WORK_ERROR = "网络不可用";
    public static final String CONNECT_EXCEPTION = "网络不给力，请稍后重试";
    public static final String SERVER_ADDRES_ERROR = "URL 地址有误！";
    public static final String JSON_PARSE_ERROR = "Json 解析出错";

    public static String getApiExceptionMessage(Throwable throwable) {
        if (throwable instanceof UnknownHostException || throwable instanceof ConnectException) {
            return NET_WORK_ERROR;
        } else if (throwable instanceof SocketTimeoutException) {
            return CONNECT_EXCEPTION;
        } else if (throwable instanceof HttpResponseException) {
            return SERVER_ADDRES_ERROR;
        } else if (throwable instanceof JsonParseException) {
            return JSON_PARSE_ERROR;
        } else {
            return "未知错误";
        }
    }
}

ResultCallBack

import com.google.gson.internal.$Gson$Types;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public abstract class ResultCallBack<T> {

    public Type mType;

    static Type getSuperclassTypeParameter(Class<?> subclass) {
        Type superclass = subclass.getGenericSuperclass();
        if (superclass instanceof Class) {
            throw new RuntimeException("Missing type parameter.");
        }
        ParameterizedType parameterized = (ParameterizedType) superclass;
        return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
    }


    public ResultCallBack () {
        mType = getSuperclassTypeParameter(getClass());
    }

    public abstract void onStart();

    public abstract void Success(int statusCode, T t);

    public abstract void Failure(int errorCode, String exception);

}

最后演示：