MVP 笔记

• MVP 与 MVC 简单介绍
• 实践

参考资料：
Android MVP 详解（下）
一步一步实现 Android 的MVP框架
如何更高效的使用 MVP 以及官方 MVP 架构解析
Android：聊聊我所理解的 MVP

MVP

MVC(图片来自[ Android：聊聊我所理解的 MVP](http://www.iamxiarui.com/2016/09/20/android%EF%BC%9A%E8%81%8A%E8%81%8A%E6%88%91%E6%89%80%E7%90%86%E8%A7%A3%E7%9A%84mvp/?utm_source=tuicool&utm_medium=referral))
MVP(图片来自[ Android：聊聊我所理解的 MVP](http://www.iamxiarui.com/2016/09/20/android%EF%BC%9A%E8%81%8A%E8%81%8A%E6%88%91%E6%89%80%E7%90%86%E8%A7%A3%E7%9A%84mvp/?utm_source=tuicool&utm_medium=referral))

Model 中有实体类，还负责对数据的获取，数据的解析，数据的存储，数据的分发，数据的增删改查等操作。涉及到数据操作都是在model进行的。

Presenter 负责把view交给自己的命令进行一定的校验等操作交给model处理，会把model处理的结果交给view

MVC 的问题在于在某种程度上 Activity 扮演了 View 和 Controller 的角色。
MVP 实现更好的解耦，提高代码的灵活性、使得代码层次清晰，而代价就是代码量可能更多。

MVP 的实践

参考 Google 的 todo-mvp，这个官方的项目可不止于 MVP。
实际上实现 MVP 这种架构的方法是很多的，这里我也只是将自己的理解写出来，
如果有什么不对的地方，或者有更好的方法，欢迎讨论。
项目核心文件：

核心文件

MainContract :将 Presenter 和 View 的接口都放到这里，增加可读性
MainController :有时候是 MainActivity 或者 MainFragment
MainPresenter :处理业务逻辑和数据模型等
MainView :只需要接受 Presenter 的控制，做一些初始化的工作

Model 在这里并没有对应的文件，实际上和 MVC 中的 Model 没有太多区别

放一张自己做的关于我理解的 MVP 的一些核心文件之间的关系：

MVP(图片来自[ SoftXJ](http://www.jianshu.com/u/3e8115dfb254))

下面是详细的解析每个文件：

MainContract

interface MainContract {
    abstract class View extends BaseView<Presenter>{
        
        //Presenter 在获取数据成功后调用这个方法来设置 View 中的 RecyclerView
        abstract void setNewsRecyclerView(News news);
        
        //Presenter 在获取数据成功后要调用这个方法，通知 View 已经完成了数据的更新
        abstract void notifyRefreshSuccess();
        
        //同上
        abstract void notifyRecyclerChanged();
    }

    abstract class Presenter extends BasePresenter<View>{

        public Presenter(View view) {
            super(view);
        }
        
        //View 中调用这个方法，让 Presenter 去在线的获取数据
        abstract void getNewsOnline(String url);
        
        //View 中调用这个方法，让 Presenter 加载更多的数据
        abstract void loadMoreNews(News news);
        
        //View 中调用这个方法，让 Presenter 查看当前数据是否最新
        abstract void checkIsLatest(String url);
    }
}

这个文件在我的理解中是可以没有的，但添加了之后代码就会更加的清晰。
毕竟 MVP 结构中每个 Activity/Fragment 都跟着若干的 Presenter 和 View，某种意义上也是比较的臃肿。
那如何利用这样的接口类让整个项目变得清晰呢？

• 首先，记得让我们的 MainView、MainPresenter 继承这个接口中的 View 和 Presenter。
• 记得在 View 获取 Presenter 的实例的时候，应该获取 Contract.Presenter，而不是具体的实现的类。反之，在 Presenter 获取 Contract.View。

MVP-P

这么做的目的是为了让 View 和 Presenter 只能调用对方在 Contract 中定义的方法
这时候就不能随意调用对方的方法，哪怕是 public 方法，
一来看源码的时候就很清晰的知道 View 和 Presenter 都有哪些操作。
一来促使我们在 Contract 写方法的时候认真想一想这些方法是否有必要让对方调用。

BaseView 和 MainView

注意， MainContract 中的 View 会继承这个 BaseView，而不是给 MainView 直接继承的。
BaseView 封装一些每个 View 都会有的方法，提高复用。
这里的 View 是继承自 Fragment，传入的 Presenter 不确定，所以用泛型类 T
部分代码如下：

public abstract class BaseView<T extends BasePresenter> extends Fragment {
    public Activity mActivity;
    private T mPresenter;

    /**
     * 初始化presenter，方便view层操作presenter来操作数据
     *
     * @param presenter presenter对象
     */
    public void setPresenter(T presenter) {
        mPresenter = presenter;
    }

    /**
     * 用于加载需要加载的layout视图
     *
     * @return layout's id
     */
    public abstract int viewLayoutId();

    /**
     * 此方法用于初始化 View 视图。当 Fragment 的 onCreateView()方法被调用时，会回调此方法。
     *
     * @param view 通过 viewLayoutId 获得父视图
     */
    public abstract void initView(@Nullable View view);


    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivity = getActivity();
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {

        if (viewLayoutId() == 0) {
            initView(null);
            return super.onCreateView(inflater, container, savedInstanceState);
        }

        View view = inflater.inflate(viewLayoutId(), container, false);
        initView(view);
        return view;
    }

    @Override
    public void onResume() {
        super.onResume();
        if (mPresenter != null) {
            mPresenter.start();
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        if (mPresenter != null) {
            mPresenter.destory();
        }
    }

}

MainView，在这里并没有展示太多的操作，主要是针对特定的页面的一个初始化。
相信很多人一开始会一直想，什么操作放到 View，什么操作放到 Presenter 呢？
在实际开发中，比如弹出一个 AlertDialog，针对 dialog 的一些初始化自然是在 View 中，而显示的数据则通过调用 mPresenter 的方法获取，获取之后显示的位置等在 View 设置。
再比如 RecyclerView、ViewPager 等的滑动监听的事件自然在 View，等等。

public class MainView extends MainContract.View {

    private TextView mTextView;
    private Button mButton;
    private MainContract.Presenter mMainPresenter;

    @Override
    public void showText(String text) {
        mTextView.setText(text);
    }

    @Override
    public int viewLayoutId() {
        return R.layout.activity_main;
    }

    @Override
    public void setPresenter(NewsContract.Presenter presenter) {
        super.setPresenter(presenter);
        mMainPresenter = presenter;
    }

    @Override
    public void initView(@Nullable View view) {
        if (view != null) {
            mTextView = (TextView) view.findViewById(R.id.text);
            mButton = (Button) view.findViewById(R.id.test);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {

                    openActivity(TestController.class);
                }
            });
        }

    }
}

BasePresenter 和 MainPresenter

BasePresenter 同样是封装好一些常用的方法

public abstract class BasePresenter<V extends BaseView> {

    private V mView;

    public BasePresenter(V view) {
        mView = view;
        mView.setPresenter(this);
    }

     /**
     * 获得View的对象
     *
     * @return 与Presenter绑定在一起的view对象
     */
    public V getView() {
        return mView;
    }

    /**
     * 生命周期开始回调
     */
    public abstract void start();

    /**
     * 生命周期结束回调
     */
    public abstract void destory();
}

MainPresenter 中实现 View 中的一些业务逻辑，比如请求数据、处理数据等需要操作，
下面只是部分的代码，值得一提是 Presenter 中通过构造函数获取 View 的实例，View 中通过setPresenter()获取。

public class NewsPresenter extends NewsContract.Presenter {

    private NewsContract.View mView;

    public NewsPresenter(NewsContract.View view, NewsSource newsSource) {
        super(view);
        mView = view;
    }
   /**
     * 初始化页面时被调用
     * 会判断加载的数据是否已经加载过
     * @param url
     */
    @Override
    void getNewsOnline(String url) {
        News news = mNewsSource.getNewsToCacheWithTime(time);
        if (news != null){
            mView.setNewsRecyclerView(news);
            return;
        }
        //如果缓存内没有数据再去加载
        mNewsSource.getNews(url,new ResultCallback<News>() {
            @Override
            public void onSuccess(final News data) {
                mNewsSource.saveNewsToCache(data);
                mView.setNewsRecyclerView(data);
            }
            @Override
            public void onFail(String msg) {
                LogUtil.e("fail：" + msg);
            }
        });


    }

BaseController 和 MainController

其实 Controller 一般来说是对应我们说的 MVC 的 C。
一般情况下，MVP 的 V 对应的可以是 Activity / Fragment 等，这里是因为项目结构的原因，我写的 View 都是继承的 Fragment，所以额外添加了一个 Controller 来控制、联系 View 和 Presenter。

BaseController 控制 Presenter 和 View 层，统一界面

public abstract class BaseController<V extends BaseView, P extends BasePresenter> extends BaseActivity {

    private V mView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mView = createBaseView();
        createBasePresenter(mView);
    }

    /**
     * 生成一个最基本的view
     *
     * @return view
     */
    protected abstract V createBaseView();

    /**
     * 通过baseView返回一个basePresenter
     *
     * @param baseView 最基本的view
     * @return 最基本的basePresenter
     */
    protected abstract P createBasePresenter(V baseView);
}

MainController 在 createBaseView() 返回了一个 MainView 的实例，这个实例会先传递到 BaseController 的 onCreate()，然后被传到下面的 createBasePresenter() 中，然后就传递给了 MainPresenter 中。

public class MainController extends BaseController<MainContract.View,MainContract.Presenter> {
    
    @Override
    protected MainContract.View createBaseView() {
        return new MainView();
    }

    @Override
    protected MainContract.Presenter createBasePresenter(MainContract.View baseView) {
        return new MainPresenter(baseView);
    }
}

MVP 的 Model 层

经过一段时间的摸索，现在我的项目架构变成了这样：

有 model 的 MVP

在 module 包里，根据模块分包，每一个模块都有一个独立的 model 包。
这样我们阅读源码的时候，就不需要在不同的包里寻找对应的文件了。

但这只是我自己学习总结下来的，不一定好，还是要看自己的理解。

以一个登录操作作为例子，事件的传递：

例子

·

后续

在学习 MVP 的时候，经常会有一个问题，为什么要绕一个圈子要实现一个功能呢？
而且使用 MVP 的时候总会多出很多文件，写下了很多接口，对 于之前没有研究过的人来说上手会有一定的难度。
但在开发中我们总是不可避免的去修改和完善我们的代码，假如我们的代码的结构不清晰，又或者耦合太高，就会给修改的过程添加很多麻烦。
更别说现在我们经常要和别人合作来完成一个项目，这对我们的代码规范和清晰度的要求就更高了，而 MVP 就基本可以满足我们的要求。

因为自己的项目其实还是很杂乱，也不合适开源，所以这里都只是放了部分的源码，有时间专门开一个项目完善关于 MVP 的研究。