Android：Retrofit + RxJava MVP 架构实际应用

前言

目前 MVP 架构在 Android app 开发中非常流行。通过 谷歌官方 例子和个人的一些理解形成自己的 Retrofit + RxJava 的 MVP 架构，并且用这实际开发当中。看此文需要一定的 Retrofit 和 RxJava 基础，对 mvp-clean 有一定了解。

MVP 简单介绍

• M：Model，数据处理层，获取数据、整理数据等；
• V：View，展示数据层，Activity、Fragment、Dialog 等都可以充当这个角色；
• P：Presenter，逻辑处理层，处理数据和 UI 的关系、处理来自 V 层逻辑等；

下图分析：
V 层和 M 层直接关联了吗？并没有，这是 MVP 和 MVC 一个很大的区别。V 层和 M 层是通过 P 层联系起来的。反映到代码中就是 P 持有 V 实例和 M 实例。

MVP

具体实现

1. 总体包目录

• base 包：一些 base 基类，BaseFragment 和 BaseMvpFragment 和 BaseActivity、BaseMvpFragment 差不多。
• net 包：网络请求和处理相关的类在此包下。
• utils 包：需要用到的简单工具类。

image.png

2. 关键类的说明

• BaseMvpActivity：封装了公共方法的 Activity，用了处理项目里 Activity一般都会使用到的方法，例如配合 Presenter 统一处理内存泄漏问题。注意：BaseMvpActivity Presenter 泛型是主 Presenter，其他的为次 Presenter，需要在 getPresenter() 中初始化，并且添加到 Presenter 集合中。

public abstract class BaseMvpActivity
> extends BaseActivity implements IBaseView {

    //主Presenter
    protected P mPresenter;
    //多个Presenter时候需要的容器
    private ArraySet mPresenters = new ArraySet<>(4);

    @Override
    protected void init(@Nullable Bundle savedInstanceState) {
        initLoading();
        mPresenter = getPresenter();
        addToPresenters(mPresenter);
        initView();
        initListener();
        initData();
    }

    @Override
    protected void onDestroy() {
        for (BasePresenter presenter : mPresenters) {
            presenter.detachView();
        }
        mPresenters.clear();
        super.onDestroy();
    }

    @Override
    public void showLoading() {

    }

    @Override
    public void showLoading(String msg) {

    }

    @Override
    public void hideLoading() {

    }

    @Override
    public void showMsg(String msg) {
        toastS(msg);
    }

    /**
     * 初始化Presenter，其他多个Presenter也在该方法创建并调用addToPresenters加入到集合
     * @return 主Presenter
     */
    protected abstract P getPresenter();

    /**
     * 根据具体项目需求创建loading
     */
    protected void initLoading() {

    }

    /**
     * 初始化View
     */
    protected void initView(){

    }

    /**
     * 初始化Listener
     */
    protected abstract void initListener();

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

    /**
     * 把其他的Presenter添加到Presenters集合里
     * 这样会自动绑定View和管理内存释放
     */
    protected  void addToPresenters(T presenter) {
        presenter.attachView(this);
        mPresenters.add(presenter);
    }

}

• BasePresenter：Presenter 基类，里面包含 Presenter 需要公共方法，例如统一处理内存泄漏问题。Presenter 我坚决不把 Context （Activity、Fragment之类的）传进来，要使用 Context 就用 Application 的 Context 。带个 Context 可能有些方便，但是我觉得很影响我的单元测试。

public abstract class BasePresenter {

    private V mView;

    //Disposable容器，收集Disposable，主要用于内存泄漏管理
    private CompositeDisposable mDisposables;

    protected V getView() {
        return mView;
    }

    /**
     * @param view 绑定View
     */
    @SuppressWarnings("unchecked")
    public  void attachView(T view) {
        this.mView = (V) view;
        mDisposables = new CompositeDisposable();
    }

    /**
     * 解绑关联
     */
    public void detachView() {
        mDisposables.clear();
        mDisposables = null;
        mView = null;
    }

    /**
     * @param disposable 添加Disposable到CompositeDisposable
     *                   通过解除disposable处理内存泄漏问题
     */
    protected boolean addDisposable(Disposable disposable) {
        if (isNullOrDisposed(disposable)) {
            return false;
        }
        return mDisposables.add(disposable);
    }

    /**
     * @param d 判断d是否为空或者dispose
     * @return true:一次任务未开始或者已结束
     */
    protected boolean isNullOrDisposed(Disposable d) {
        return d == null || d.isDisposed();
    }

    /**
     * @param d 判断d是否dispose
     * @return true:一次任务还未结束
     */
    protected boolean isNotDisposed(Disposable d) {
        return d != null && !d.isDisposed();
    }

    /**
     * 获取 Model 实例
     */
    protected  M getModel(Class clazz) {
        return ModelManager.getInstance().create(clazz);
    }

}

• HttpManager：网络访问管理，例如 baseUrl 配置；

public final class HttpManager {

    private Retrofit mRetrofit;
    private String mBaseUrl;
    private OkHttpClient mOkHttpClient;
    private Boolean debug = true;

    private static final Logger LOG = Logger.getLogger(HttpManager.class.getName());

    private HttpManager() {
    }

    public static HttpManager getInstance() {
        return Holder.INSTANCE;
    }

    /**
     * @param mBaseUrl 设置BaseUrl
     *                 放在第一位设置
     */
    public HttpManager setBaseUrl(String mBaseUrl) {
        this.mBaseUrl = mBaseUrl;
        return Holder.INSTANCE;
    }

    /**
     * 设置OkHttpClient
     */
    public HttpManager setOkHttpClient(OkHttpClient okHttpClient) {
        this.mOkHttpClient = okHttpClient;
        return Holder.INSTANCE;
    }

    /**
     * @param retrofit 设置retrofit
     *                 放在最后设置
     */
    public void setRetrofit(Retrofit retrofit) {
        this.mRetrofit = retrofit;
    }

    /**
     * debug
     */
    public HttpManager setDebug(Boolean debug) {
        this.debug = debug;
        return Holder.INSTANCE;
    }

    /**
     * @return mRetrofit.create(clazz)
     */
    public  T getApiService(Class clazz) {
        return mRetrofit.create(clazz);
    }

    /**
     * 自带创建retrofit
     */
    public Retrofit createRetrofit() {
        Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(mBaseUrl)
                .client(mOkHttpClient)
                .addConverterFactory(ScalarsConverterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(ObserveOnMainCallAdapterFactory.createMainScheduler())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io()));
        return builder.build();
    }

    /**
     * @return OkHttpclient
     */
    public OkHttpClient createDefaultClient() {
        ...
    }

    private static class Holder {
        private static final HttpManager INSTANCE = new HttpManager();
    }

    /**
     * info 等级log
     */
    public static class InterceptorLogInfo implements HttpLoggingInterceptor.Logger {
        @Override
        public void log(@NonNull String message) {
            LOG.log(Level.INFO, message);
        }
    }

}

• HttpResultObserver：DisposableSingleObserver 的子类，用来接收网络数据回调；

public abstract class HttpResultObserver extends DisposableSingleObserver {

    @Override
    public void onSuccess(T t) {
        //dispose 一次任务
        dispose();
        onResult(t);
    }

    @Override
    public void onError(Throwable e) {
        //dispose 一次任务
        dispose();
        onFailure(e);
    }

    /**
     * @param t 获取结果
     */
    protected abstract void onResult(T t);

    /**
     * @param e 获取结果失败
     */
    protected abstract void onFailure(Throwable e);

}

• ObserveOnMainCallAdapterFactory：指定数据回调到主线程。配合 Retrofit 使用的。

public final class ObserveOnMainCallAdapterFactory extends CallAdapter.Factory{

    private final Scheduler mScheduler;

    public ObserveOnMainCallAdapterFactory(Scheduler scheduler) {
        this.mScheduler = scheduler;
    }

    @Nullable
    @Override
    public CallAdapter get(@NonNull Type returnType, @NonNull Annotation[] annotations, @NonNull Retrofit retrofit) {
        Class rawType = getRawType(returnType);
        if (rawType != Single.class) {
            return null;
        }
        final CallAdapter> delegate =
                (CallAdapter>) retrofit.nextCallAdapter(this, returnType, annotations);
        return new CallAdapter() {
            @Override
            public Type responseType() {
                return delegate.responseType();
            }

            @Override
            public Object adapt(@NonNull Call