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

最新推荐文章于 2021-08-09 11:23:34 发布

原创最新推荐文章于 2021-08-09 11:23:34 发布 · 2.3k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Android #Okhttp #Okhttputil #android

Android开发笔记专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍如何使用OkHttp进行网络请求的封装，包括自定义响应数据格式、封装响应类和错误类，以及如何解析复杂的数据结构。通过具体示例展示了如何创建和使用自定义的回调类来处理不同类型的数据。

没看过上篇的，建议先看上篇，传送门：http://blog.youkuaiyun.com/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