Okhttp - 站在巨人的肩膀上再次进行需求封装

背景

由于项目的后台接口准备换一套全新的接口开发，不采用RestFul的方式进行开发。所以项目中本身的Retrofit就死翘翘了。简而言之，项目中采用的接口开发，参数只有一个data，而data参数是一个JSON字符串，里面包含的信息就是需要请求的其他参数，均在JSON中。

思路

换网络底层，自己封装来不及，就站在鸿洋大神的肩膀上上进行再次封装。使用的是鸿洋大神的OkHttpUtils工具类，已经快3k Star了，看来确实不错。

GitHub 上有使用方法，我这里就不做过多的描述了。

前期，仅仅是数据层面上的，所以目前就只对Post数据做了封装，但是可以拓展的。另外，参数处理是通过实现抽象类实现，回调也是通过重新类实现同时实现链式调用。

实现

（1）实现参数抽象类
里面的含义具有保密性，不方便透露，已经修改过，只有记得是参数即可。

/**
 * Created by yuan on 2016/8/6.
 * 抽象类提供参数使用
 */
public abstract class BaseRequest{

    private String str=getStr(); 
    private String mStr=getMStr(); 
    private ArrayList<Object> pStr=getPStr(); 
    private String oStr= "xxxxx";
    private String vStr=getVStr(); 


    public abstract String getStr();
    public abstract String getMStr();
    public abstract ArrayList<Object> getPStr();
    public abstract String getVStr();

}

（2）实现回调类，继承自OkHttpUtils中的CallBack抽象类

/**
 * Created by yuan on 2016/8/6.
 * 拓展：自定义类型实现
 */
public abstract class BaseCallBack<T> extends Callback<T>{

    IParser parser;

    public BaseCallBack() {
        parser=new GsonParser();
    }

    @Override
    public T parseNetworkResponse(Response response, int id) throws Exception {
         //这里可以进行解密操作
        String result=response.body().string()；
        return parser.parse(result,getFirstActualTypeArgument());
    }

    /**
     * 获得 T 类型
     * @return
     */
    private Type getFirstActualTypeArgument(){
        Type[] types = getActualTypeArguments();
        return types[0];
    }

    /**
     * 获得实际的类型参数（泛型的真实类型）
     */
    private Type[] getActualTypeArguments(){
        Type genType = getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        return params;
    }
}

当然在回调中，需要进行数据解析，这里使用的是Gson
自定义解析接口，具有可拓展型，可以自定义其它解析器：

import java.lang.reflect.Type;

/**
 * 解析器接口
 * Created by yuan on 16/08/06.
 */
public interface IParser {
    <T>T parse(String msg, Type type);
}

Gson解析类实现 ：

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import java.lang.reflect.Type;

/**
 * Gson解析器
 * Created by yuan on 16/08/06.
 */
public class GsonParser implements IParser{

    static final Gson gson = new Gson();

    @Override
    public <T> T parse(String json, Type type) {
        try {
            return gson.fromJson(json, type);
        }catch (JsonSyntaxException e){
        }
        return null;
    }

}

（3）OkHttpBuilder实现

import com.zhy.http.okhttp.OkHttpUtils;

import org.pinjinbao.pinjinbaocore.net.base.BaseCallBack;
import org.pinjinbao.pinjinbaocore.net.base.BaseRequest;

import okhttp3.OkHttpClient;

/**
 * Created by yuan on 2016/8/6.
 *
 */
public class OkHttpBuilder {

    private static final String HTTP_HOST_API="http://xxxxxx";
    private volatile static OkHttpBuilder mInstance;
    private BaseRequest baseRequest;//请求参数
    private BaseCallBack baseNetCall;//数据回调

    public OkHttpBuilder setBaseRequest(BaseRequest baseRequest) {
        this.baseRequest = baseRequest;
        return mInstance;
    }

    public OkHttpBuilder setBaseNetCall(BaseCallBack baseNetCall) {
        this.baseNetCall = baseNetCall;
        return mInstance;
    }

    public static OkHttpBuilder initClient(OkHttpClient okHttpClient) {
        if (mInstance == null) {
            synchronized (OkHttpUtils.class) {
                if (mInstance == null) {
                    //初始化OkHttpUtils
                    OkHttpUtils.initClient(okHttpClient);
                    mInstance = new OkHttpBuilder();
                }
            }
        }
        return mInstance;
    }

    public static OkHttpBuilder getInstance(){
        return mInstance;
    }

    /*
    *  post数据请求，当然下面还可以进行其他拓展。
    * 
    */
    public void postData(){
        OkHttpUtils
                .post()
                .url(HTTP_HOST_API)
                .addParams("params",baseRequest.toString())
                .build()
                .execute(baseNetCall);
    }

}

（4）初始化 - Application中实现

private void initOkHttpUtil() {
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(10000L, TimeUnit.MILLISECONDS)
                .readTimeout(10000L, TimeUnit.MILLISECONDS)
                .addInterceptor(new LoggerInterceptor("HaHa"))//日志拦截器
                .build();
        OkHttpBuilder.initClient(okHttpClient);
    }

（5）使用第一步 ： 继承数据抽象类，返回参数

/**
 * Created by yuan on 2016/8/6.
 */
public class BannersRequest extends BaseRequest{

        @Override
        public String getStr() {
            return "Labelnet";
        }

        @Override
        public String getMStr() {
            return "Labelnet";
        }

        @Override
        public ArrayList<Object> getPStr() {
            return new ArrayList<>();
        }

        @Override
        public String getVStr() {
            return "Labelnet";
        }

}

（6）使用第二步：调用进行请求，使用起来很简单

OkHttpBuilder
                .getInstance()
              /参数/  .setBaseRequest(new BannersRequest())
              /回调/  .setBaseNetCall(new BaseCallBack<BaseNetCall<List<BannerItem>>>() {
                    @Override
                    public void onError(Call call, Exception e, int id) {
                    //失败
                    }

                    @Override
                    public void onResponse(BaseNetCall<List<BannerItem>> response, int id) {
                  //成功
                        }

                    }
                }).postData();

附件

代码设计保密，这里就不进行分享了，但是通过上面的步骤，是可以实现的，非常详细。里面还可以进行加密解密操作等等。

附上返回数据的总Bean类：

/**
 * Created by yuan on 2016/8/5.
 * 接口返回值
 */
public class BaseNetCall<T>{

    private int code;
    private String err;
    private T data;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getErr() {
        return err;
    }

    public void setErrMsg(String err) {
        this.err = err;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

思考：虽然在这里使用的时候，已经是异步的了。但是还是可以考虑下，在解析返回的时候，返回值与RxJava结合？