关于retrifit2+rxjava2进行网络请求的个人心得

不知从何下手。
…
这一年一直在使用retrifit2+rxjava2，如果你是一位接触过这两种框架不久但一直苦于代码臃肿的同道中人，也许这篇文章能帮到你…吧！
一开始接触的时候由于理解得不深，写的也比较死板，不灵活，看起来也乱。也借鉴过网上一些技术贴（大部分都忘了收藏~~），结合自己工作上的实际需求，所以整理出了一个稍微有一丢丢方便的使用方法（纯手打，如有雷同，纯属~~借鉴，望各位大神原谅则个）
不多啰嗦
首先，当然还是老套路，创建一个RetrifitServer 接口。如下

public interface RetrifitServer {
	 @POST
    Observable<BaseResponse> request(@Url String path,@Body JsonObject jo);
 }

请求很简单,jo包含请求参数(后面会提供请求例子)，BaseResponse则是返回结果格式，用Observable接收.
然后是BaseResponse，仅供参考：

public class BaseResponse{
    public int resCode;
    public String resMsg;
    public JsonObject result;
    
    public JsonObject getResult() {
     return result; 
     }
    public void setResult(JsonObject result) {
        this.result = result;
    }
    public int getResCode() {
        return resCode;
    }
    public void setResCode(int resCode) {
        this.resCode = resCode;
    }
    public String getResMsg() {
        return resMsg;
    }
    public void setResMsg(String resMsg) {
        this.resMsg = resMsg;
    }
}

到这里，一个基本的网络请求就好了。
但是在写代码时候，如果进行网络请求和解析请求结果没有进行规范，代码看起来会相当臃肿，不利于以后的维护
所以下面将对所有接口请求和请求结果进行统一规范。
首先写一个请求与解析工具类NetWorkHelper:

public class NetworkHelper {
	//网络请求方法,callback用来返回解析结果
    public static Disposable doHttp(JsonObject request, final String method, final String msg, final HttpCallback callback) {
    	//获取请求结果observable
        Observable<BaseResponse> observable = getObservable(request, method);
        if (observable == null) {
            ToastHelper.getInstance().show("无法匹配该请求,请检查请求地址");
            return null;
        }
        //接下来实现三个Consumer接口  分别是	disposableConsumer，responseConsumer ,throwableConsumer 

        //disposableConsumer  这里可以定义请求前的相关操作
        Consumer<Disposable> disposableConsumer = (Disposable disposable) -> {
        //展示网络请求等待窗口
           LoadingDialog.getInstance().show(msg);
        };

		//responseConsumer   在这里解析网络请求结果
        Consumer<BaseResponse> responseConsumer = (BaseResponse response) -> {
        //隐藏网络请求等待窗口
            LoadingDialog.getInstance().hide();
            NetWorkResult result = parseResponse(response);
            if (!result.isSuccess()) 
            //回调请求失败结果与原因
                callback.fail(method, result.getCode(), result.getMsg(), result.getData());
            else 
            //回调网络请求成功
                callback.success(method, result.getData());
            
        };

		//throwableConsumer   在这里解析网络错误
        Consumer<Throwable> throwableConsumer = (Throwable throwable) -> {
        //隐藏网络请求等待窗口
            LoadingDialog.getInstance().hide();
            String reason = parseError(method, throwable);
            //回调网络错误的原因
            callback.error(method, reason);
        };
        
		//最后进行网络请求
        return observable
                .doOnSubscribe(disposableConsumer)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(responseConsumer, throwableConsumer, () -> {
                });
    }
	//将所有请求接口在这里匹配
    private static Observable getObservable(String method, JsonObject request) {
    	RetrifitServer retrifitServer = RetrifitHelper.getInstance().getServer();
        if (retrifitServer == null)
            return null;
       return  retrifitServer.request(method,request);
     }

    private static NetWorkResult parseResponse(BaseResponse response) {
        NetWorkResult result = new NetWorkResult();
        if (response == null) {
            result.setSuccess(false);
            result.setMsg("请求结果有误");
            return result;
        }
        if (response.getResCode() != 0) {
            result.setSuccess(false);
            result.setMsg(response.getResMsg());
            return result;
        }
        if (response.getResult() == null) {
            result.setSuccess(false);
            result.setMsg("请求结果有误");
            return result;
        }
         JsonObject jo= response.getResult();
        if ("0".equals(jo.get("resCode"))) {
            result.setData(jo.get("data").toString());
            result.setSuccess(true);
            result.setMsg(jo.get("resMsg").toString());
            return result;
        } else {
            result.setSuccess(false);
            result.setData(jo.get("data").toString());
            result.setCode(jo.get("resCode").toString());
            result.setMsg(jo.get("resMsg").toString());
            return result;
        }
    }

到此就是网络请求解析部分。
下面贴上HttpCallback

public interface HttpCallback {
    void success(String method, Object result);
    void fail(String method, int errorCode, String reason, Object data);
    void error(String method, String reason);
}

最后贴一个登录请求示例:

	public void login(String account, String pwd) {
		JsonObject request = new JsonObject();
        request.addProperty("account",account);
        request.addProperty("pwd",pwd);
        //调用loginModel的doHttp进行网络请求
        loginModel.doHttp(request, Constants.login, "登陆中...");
    }

LoginModel类

public class LoginModel implements LoginContract.LoginModel, HttpCallback {
    private Disposable mDisposable;

    public void request(JsonObject request, String method, final String msg) {
        	this.mDisposable = NetworkHelper.doHttp(request, method, msg, this);
    }
    @Override
    public void success(String method, Object result) {
        switch (method) {
         	case Constants.login:
         		break;
         	}
    }
        @Override
    public void fail(String method, int errorCode, String reason, Object data) {

    }

    @Override
    public void error(String method, String reason) {

    }
    public void release() {//释放所有资源
        if (mDisposable != null)
            mDisposable.dispose();
    }

若有不足之处，望不吝指出，感谢!