okhttp解析请求响应字符串为实体,泛型,fastjson

请求回调解析 ResultCallback

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.blankj.utilcode.util.ToastUtils;
import com.qmy.yzsw.bean.base.BaseBean;
import com.zhy.http.okhttp.callback.Callback;

import java.net.SocketException;
import java.net.SocketTimeoutException;

import cn.mvp.mlibs.log.LogUtils;
import okhttp3.Call;
import okhttp3.ResponseBody;

/**
 * ================================================
 * 作    者：胡一帆
 * 版    本：1.0
 * 创建日期：2021年12月22日 16:38:07
 * 描    述：默认将返回的数据解析成需要的Bean,可以是 BaseBean，String，List，Map
 * 修订历史：
 * ================================================
 */
public abstract class ResultCallback<T> extends Callback<BaseBean<T>> {

    public ResultCallback() {
    }

    @Override
    public BaseBean<T> parseNetworkResponse(okhttp3.Response response, int id) throws Exception {
        ResponseBody body = response.body();
        if (body != null) {
            try {
                String string = body.string();
                return JSONObject.parseObject(string, new TypeReference<BaseBean<T>>() {
                });
            } catch (Throwable throwable) {
                LogUtils.e(throwable.getMessage());
            }
        }
        return null;
    }

    @Override
    public void onError(Call call, Exception e, int id) {
        //记录一下错误日志
//        call.request().url()
        if (e instanceof SocketTimeoutException) {
            ToastUtils.showShort("请求超时");
        } else if (e instanceof SocketException) {
            ToastUtils.showShort("服务器异常");
        }
        onError(call, e);
        LogUtils.e(e);
    }

    @Override
    public void onResponse(BaseBean<T> response, int id) {
        LogUtils.e("响应成功");
        if (response == null) {
            LogUtils.e("解析后的数据为空");
            return;
        }
        if (response.getCode() == 1) {
            onSuccess(response.getData());
        } else {
            //提示一下
            onFailure(response);
        }
    }

    public abstract void onSuccess(T data);

    public abstract void onError(Call call, Exception e);

    public void onFailure(BaseBean<T> response) {
        //这里可以提示一下,写个toast.
        ToastUtils.showShort(response.getMsg());
    }

}

ben类 

import java.io.Serializable;

public class BaseBean<T> implements Serializable {
    public int code;
    public T data;
    public String msg;

    public int getCode() {
        return code;
    }

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

    public T getData() {
        return data;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

使用

OkHttpUtils.post().url(Urls.LOGIN)
                .addParams("userName", "胡一帆")
                .addParams("password", "cccccc")
                .build().execute(new ResultCallback<LoginEntity.DataBean>() {
            @Override
            public void onSuccess(LoginEntity.DataBean data) {
                LogUtils.e("调用成功....");
            }

            @Override
            public void onError(Call call, Exception e) {
                LogUtils.e("异常....");

            }

            @Override
            public void onFailure(BaseBean<LoginEntity.DataBean> response) {
//                super.onFailure(response);
//                LogUtils.e("++++++++++ "+response.getMsg());
            }
        });

okGo解析

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.blankj.utilcode.util.SPUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.lzy.okgo.callback.AbsCallback;
import com.lzy.okgo.request.base.Request;
import com.orhanobut.logger.Logger;

import org.greenrobot.eventbus.EventBus;

import java.lang.reflect.Type;
import java.net.SocketException;
import java.net.SocketTimeoutException;

import okhttp3.Response;

/**
 * ================================================
 * 作    者：jeasonlzy（廖子尧）Github地址：https://github.com/jeasonlzy
 * 版    本：1.0
 * 创建日期：2016/1/14
 * 描    述：默认将返回的数据解析成需要的Bean,可以是 BaseBean，String，List，Map
 * 修订历史：
 * ================================================
 */
public abstract class JsonCallback1<T> extends AbsCallback<BaseBean<T>> {

    private Type type;
    private Class<T> clazz;

    public JsonCallback1() {
    }

    public JsonCallback1(Type type) {
        this.type = type;
    }

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

    @Override
    public void onStart(Request<BaseBean<T>, ? extends Request> request) {
        super.onStart(request);
        // 主要用于在所有请求之前添加公共的请求头或请求参数
        // 例如登录授权的 token
        // 使用的设备信息
        // 可以随意添加,也可以什么都不传
        // 还可以在这里对所有的参数进行加密，均在这里实现
        String token = SPUtils.getInstance().getString(Constants.SP_KEY_HEADER_TOKEN, "");
//       HashMap<String, String> stringStringHashMap = new HashMap<>();
//       stringStringHashMap.put("Authorization",token);
        request.headers("Authorization", token);
//        request.headers("header1", "HeaderValue1")//
//                .params("params1", "ParamsValue1")//
//                .params("token", "3215sdf13ad1f65asd4f3ads1f");
    }

    /**
     * 该方法是子线程处理，不能做ui相关的工作
     * 主要作用是解析网络返回的 response 对象,生产onSuccess回调中需要的数据对象
     * 这里的解析工作不同的业务逻辑基本都不一样,所以需要自己实现,以下给出的时模板代码,实际使用根据需要修改
     */
    @Override
    public BaseBean<T> convertResponse(Response response) throws Throwable {

        // 重要的事情说三遍，不同的业务，这里的代码逻辑都不一样，如果你不修改，那么基本不可用
        // 重要的事情说三遍，不同的业务，这里的代码逻辑都不一样，如果你不修改，那么基本不可用
        // 重要的事情说三遍，不同的业务，这里的代码逻辑都不一样，如果你不修改，那么基本不可用

        //详细自定义的原理和文档，看这里： https://github.com/jeasonlzy/okhttp-OkGo/wiki/JsonCallback

//        if (type == null) {
//            if (clazz == null) {
//                Type genType = getClass().getGenericSuperclass();
//                type = ((ParameterizedType) genType).getActualTypeArguments()[0];
//            } else {
//                JsonConvert1<T> convert = new JsonConvert1<>(clazz);
//                return convert.convertResponse(response);
//            }
//        }
//
//        JsonConvert1<T> convert = new JsonConvert1<>(type);
//        return convert.convertResponse(response);
        return JSONObject.parseObject(response.body().string(), new TypeReference<BaseBean<T>>() {
        });
    }

    @Override
    public void onSuccess(com.lzy.okgo.model.Response<BaseBean<T>> response) {
        if (response.body().getCode() == 1) {
            onSuccess(response.body().getData());
        } else {
            onFailure(response.body());
        }

    }

    /**
     * 失败
     */
    private void onFailure(BaseBean<T> response) {

    }

    /**
     * 成功
     */
    protected abstract void onSuccess(T data);

    @Override
    public void onError(com.lzy.okgo.model.Response<BaseBean<T>> response) {
        super.onError(response);
        int code = response.code();
        if (code == 404) {
            Logger.d("JsonCallback", "404 当前链接不存在");
            ToastUtils.showShort("404 当前链接不存在");
        }
        if (response.getException() instanceof SocketTimeoutException) {
            Logger.d("JsonCallback", "请求超时");
            ToastUtils.showShort("请求超时");
        } else if (response.getException() instanceof SocketException) {
            Logger.d("JsonCallback", "服务器异常");
            ToastUtils.showShort("服务器异常");
        } else if (response.getException() instanceof RequestException) {
            BaseBean errorBean = ((RequestException) response.getException()).getErrorBean();
            if (errorBean.getCode() == 99) {
                EventBus.getDefault().post(new LoginBean());
            } else {
                ToastUtils.showShort(errorBean.getMsg());
            }

        }
    }
}