OkHttp框架二次封装，post json格式的参数（下）

没看过上篇的，建议先看上篇，传送门：http://blog.csdn.net/black_dreamer/article/details/53068620

响应数据的格式

服务器响应的数据，结构也大都固定，比如：

{
"result": {
    "total": 0,
    "data": {
        "uid": 9527,
        "token": "xxxxxxxxxxxxx",
        "username": "xxxxx"
    }
},
"status": 200
}

上面的响应里，基本上两个字段是不变的，result字段和status字段，result里面的字段也相对固定，可能列表数据和单条数据会有不同。

封装响应

请求封装的主要内容在TPostJsonBuilder.java里，将参数拼接转换，而响应的封装，主要是解析服务器返回的响应数据，解析成实体类，然后方便我们取里面的字段。

这里我们可以先写一个最外层的结果类，用来接收result和status两个字段：

TOkHttpResponse.java

public class TOkHttpResponse<T> {


@SerializedName("result")
private T result;

@SerializedName("status")
private int status;

//get and set 方法，略...

}

很简单，里面只有两个成员变量，一个是泛型的result，一个是status。

然后要怎么用到这个TOkHttpResponse呢？
答案是新建TBaseCallback类继承自Callback：

TBaseCallback.java

public abstract class TBaseCallback<T> extends Callback<TOkHttpResponse<T>> {

public TBaseCallback() {

}

@Override
public TOkHttpResponse<T> parseNetworkResponse(Response response, int id) throws Exception {

    String str = response.body().string();

    TOkHttpResponse<T> res = new Gson().fromJson(str,new TypeToken<TOkHttpResponse<T>>(){}.getType()) ;
    return res;
}

@Override
public void onError(Call call, Exception e, int id) {
    Log.e("test","e: " + e.toString()) ;
}
}

这个类里，通过parseNetworkResponse方法，得到response.body().string()，然后转换成TOkHttpResponse对象并返回。这样一来，在TBaseCallback的子类的onResponse方法里，就能得到TOkHttpResponse类型的结果了。

举个栗子：

针对上面的result字段

"result": {
    "total": 0,
    "data": {
    "uid": 9527,
    "token": "xxxxxxxxxxxxx",
    "username": "xxxxx"
}

里面字段始终都是total和data，但是data可能是Object ，也可能是array，这里是object，所以我们给result也建一个基本类，里面是total和data两个字段：

TBaseDataResult.java

public class TBaseDataResult<T> {

int total ;

T data;

//get and set 方法，略...
}

在使用的时候，只需要这么做（headM是请求头里的一个字段，pri_args是参数的一部分）：

TBaseApi.createPostRequest(headM, pri_args, new TBaseCallback<TBaseDataResult>() {
        @Override
        public void onResponse(TOkHttpResponse<TBaseDataResult> response, int i) {
            TBaseDataResult result = response.getResult() ;
            int total = result.getTotal() ;
            Object data = result.getData() ;
        }
    });

这样total和data两个字段都可以轻松得到了，如果想继续解析data，那么可以再新建个bean对象：

TLogin.java

public class TLogin {
    int uid ;
    String token ;
    String username ;

    ...
}

使用时放进去：

 TBaseApi.createPostRequest(headM, pri_args, new TBaseCallback<TBaseDataResult<TLogin>>() {
        @Override
        public void onResponse(TOkHttpResponse<TBaseDataResult<TLogin>> response, int id) {

            if (response.getStatus() == 200) {

                JsonElement j = new Gson().toJsonTree(response.getResult()) ;
                TBaseDataResult<TLogin> result = new Gson().fromJson(j,new TypeToken<TBaseDataResult<TLogin>>(){}.getType()) ;

                TLogin data = result.getData();

                int uid = data.getUid() ;
                String username = data.getUsername() ;
                String token = data.getToken();
            }

        }

        @Override
        public void onError(Call call, Exception e, int id) {
            super.onError(call, e, id);
            ...
        }
    });

这样无论data字段里是什么东西，都可以依葫芦画瓢创建POJO对象，然后去适配。

不过每次都用new TBaseCallback()来新建Callback也很烦，所以嘛，可以把它封装到基类里去，比如：

TBaseNetActivity.java

public abstract class TBaseNetActivity<T> extends TBaseActivity {

public void setContentView(...) {
    ...
    initCallBack();
}

private void initCallBack() {
    if (callback == null) {
        callback = new TBaseCallback<T>() {
            @Override
            public void onResponse(TOkHttpResponse<T> response, int id) {
                hideLoadingView();
                status = response.getStatus();
                if (status == 200) {
                    onSuccessResponse(response);
                } else {
                    ...
                    onFailResponse(error);
                }
            }

            @Override
            public void onError(Call call, Exception e, int id) {
                super.onError(call, e, id);
                ...
                hideLoadingView();
                onFailResponse(error);
            }
        };
    }
}

public TBaseCallback<T> getCallback() {
    if (callback == null) {
        initCallBack();
    }
    return callback ;
}

public void postRequest(String headM,Map<String,Object> pri_args) {
    showLoadingView();
    TBaseApi.createPostRequest(headM,pri_args,getCallback());
}

public abstract void onSuccessResponse(TOkHttpResponse<T> response);

public abstract void onFailResponse(TOkHttpError error);
}

这里的思路就很简单了，区分请求成功（返回码200）和请求失败的，只允许成功的进入onSuccessResponse方法里，把错误逻辑都扔到onFailResponse里，避免了原来在onResponse里解析时的过多的判断。TOkHttpError跟TOkHttpResponse类似，是封装的错误返回码

使用时创建Activity，传入bean类，重写父类的方法：

public class TMyActivity extends TBaseNetActivity<TBaseDataResult<TBean>> {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.layout_main);
    //发送请求，因为Okhttp-utils已经封装成异步请求了，所以主线程中请求网络是完全没问题的
    postRequest(headM,pri_args);
}

@Override
public void onSuccessResponse(TOkHttpResponse<TBaseDataResult<TBean>> response) {
    //解析数据咯
}
@Override
public void onFailResponse(TOkHttpError error) {
    //失败时的异常处理
}

}

关于网络框架的封装，差不多就涉及这些了。

github地址：https://github.com/herdotage/Android_sample/tree/master/LOkhttpUtils