从async-http转战OkHttp

2019独角兽企业重金招聘Python工程师标准>>>

项目以前用的是async-http，做过二次封装，一直沿用，但是已经落伍很久了，现在花点时间，从底部分装迁移到OkHttp.

最早期的代码大概如下：

private static AsyncHttpClient client = new AsyncHttpClient();

    private static String tempCacheDictionary = "temp";

    /**
     * @param actionUrl 请求地址
     * @param params    请求参数
     * @param Method    请求类型
     * @param headers   请求头
     * @param response  回调方法
     */

    public static RequestHandle loadContent(String actionUrl, RequestParams params, String Method, Map<String, Object> headers, AsyncHttpResponseHandler response, Context context) {
        Log.e("actionUrl", "--------------------------------->"+actionUrl);
        RequestHeader[] headersArray = new RequestHeader[0];
        try {
            headersArray = new RequestHeader[headers.entrySet().size()];

            int i = 0;
            for (Map.Entry<String, Object> header : headers.entrySet()) {
                headersArray[i] = new HaoHttpClient().new RequestHeader();
                headersArray[i].setName(header.getKey());
                if (header.getValue() == null) {
                    headersArray[i].setValue("");
                } else {
                    headersArray[i].setValue("" + header.getValue());
                }
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        client.setTimeout(30000);
        if (Method == null || Method.equals("get")) {
            return client.get(context, actionUrl, headersArray, params, response);
        } else {
            return client.post(context, actionUrl, headersArray, params, null, response);
        }
    }

 

迁移操作一、新建一个OkHttpHelper，替代之前的Helper.

扩展后的代码：

 /**
     * 添加请求头信息
     *
     * @param requestBuilder
     * @param headerParams
     */
    private static void addHeadlers(Request.Builder requestBuilder, Map<String, Object> headerParams) {
        Headers.Builder headersBuilder = new Headers.Builder();
        for (Map.Entry<String, Object> header : headerParams.entrySet()) {
            headersBuilder.add(header.getKey(), header.getValue() == null ? "" : (header.getValue() + ""));
        }
        requestBuilder.headers(headersBuilder.build());
    }

/**
     * okHttp get异步请求
     *
     * @param actionUrl 接口地址
     * @param paramsMap 请求参数
     * @param callBack  请求返回数据回调
     * @param <T>       数据泛型
     * @return
     */
    public <T> Call doGetAsync(Request.Builder requestBuilder, String actionUrl, Map<String, Object> paramsMap, final ReqCallBack<T> callBack) {
        try {

            String requestUrl = getUrlWithQueryString(actionUrl, paramsMap);
            requestBuilder.url(requestUrl);

            final Call call = client.newCall(requestBuilder.build());
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    failedCallBack(null, "请求失败", callBack);
                    Log.e(TAG, e.toString());
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    responseCallBack(response, callBack);
                }
            });
            return call;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return null;
    }

    /**
     * okHttp post异步请求
     *
     * @param paramsMap 请求参数
     * @param callBack  请求返回数据回调
     * @param <T>       数据泛型
     * @return
     */
    public <T> Call doPostByAsyn(Request.Builder requestBuilder, Map<String, Object> paramsMap, final ReqCallBack<T> callBack) {
        try {

            FormBody.Builder formBuilder = new FormBody.Builder();
            for (String key : paramsMap.keySet()) {
                formBuilder.add(key, paramsMap.get(key) + "");
            }

           /* json提交
           Gson gson = new GsonBuilder().enableComplexMapKeySerialization()
                    .create();
            String paramJson = gson.toJson(paramsMap);
           RequestBody requestBody = RequestBody.create(JSON, paramJson);
            requestBuilder.post(requestBody).build();*/

            //form提交
            RequestBody formBody = formBuilder.build();
            requestBuilder.post(formBody);

            final Call call = client.newCall(requestBuilder.build());
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    failedCallBack(null, "请求失败", callBack);
                    Log.e(TAG, e.toString());
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    responseCallBack(response, callBack);
                }

            });
            return call;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return null;
    }

    /**
     * 返回结果
     *
     * @param response
     * @param callBack
     * @param <T>
     */
    private <T> void responseCallBack(Response response, ReqCallBack<T> callBack) {
        if (response.isSuccessful()) {
            String responseString = null;
            try {
                responseString = response.body().string();
                Log.e(TAG, "response ----->" + responseString);
                try {
                    Gson gson = new Gson();
                    JsonObject jsonObject = gson.fromJson(responseString, JsonObject.class);
                    HaoResult haoResult = (HaoResult) HaoResult.instanceModel(jsonObject.get("results"), jsonObject.get("errorCode").getAsInt(), jsonObject.get("errorStr").getAsString(), jsonObject.get("extraInfo"));

                    if (haoResult.isResultsOK()) {
                        successCallBack((T) haoResult, callBack);
                    } else {
                        failedCallBack((T) haoResult, haoResult.errorStr, callBack);
                    }
                } catch (Exception e) {
                    HaoResult haoResult = (HaoResult) HaoResult.instanceModel(null, -1, e.toString(), null);
                    failedCallBack((T) haoResult, e.toString(), callBack);
                }
            } catch (IOException e) {
                e.printStackTrace();
                failedCallBack(null, e.getMessage(), callBack);
            }

        } else {
            failedCallBack(null, "服务器错误", callBack);
        }
    }

    /**
     * 统一处理成功信息
     *
     * @param result
     * @param callBack
     * @param <T>
     */
    private <T> void successCallBack(final T result, final ReqCallBack<T> callBack) {
        okHttpHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onReqSuccess(result);
                }
            }
        });
    }

    /**
     * 统一处理失败信息
     *
     * @param result
     * @param callBack
     * @param <T>
     */
    private <T> void failedCallBack(final T result, final String errorMsg, final ReqCallBack<T> callBack) {
        okHttpHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    if (result == null) {
                        HaoResult haoResult = (HaoResult) HaoResult.instanceModel(null, -1, errorMsg, null);
                        callBack.onReqFailed((T) haoResult, errorMsg);
                    } else {
                        callBack.onReqFailed(result, errorMsg);
                    }
                }
            }
        });
    }

初步迁移已有成效，用ReqCallBack替换之前async-http里的回调方法，进一步解耦

参考这篇博文，感谢博主的辛劳：

okhttp封装：http://www.cnblogs.com/whoislcj/p/5526431.html

 

OkHttp的学习参考地址：

官网：http://square.github.io/okhttp/

github:https://github.com/square/okhttp

hongyang的博客：http://blog.csdn.net/lmj623565791/article/details/47911083

 

转载于:https://my.oschina.net/gabriel1215/blog/1504495