打造终极MVP+Retrofit2+okhttp3+Rxjava2网络请求,开发实用,简约

抓住人生中的一分一秒，胜过虚度中的一月一年!

小做个动图开篇引题

懒洋洋.gif

前言

目前较火的网络框架有MVP+Retrofit2+okhttp3+Rxjava2，于是也加入了使用行列，本框架为Retrofit基本写法及特殊情况处理衍生，为大家学习使用提供帮助，本次优化对使用过程中所遇到问题进行总结，基本满足实际开发需求，有不足地方我将继续完善

---

---

相关业务需求及解决方案
一、 MVP+Retrofit2+okhttp3+Rxjava2框架基本搭建及使用
二、 对BaseActivity、BaseFragment封装协调框架更好使用
三、 Android部分手机4G网第一次请求很慢（wifi正常）解决方案
四、 Retrofit运行时动态改变BaseUrl解决方案
五、 Retrofit文件上传（本片文章介绍中包含进度条）
六、 Retrofit文件下载（含进度条）
七、 Retrofit，Gson解析，请求返回的类型不统一，假如double返回的是null
八、 Retrofit实现cookie自动化管理
九、 路由判断第二种解决方案（文章为旧版，提供思路）
十、 Retrofit配置及各情况处理（缓存拦截、日志打印、替换接口内容、参数添加等）
十一、 后记
十二、 本文譩在一篇文章搞定所有，上述描述文章都有讲解

一、MVP+Retrofit2+okhttp3+Rxjava2框架基本搭建

1、 相关依赖引用

    implementation 'com.squareup.okhttp3:okhttp:3.11.0'
    implementation 'com.squareup.retrofit2:retrofit:2.4.0'
    //ConverterFactory的Gson依赖包
    implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
    //CallAdapterFactory的Rx依赖包
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
    //cookie管理
    implementation 'com.github.franmontiel:PersistentCookieJar:v1.0.1'
    //日志
    implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0'

2、 创建接口类ApiServer，定义接口方法

public interface ApiServer {
    @FormUrlEncoded
    @POST("/api/table_list/")
    Observable> getCeShi(@FieldMap HashMap params);
}

3、 创建Retrofit

public class ApiRetrofit {
    private static ApiRetrofit mApiRetrofit;
    private Retrofit retrofit;
    private ApiServer apiServer;
    private static final int DEFAULT_TIMEOUT = 15;
    public static String mBaseUrl = BaseContent.baseUrl;

    public ApiRetrofit() {
        OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
        httpClientBuilder
                .cookieJar(new CookieManger(App.getContext()))
                .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

        retrofit = new Retrofit.Builder()
                .baseUrl(mBaseUrl)
                .addConverterFactory(GsonConverterFactory.create())
                //支持RxJava2
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .client(httpClientBuilder.build())
                .build();

        apiServer = retrofit.create(ApiServer.class);
    }

    public static ApiRetrofit getInstance() {
        if (mApiRetrofit == null) {
            synchronized (Object.class) {
                if (mApiRetrofit == null) {
                    mApiRetrofit = new ApiRetrofit();
                }
            }
        }
        return mApiRetrofit;
    }

    public ApiServer getApiService() {
        return apiServer;
    }
}

4、 定义常用的接口，如网络请求开始，结束，进度条加载，错误码等

public interface BaseView {
    //显示dialog
    void showLoading();
    //隐藏 dialog
    void hideLoading();
    //显示错误信息
    void showError(String msg);
    //错误码
    void onErrorCode(BaseModel model);
    //进度条显示
    void showProgress();
    //进度条隐藏
    void hideProgress();
    //文件下载进度监听
    void onProgress(int progress);
}

5、 BaseModel封装

封装理由:一个项目一般情况下json返回格式外层都是统一的

public class BaseModel implements Serializable {
    private String reason;
    private int error_code;
    private T result;
    public BaseModel(String reason, int error_code) {
        this.reason = reason;
        this.error_code = error_code;
    }
    public String getReason() {
        return reason;
    }
    public void setReason(String reason) {
        this.reason = reason;
    }
    public int getError_code() {
        return error_code;
    }
    public void setError_code(int error_code) {
        this.error_code = error_code;
    }
    public T getResult() {
        return result;
    }
    public void setResult(T result) {
        this.result = result;
    }
}

6、 BasePresenter封装，协调m层v层的中间信使通用代码封装

public class BasePresenter {
    private CompositeDisposable compositeDisposable;
    public V baseView;
    protected ApiServer apiServer = ApiRetrofit.getInstance().getApiService();

    public BasePresenter(V baseView) {
        this.baseView = baseView;
    }
    /**
     * 解除绑定
     */
    public void detachView() {
        baseView = null;
        removeDisposable();
    }
    /**
     * 返回 view
     *
     * @return
     */
    public V getBaseView() {
        return baseView;
    }

    public void addDisposable(Observable observable, BaseObserver observer) {
        if (compositeDisposable == null) {
            compositeDisposable = new CompositeDisposable();
        }
        compositeDisposable.add(observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(observer));
    }

    public void addFileDisposable(Observable observable, FileObserver observer) {
        if (compositeDisposable == null) {
            compositeDisposable = new CompositeDisposable();
        }
        compositeDisposable.add(observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(observer));
    }

    public void removeDisposable() {
        if (compositeDisposable != null) {
            compositeDisposable.dispose();
        }
    }
}

6、 BaseObserver封装，数据等异常处理路由

封装理由:处理业务逻辑路由，与错误信息处理
注：在正常开发中，前后台会约定相关字段如code的值代表各情况,在此路由通道，另一种路由方案是重写Gson解析类，文章不做体现，demo中有相关代码

public abstract class BaseObserver extends DisposableObserver> {
    protected BaseView view;
    /**
     * 网络连接失败  无网
     */
    public static final int NETWORK_ERROR = 100000;
    /**
     * 解析数据失败
     */
    public static final int PARSE_ERROR = 1008;
    /**
     * 网络问题
     */
    public static final int BAD_NETWORK = 1007;
    /**
     * 连接错误
     */
    public static final int CONNECT_ERROR = 1006;
    /**
     * 连接超时
     */
    public static final int CONNECT_TIMEOUT = 1005;
    /**
     * 其他所有情况
     */
    public static final int NOT_TRUE_OVER = 1004;

    public BaseObserver(BaseView view) {
        this.view = view;
    }

    public BaseObserver() {
    }

    @Override
    protected void onStart() {
        if (view != null) {
            view.showLoading();
        }
    }

    @Override
    public void onNext(BaseModel o) {
//        T t = o.getData();
        try {
            if (view != null) {
                view.hideLoading();
            }
            if (o.getError_code() == BaseContent.basecode) {
                onSuccess(o);
            } else {
                if (view != null) {
                    view.onErrorCode(o);
                }
                //非  true的所有情况
                onException(PARSE_ERROR, o.getReason());
            }
        } catch (Exception e) {
            e.printStackTrace();
            onError(e.toString());
        }
    }

    @Override
    public void onError(Throwable e) {
        if (view != null) {
            view.hideLoading();
        }
        if (e instanceof HttpException) {
            //   HTTP错误
            onException(BAD_NETWORK, "");
        } else if (e instanceof ConnectException
                || e instanceof UnknownHostException) {
            //   连接错误
            onException(CONNECT_ERROR, "");
        } else if (e instanceof InterruptedIOException) {
            //  连接超时
            onException(CONNECT_TIMEOUT, "");
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {
            //  解析错误
            onException(PARSE_ERROR, "");
            e.printStackTrace();
        } else {
            if (e != null) {
                onError(e.toString());
            } else {
                onError("未知错误");
            }
        }
    }

    private void onException(int unknownError, String message) {
        switch (unknownError) {
            case CONNECT_ERROR:
                onError("连接错误");
                break;
            case CONNECT_TIMEOUT:
                onError("连接超时");
                break;
            case BAD_NETWORK:
                onError("网络超时");
                break;
            case PARSE_ERROR:
                onError("数据解析失败");
                break;
            //非true的所有情况
            case NOT_TRUE_OVER:
                onError(message);
                break;
            default:
                break;
        }
    }
    //消失写到这 有一定的延迟  对dialog显示有影响
    @Override
    public void onComplete() {
       /* if (view != null) {
            view.hideLoading();
        }*/
    }
    public abstract void onSuccess(BaseModel o);
    public abstract void onError(String msg);
}

如上，相关框架已封装完毕，下面看下如何使用

8、 定义MainView，并继承BaseView

public interface MainView extends BaseView {
    void onTextSuccess(BaseModel o);
}

9、 定义MainPresenter，并继承BasePresenter

public class MainPresenter extends BasePresenter {
    public MainPresenter(MainView baseView) {
        super(baseView);
    }
    /**
     * 写法好多种  怎么顺手怎么来
     */
    public void getTextApi() {
        HashMap params = new HashMap<>();
        params.put("type", "junshi");
        params.put("key", "2c1cb93f8c7430a754bc3ad62e0fac06");
        addDisposable(apiServer.getText(params), new BaseObserver(baseView) {
            @Override
            public void onSuccess(BaseModel o) {
                baseView.onTextSuccess((BaseModel) o);
            }
            @Override
            public void onError(String msg) {
                if (baseView != null) {
                    baseView.showError(msg);
                }
            }
        });
    }
}

10、 在Activity中进行网络请求，如下

public class MainActivity extends AppCompatActivity implements MainView {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MainPresenter presenter = new MainPresenter(this);
        //网络请求
        presenter.getTextApi();
    }
    @Override
    public void onTextSuccess(BaseModel o) {
    //我是网络请求成功后的结果
    }

    @Override
    public void showLoading() {
    //网络开始请求时我会执行
    }
    @Override
    public void hideLoading() {
    //网络请求完毕时我会执行
    }
    @Override
    public void showError(String msg) {
    //异常情况下我会提示内容
    }
    @Override
    public void onErrorCode(BaseModel model) {
    //在异常时候我会回调
    }
    @Override
    public void showProgress() {
    //需要显示进度条时候我是开始标识
    }
    @Override
    public void hideProgress() {
    //需要隐藏进度条时候我是结束标识
    }
    @Override
    public void onProgress(int progress) {
    //进度条最主要的是我
    }
}

第一章结束（MVP+Retrofit2+okhttp3+Rxjava2框架基本搭建及使用）
activity内容太多了，阅读性差，引发了强烈的需求对Activity封装与Fragment封装，请往下看

二、对BaseActivity、BaseFragment封装协调框架更好使用

浅谈BaseActivity写法，促使我们更高效开发
Fragment懒加载实现，BaseFragment封装
有兴趣的撸友们可以转战我其他俩篇文章，本文意在一篇掌握网络请求，如下继续介绍如何封装

1、 BaseActivity相关内容进行封装，BaseFragment可到demo中查看

public abstract class BaseActivity
 extends AppCompatActivity implements BaseView {
    protected final String TAG = this.getClass().getSimpleName();
    public Context mContext;
    protected P mPresenter;

    protected abstract P createPresenter();

    private LoadingDialog loadingDialog;
    private ProgressDialog progressDialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mContext = this;
        setContentView(getLayoutId());
        mPresenter = createPresenter();
        setStatusBar();

        this.initData();
    }

    /**
     * 获取布局ID
     *
     * @return
     */
    protected abstract int getLayoutId();

    /**
     * 数据初始化操作
     */
    protected abstract void initData();

    /**
     * 此处设置沉浸式地方
     */
    protected void setStatusBar() {
        StatusBarUtil.setTranslucentForImageViewInFragment(this, 0, null);
    }

    /**
     * 封装toast方法（自行定制实现）
     *
     * @param str
     */
    public void showToast(String str) {
        ToastUtils.show(str);
    }

    public void showLongToast(String str) {
        ToastUtils.show(str);
    }

    @Override
    public void showError(String msg) {
        showToast(msg);
    }

    /**
     * 返回所有状态  除去指定的值  可设置所有（根据需求）
     *
     * @param model
     */
    @Override
    public void onErrorCode(BaseModel model) {
        if (model.getError_code() == 10000000) {
            //处理些后续逻辑   如果某个页面不想实现  子类重写这个方法  将super去掉  自定义方法
//            App.put();
//            startActivity(LoginActivity.class);
        }
    }

    @Override
    public void showLoading() {
        showLoadingDialog();
    }

    @Override
    public void hideLoading() {
        dissMissDialog();
    }

    public void showLoadingDialog() {
        showLoadingDialog("加载中...");
    }

    /**
     * 加载  黑框...
     */
    public void showLoadingDialog(String msg) {
        if (loadingDialog == null) {
            loadingDialog = new LoadingDialog(this);
        }
        loadingDialog.setMessage(msg);
        if (!loadingDialog.isShowing()) {
            loadingDialog.show();
        }
    }

    /**
     * 消失  黑框...
     */
    public void dissMissDialog() {
        if (loadingDialog != null) {
            loadingDialog.dismiss();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mPresenter != null) {
            mPresenter.detachView();
        }
        if (loadingDialog != null) {
            loadingDialog.dismiss();
        }
        if (progressDialog != null) {
            progressDialog.dismiss();
        }
        if (mPresenter != null) {
            mPresenter.detachView();
        }
    }

    /**
     * 进度条显示
     */
    @Override
    public void showProgress() {
        if (progressDialog == null) {
            progressDialog = new ProgressDialog(this);
        }
        progressDialog.getProgressBar().performAnimation();
        if (!progressDialog.isShowing()) {
            progressDialog.show();
        }
    }

    /**
     * 进度条隐藏
     */
    @Override
    public void hideProgress() {
        if (progressDialog != null) {
            progressDialog.getProgressBar().releaseAnimation();
            progressDialog.dismiss();
        }
    }

    /**
     * 进度条 回调
     * @param progress
     */
    @Override
    public void onProgress(int progress) {
        if (progressDialog != null) {
            progressDialog.updateProgress(progress);
        }
    }
}

2、 定义MainView，并继承BaseView(同上)

3、 定义MainPresenter，并继承BasePresenter(同上)

4、 在Activity中进行网络请求，如下

public class MainActivity extends BaseActivity implements MainView {
    @Override
    protected MainPresenter createPresenter() {
        return new MainPresenter(this);
    }

    @Override
    protected int getLayoutId() {
        return R.layout.activity_main;
    }

    @Override
    protected void initData() {
        //网络请求
        mPresenter.getTextApi();
    }

    @Override
    public void onTextSuccess(BaseModel o) {
        //我是网络请求成功后的结果
    }
}

三、Android部分手机4G网第一次请求很慢（wifi正常）解决方案

Android部分手机4G网第一次请求很慢（wifi正常）解决方案

1、出现此类问题场景

经测试，一般手机都没有发现网络请求慢现象，只有部分手机会出现，如（小米手机）

2、出现此类问题现象

手机4G网网络请求特别慢，第一次进入app加载网络会出现30s+延迟现象，只有第一次慢，第二次网络访问回归正常，但重新进入又会出现网络延迟30s+

3、出现此类问题排查

通过网上查阅资料，都趋向于ipv4、ipv6地址问题，经对应手机测试发现，DNS 解析的 IP 地址①.连接到wifi，只解析到 ipv4 地址，②.连接到4G网，解析到了ipv4、ipv6俩个地址,但是ipv6默认为集合中的第一个，是否我们可以尝试修改集合第一个为ipv4呢？

4、出现此类问题解决方案

解决方案：集合中ipv4，ipv6调换位置，将ipv4当到集合首位

调换集合中ipv4 ipv6位置，将ipv4当到集合首位

import okhttp3.Dns;

public class ApiDns implements Dns {
    @Override
    public List lookup(String hostname) throws UnknownHostException {
        if (hostname == null) {
            throw new UnknownHostException("hostname == null");
        } else {
            try {
                List mInetAddressesList = new ArrayList<>();
                InetAddress[] mInetAddresses = InetAddress.getAllByName(hostname);
                for (InetAddress address : mInetAddresses) {
                    if (address instanceof Inet4Address) {
                        mInetAddressesList.add(0, address);
                    } else {
                        mInetAddressesList.add(address);
                    }
                }
                return mInetAddressesList;
            } catch (NullPointerException var4) {
                UnknownHostException unknownHostException = new UnknownHostException("Broken system behaviour");
                unknownHostException.initCause(var4);
                throw unknownHostException;
            }
        }
    }
}

第二步，将自定义方法插入到okhttp中

  OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();

        ClearableCookieJar cookieJar =
                new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(AppUMS.mContent));

        httpClientBuilder
                .cookieJar(cookieJar)
                .addInterceptor(interceptor)
                .addInterceptor(new HeadUrlInterceptor())
                //设置请求超时时长
                .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                .dns(new ApiDns());//添加如下方法

四、Retrofit运行时动态改变BaseUrl解决方案

Retrofit运行时动态改变BaseUrl解决方案

1、出现此类问题场景

Android正式项目中可能会涉及到多个BaseUrl，使用Retrofit开发者可能会遇到多BaseUrl不是很好处理情况

2、第一种解决方案

简单粗暴解决方案，利用Retrofit请求优先级，因为Retrofit支持全路径，比如

 @GET("http://www.baidu.com")
 Observable