没看过上篇的,建议先看上篇,传送门: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