简单的封装OkGo

本文只是简单的将OkGo封装了一下，如有什么没有考虑到的问题还请各位大神提出来，我们一起进步（ps：大神自动过滤，本文只适合小白）

OkGo地址 [https://github.com/jeasonlzy/okhttp-OkGo]
OkGo文档地址 [https://github.com/jeasonlzy/okhttp-OkGo/wiki]
OkHttpUtil地址 [https://github.com/hongyangAndroid/okhttputils](已停止维护)

原因：

在项目中需要从网络或者后台去获取数据的时候，我们就会去写一个网络请求方法（其中包括进度条展示，Gson转换等），久而久之，网络请求方法就遍布到我们系统的每个地方，假如后期维护的时候突然发现这个网络请求框架不好，需要去换一个的话，那就麻烦了，维护的程序员心中会有一万个草泥马奔腾而过吧！！！
根据上面说的，这样也确实是个问题，在做项目的时候为了方便就在需要的时候去写，这样确实会对以后的维护带来很多的不便，那么我们就本着造福人类（哈哈）的想法去封装一些通用的方法。

封装

封装很简单，直接上代码
JsonCallback.class

/**
 * 类名：com.lxg.http
 * 时间：2018/1/30 14:45
 * 描述：将返回过来的json字符串转换为实体类
 * 修改人：
 * 修改时间：
 * 修改备注：
 *
 * @author Liu_xg
 */
public abstract class JsonCallback<T> extends AbsCallback<T> {
    private Type mType;
    private Class<T> clazz;

    public JsonCallback() {
    }

    public JsonCallback(Type type) {
        mType = type;
    }

    public JsonCallback(Class<T> clazz) {
        this.clazz = clazz;
    }

    @Override
    public T convertResponse(Response response) throws Throwable {

        ResponseBody body = response.body();
        if (body == null) {
            return null;
        }
        T data = null;
        Gson gson = new Gson();
        String str = response.body().string();
        if (mType != null) {
            data = gson.fromJson(str, mType);
        }
        if (clazz != null) {
            data = gson.fromJson(str, clazz);
            //可以将错误信息在onError中获取到
            //https://github.com/jeasonlzy/okhttp-OkGo/wiki/Callback#callback%E4%BB%8B%E7%BB%8D
        }
        return data;
    }
}

DialogCallback.class

/**
 * 类名：com.lxg.http
 * 时间：2018/1/30 14:34
 * 描述：网络请求前显示一个dialog,请求结束后取消loading
 * 修改人：
 * 修改时间：
 * 修改备注：
 *
 * @author Liu_xg
 */

public abstract class DialogCallback<T> extends JsonCallback<T> {

    private ProgressDialog mProgressDialog;

    public DialogCallback(Activity activity,Class<T> tClass) {
        super(tClass);
        initDialog(activity);
    }


    private void initDialog(Activity activity) {
        mProgressDialog = new ProgressDialog(activity);
        mProgressDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
        mProgressDialog.setCanceledOnTouchOutside(false);
        mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        mProgressDialog.setMessage("网络请求中");
    }

    @Override
    public void onStart(Request<T, ? extends Request> request) {
        if (mProgressDialog != null && !mProgressDialog.isShowing()) {
            mProgressDialog.show();
        }

    }

    @Override
    public void onFinish() {
        if (mProgressDialog != null && mProgressDialog.isShowing()) {
            mProgressDialog.dismiss();
        }
    }

    @Override
    public void onSuccess(Response<T> response) {

    }
}

以上是两个基类，是将json字符串转换为实体类和在每个请求前面添加进度条的方法抽取出来，弄成一个基类，这样就不需要在每次请求的时候又去单独写了。

为了方便调用，我们采用建造者模式（Builder）的方式来封装我们自己的请求类

OkGoBuilder.class

/**
 * 类名：com.lxg.http
 * 时间：2018/1/31 9:18
 * 描述：okgo帮助类-建造者模式
 * 修改人：
 * 修改时间：
 * 修改备注：
 *
 * @author Liu_xg
 */

public class OkGoBuilder<T> {
    /**
     * get请求
     */
    public static final int GET = 1;
    /**
     * post请求
     */
    public static final int PSOT = 2;


    private Activity activity;
    /**
     * 请求网址
     */
    private String url;
    /**
     * 参数
     */
    private HttpParams params;
    /**
     * 实体类
     */
    private Class<T> clazz;
    /**
     * 回调
     */
    private Callback<T> callback;

    private int methodType;

    /**
     * 单列模式
     **/
    private static OkGoBuilder mOkGoBuilder = null;

    /**
     * 构造函数私有化
     **/
    private OkGoBuilder() {
    }

    /**
     * 公有的静态函数，对外暴露获取单例对象的接口
     **/
    public static OkGoBuilder getInstance() {
        if (mOkGoBuilder == null) {
            synchronized (OkGoBuilder.class) {
                if (mOkGoBuilder == null) {
                    mOkGoBuilder = new OkGoBuilder();
                }
            }
        }
        return mOkGoBuilder;
    }


    public OkGoBuilder Builder(Activity activity) {
        this.activity = activity;
        return this;
    }

    public OkGoBuilder url(String url) {
        this.url = url;
        return this;
    }

    public OkGoBuilder method(int methodType) {
        this.methodType = methodType;
        return this;
    }

    public OkGoBuilder params(HttpParams params) {
        this.params = params;
        return this;
    }

    public OkGoBuilder cls(Class<T> clazz) {
        this.clazz = clazz;
        return this;
    }

    public OkGoBuilder callback(Callback<T> callback) {
        this.callback = callback;
        return this;
    }


    public OkGoBuilder build() {
        if (methodType == 1) {
            getRequest();
        } else {
            postRequest();
        }
        return this;
    }

    /**
     * post请求
     */
    private void postRequest() {
        OkGo
                // 请求方式和请求url
                .<T>post(url)
                .params(params)
                // 请求的 tag, 主要用于取消对应的请求
                .tag(this)
                // 设置当前请求的缓存key,建议每个不同功能的请求设置一个
                .cacheKey("cacheKey")
                // 缓存模式，详细请看缓存介绍
                .cacheMode(CacheMode.DEFAULT)
                .execute(new DialogCallback<T>(activity, clazz) {
                    @Override
                    public void onSuccess(Response<T> response) {
                        callback.onSuccess(response.body(), 1);
                    }

                    @Override
                    public void onError(Response<T> response) {
                        super.onError(response);
                        Throwable throwable = response.getException();
                        if (throwable != null) {
                            throwable.printStackTrace();
                            callback.onError(throwable, 2);
                        }
                    }

                });
    }

    /**
     * get请求
     */
    private void getRequest() {
        OkGo
                // 请求方式和请求url
                .<T>get(url)
                .params(params)
                // 请求的 tag, 主要用于取消对应的请求
                .tag(this)
                // 设置当前请求的缓存key,建议每个不同功能的请求设置一个
                .cacheKey("cacheKey")
                // 缓存模式，详细请看缓存介绍
                .cacheMode(CacheMode.DEFAULT)
                .execute(new DialogCallback<T>(activity, clazz) {
                    @Override
                    public void onSuccess(Response<T> response) {
                        callback.onSuccess(response.body(), 1);
                    }

                    @Override
                    public void onError(Response<T> response) {
                        super.onError(response);
                        Throwable throwable = response.getException();
                        if (throwable != null) {
                            throwable.printStackTrace();
                            callback.onError(throwable, 2);
                        }
                    }

                });
    }


}

这样写了之后，通过泛型，使每个网络请求都使用它，就是把它作为了网络请求公共入口类，那么我们在后期维护的时候只需要去修改这里面的代码即可，是不是感觉很方便啊。

使用方法

        HttpParams paramsPost = new HttpParams();
        paramsPost.put("sort", "desc");
        paramsPost.put("page", "1");
        paramsPost.put("pagesize", "5");
        paramsPost.put("time", "1514736923");

        OkGoBuilder.getInstance()
                .Builder(this)
                .url(URL)
                .method(OkGoBuilder.PSOT)
                .params(paramsPost)
                .cls(HttpDataBean.class)
                .callback(new Callback<HttpDataBean>() {
                    @Override
                    public void onSuccess(HttpDataBean response, int id) {
                        Log.i(TAG, "onSuccess1: " + response.getReason());
                    }

                    @Override
                    public void onError(Throwable e, int id) {

                    }
                })
                .build();

项目我已经上传到Github上面了：https://github.com/liuxinggen/OkGoUtils