Okhttp 简单的网络封装

              项目一直在用okhttp进行网络请求,但是一直没有自己独立敲一遍整个的网络请求框架。目的是重新了解整个框架的实现流程。

             框架实现的结果：

            1、请求参数统一封装；

            2、返回参数统一处理；

            3、此框架可以实现各个网络框架，比如okhttp,Volley等的迅速替换，而不需要替换框架，更改每个接口。

           

          一、请求接口

   

public interface ICallback {
    void onSuccess(String result);
    void onFailure(String e);
}

 数据均以String类型返回。

2、支持泛型的请求接口，实现ICallBack,在方法中直接进行Gson解析，返回需要的bean类。

public abstract  class HttpCallback<Result> implements ICallback{

    @Override
    public void onSuccess(String result) {
        Log.i("返回result",result.toString());
        Gson gson = new Gson();
        try{
            Result objResult = (Result)gson.fromJson(result,analysisClassInfo(this));
            onSuccess(objResult);
        }catch (Exception e){
            Log.e("返回数据Gson解析异常",e.toString());
            onFailure(e.toString());
        }
    }


    @Override
    public void onFailure(String e) {
        Log.e("请求onFailure==",e.toString());
        onFailure(e);

    }

    public abstract void onSuccess(Result result);

    public static Type analysisClassInfo(Object object) {
        Type genType = object.getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType)genType).getActualTypeArguments();
        return  params[0];
    }


}

3、请求方法的接口，

public interface IHttpProcessor {


    /**
     * 异步post请求
     */
    void post(String url, Map<String, Object> params, ICallback callback);

    /**
     * 异步get请求
     */
    void get(String url, Map<String, Object> params, ICallback callback);

    /**
     * 同步post请求
     */
    void postSyn(String url, Map<String, Object> params, ICallback callback);

    /**
     * 同步get请求
     */
    void getSyn(String url, Map<String, Object> params, ICallback callback);
}

4、实现请求接口的类，如果项目中需要用okhttp，则可以写OkhttpProcessor,如果需要用Volley，则可以写VolleyProcessor。

public class OkhttpProcessor implements IHttpProcessor {


    private static final String TAG = "OkhttpProcessor";
    private OkHttpClient mOkHttpClient;
    private Handler mHandler;


    public OkhttpProcessor() {
        mOkHttpClient = new OkHttpClient.Builder()
                .connectTimeout(30, TimeUnit.SECONDS)//设置连接超时时间
                .writeTimeout(30, TimeUnit.SECONDS)//设置写的超时时间
                .readTimeout(30, TimeUnit.SECONDS)//设置读取超时时间
                .build();

        mHandler = new Handler();
    }

    /**
     * 异步post
     */

    @Override
    public void post(String url, Map<String, Object> params, final ICallback callback) {
        RequestBody requestBody = appendBody(params);
        Request request = addHeaders().url(url).post(requestBody).build();
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(final Call call, final IOException e) {
                failedCallBack(e.toString(), callback);
            }

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

    /**
     * 异步get
     */
    @Override
    public void get(String url, Map<String, Object> params, final ICallback callback) {
        Request request = addHeaders().url(url).build();
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(final Call call, final IOException e) {
                failedCallBack(e.toString(), callback);

            }

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

            }
        });
    }


    /**
     * 同步post
     */

    @Override
    public void postSyn(String url, Map<String, Object> params, ICallback callback) {
        try {
            RequestBody requestBody = appendBody(params);
            Request request = addHeaders().url(url).post(requestBody).build();
            Response response = mOkHttpClient.newCall(request).execute();
            responseCallBack(response, callback);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 同步get
     */
    @Override
    public void getSyn(String url, Map<String, Object> params, ICallback callback) {
        try {
            Request request = addHeaders().url(url).build();
            Response response = mOkHttpClient.newCall(request).execute();
            responseCallBack(response, callback);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }



    //==========================================内部方法============================================================

    /**
     * 统一为请求添加头信息
     *
     * @return
     */
    private Request.Builder addHeaders() {
        Request.Builder builder = new Request.Builder();
//                .addHeader("", "")
        return builder;
    }


    /**
     * 统一处理onResponse信息
     */
    private void responseCallBack(Response response, final ICallback callBack) throws IOException {
        Log.i("接口返回response：", response + "");
        final String result = response.body().string();
        if (response.isSuccessful()) {
            successCallBack(result, callBack);
        } else {
            failedCallBack(response.toString(), callBack);
        }

    }


    /**
     * 统一处理成功信息
     */
    private void successCallBack(final String result, final ICallback callBack) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onSuccess(result);
                }
            }
        });
    }

    /**
     * 统一处理失败信息
     */

    private void failedCallBack(final String errorMsg, final ICallback callBack) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onFailure(errorMsg);
                }
            }
        });
    }


    /**
     * 获取RequestBody
     */
    private RequestBody appendBody(Map<String, Object> params) {
        FormBody.Builder body = new FormBody.Builder();
        if (params == null || params.isEmpty()) {
            return body.build();
        }
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            Log.i("接口请求参数：", entry.getKey() + ":" + entry.getValue().toString());
            body.add(entry.getKey(), entry.getValue().toString());
        }
        return body.build();
    }


}

以上即为简单的网络框架，那怎么使用这个框架：

5、在Application里面对框架进行初始化：

HttpHelper.init(new OkhttpProcessor());

6、具体代码使用：

因为返回的格式是统一格式，所以用泛型替代。如果返回的msg是object类，那在下面标注红色的地方，直接为ResponseBean<bean类名称>，如果返回msg为数组，则泛型为ResponseBean<List<bean类名称>。

private Map<String,Object> httpParams = new HashMap<>();
    public void getlistData(){
        httpParams.put("a", "aa");
        httpParams.put("b","bb");
        httpParams.put("c","cc");
        HttpHelper.obtain().post(HttpUrlUtil.GET_PERFORMANCE_FM, httpParams, new HttpCallback<ResponseBean<List<FMAchievementBean>>>() {
            @Override
            public void onSuccess(ResponseBean responseBean) {
                //处理数据
            }

            @Override
            public void onFailure(String e) {
                //处理数据
            }
        });
    }

7、返回数据格式：

ResponseBean类：

public class ResponseBean<T> implements Serializable{
    public String status;
    public String error;
    public T msg;
}

github源码地址