MVP框架 – Ted Mosby的软件架构

• 做者：Hannes Dorfmann
• 原文连接 : Ted Mosby – Software Architect
• 文章出自 : Android开发技术前线
• 译者 : Mr.Simple

我给这篇关于Android库的博客起的名字灵感来源于《老爸老妈浪漫史》中的建筑设计师Ted Mosby。这个Mosby库能够帮助你们在Android上经过Model-View-Presenter模式作出一个完善稳健、可重复使用的软件，还 能够借助ViewState轻松实现屏幕翻转。

Model-View-Presenter (MVP)

MVP模式是一个把view从低层模型分离出来的一种现代模式。MVP由model–view–controller (MVC)软件模式衍生而来，经常使用于构建UI

• MVP中的M（model）表明的是将会显示在view（UI）中的数据。
• MVP中的V（view）是显示数据（model）而且将用户指令（events）传送到presenter以便做用于那些数据的一个接口。View一般含有Presenter的引用。
• MVP中的P（presenter）扮演的是“中间人”的做用（就如 MVC中的controller），且presenter同时引用view和model。值得注意的是，“Model”这个词并不正确。严格意义上来讲， 它指的应该是检索或控制一个Model的业务逻辑层。举个例子，好比你的数据库里面包含了User，而你的View想要显示一个User列表，那么 Presenter会引用数据库中的业务逻辑层（好比DAO）从而查询到一个User列表。如图1-1.
  

从数据库中查询或显示User列表的具体流程如图1-2：

以上工做流程图应该可以说明问题了。可是，还有如下几点值得注意的地方：

• Presenter不是一个OnClickListener。View主要是负责处理用户输入并调用presenter相应的方法。那么问题来了，为何不把Presenter 直接作成一个OnClickListener，从而把“转发流程”给省略掉呢？你们想一想，若是这样作的话，首先，presenter须要知道view的内部构件。举个例子，若是一个View有两个按钮，且这个view在这两个按钮上都把Presenter 注册成OnClickListener的 话，那么发生点击事件时Presenter （在不知道view中按钮引用等内部构件的状况下）怎么可以区分出是哪个按钮被点击了 呢？Model，View和Presenter三者应解耦。其次，若是让Presenter 执行OnClickListener，Presenter就 被绑定到了Android平台上。理论上来讲presenter和业务逻辑层都是纯旧式的可以与桌面应用或其余任何java应用共享的java代码。

• 你们在第1步和第2步中能够看到，View 只执行Presenter 指 示的操做：用户点击“load user button”（第1步）后，view并无直接显示加载动画，而是在第2步presenter明确告诉其显示加载动画后才显示的。这一Model- View-Presenter的变体称之为MVP 被动视图。这个view能够说是要多笨有多笨。这时咱们须要让presenter以一种更抽象的方式来控制view。好比，presenter在调用 view.showLoading() 时并不控制view的诸如动画等具体事项。因此presenter不该调用view.startAnimation() 等方法。

• 经过执行MVP被动视图，并发性以及多线程更容易处理。你们能够看到，第3步中数据库查询异步运行，而且presenter做为Listener/Observer，在数据准备显示时presenter收到通知。

Android上的MVP

目前为止一切顺利。可是你们怎么样把MVP运用到本身的Android 应用上呢？第一个问题在于，咱们要把MVP模式运用到什么地方？Activity上、Fragment上、仍是像RelativeLayout这类的 ViewGroup上？咱们来看看Android平板上的Gmail应用，如图1-3：

在我看来，上图屏幕中有四个可使用MVP的地方。我所说的“可使用MVP的地方”是指屏幕上显示的、在逻辑上属于一个总体的UI元素。所以这些地方也能够称为是能够运用MVP的一个单独的UI单元。如图 1-4.

看起来MVP彷佛很适合运用到Activity，特别是Fragment上。一般Fragment只负责显示单一的如ListView之类的内容，就像依靠MailProvider 来获取一系列Mails的InboxPresenter 控制下的 InboxView同样。可是，MVP不 仅仅限于Fragment或Activity，它还能够运用到SearchView中显示的ViewGroup中。在个人大多数app里面我都在 Fragment运用MVP模式。可是你们能够自行决定把MVP运用到什么地方，前提是view是独立的，这样这样presenter才能在不与其余 Presenter冲突的状况下控制View。

咱们为何要实现MVP？

咱们如何在不使用MVP模式时显示Email列表到Fragment? 一般，咱们须要获取而且合并本地SQL数据库和从IMAP邮件服务器获取的邮件列表，而后将邮件列表绑定到收件箱view中。那么，此时fragment的代码又会是怎么样的呢？咱们须要运行两个AsyncTasks 并 实现一个“等待机制”（等到两个任务将二者的加载数据合并到一个单独的mail列表）。咱们还须要注意的是在加载时要显示加载动画 （ProgressBar），以后用ListView替代。咱们须要把全部的代码放到Fragment中吗？要是加载过程当中出现错误怎么办？屏幕翻转怎么 办？谁来负责撤销AsyncTasks ？这一系列的问题均可以经过MVP获得解决。让咱们跟那些带有上千行大杂烩代码的activity和fragment说拜拜吧

可是，在咱们深刻研究如何将MVP运用到Android中以前，咱们须要弄清楚的一个问题是：Activity或Fragment到底是一个View仍是一个Presenter。Activity或Fragment彷佛既是View也是Presenter，由于它们都有 onCreate() 或onDestroy()之 类的生命周期回调功能，而且它们负责从一个UI控件到另外一个UI 控件的转换（好比在加载时显示ProgressBar，而后显示带有数据的ListView）等View操做。你们可能会以为这里的Activity或 Fragment就是一个Controller，我猜可能也是这么一个初衷。可是在经历了几年的Android应用开发以后，我得出这么一个结论：咱们应 该把Activity或Fragment看做是一个不太智能的View，而不是把它们看做一个Presenter。后文我会给出缘由。

综上，我想给你们介绍一个在Android平台上开发基于MVP的应用的一个 Mosby库。
Mosby

你们能够在Github和Maven Central上找到Mosby库。Mosby分为几个子模块，你们能够根据本身的须要选取组件。咱们来回顾一下最重要的一个模块。

核心模块 ( Core Module)

《老爸老妈浪漫史》中的建筑设计师Ted Mosby想建造一栋摩天大楼。而建造这样一栋宏伟的建筑必须打好坚实的地基。这对Android应用的开发来讲是也是同样的道理。基本上，Core Module 分为两种类型：MosbyActivity 和MosbyFragment。这二者是全部其余activity或fragment子类的基类（至关于建筑的地基）。二者都使用咱们你们所熟知的APT （Annotation Processing Tool）来减小一些样板式代码。MosbyActivity 和MosbyFragment 使 用Butterknife进行view的注入，使用Icepick 将实例状态保存和存储到Bundle中，使用FragmentArgs注入 Fragment参数。咱们不须要再调用Butterknife.inject(this)等插入方法。这类代码已经包含在了MosbyActivity 和 MosbyFragment中。它是即时可用的。咱们须要作的就是使用子类中相应的注解。核心模块与MVP没有关联，它只是写一个大型软件的基础。

MVP模块( MVP Module )

Mosby库中的MVP模块使用泛型来确保类型安全。全部view的基类是MvpView。从根本上说这只是一个空的interface 。Presenter的基类是MvpPresenter：

public interface MvpView{}

public interface MvpPresenter<V extends MvpView>{
    public void attachView(V view);
    public void detachView(boolean retainInstance);
}

上文提到，咱们把Activity和Fragment看作View。所以Mosby库的MVP模块提供了 属于MvpViews 的MvpActivity和MvpFragment做为Activity和Fragment的基类。

public abstract class MvpActivity<P extends MvpPresenter> extends MosbyActivity implements MvpView{

    protected P presenter;
    @Override  protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        presenter = createPresenter();
        presenter.attachView(this);
        super.onDestroy();
        presenter.detachView(false);
    }

    protected abstract PcreatePresenter();
}

public abstract class MvpFragment<P extends MvpPresenter> MosbyFragment implements MvpView{
    protected Ppresenter;

    @Override public void onViewCreated(View view,@Nullable Bundle savedInstanceState){
        super.onViewCreated(view,savedInstanceState);
        // Create the presenter if needed
        if(presenter == null){
            presenter = createPresenter();
        }
        presenter.attachView(this);
    }

    @Override public void onDestroyView(){
        super.onDestroyView();
        presenter.detachView(getRetainInstance());
    }

    protected abstract PcreatePresenter();
    }
}

@Override protected void onDestroy(){

这一理念主要是一个MvpView (也就是Fragment or Activity)会关联一个MvpPresenter，而且管理MbpPresenter的声明周期。你们从上面的代码片断能够看到，Mosby使用Activity和Fragement生命周期来实现这一目的。一般presenter是绑定在该生命周期上的。因此初始化或者清理一些东西等操做（例如撤销异步运行任务）应该在 presenter.onAttach()和 presenter.onDetach() 上进行。咱们稍后会谈到presenter如何使用setRetainInstanceState(true) “避开”Fragment中的生命周期。我相信你们也注意到了， MvpPresenter是一个interface 。MVP模块提供一个 MvpBasePresenter，这个MvpBasePresenter只持有View（是一个Fragment或Activity）的弱引用，从而避免内存泄露。所以，当presenter想要调用view方法时，咱们须要查看isViewAttached() 并使用getView()来获取引用，以检查view是否链接到了presenter。

Loading-Content-Error (LCE)

一般Fragment会一直重复作某一件事。它在后台加载数据，同时显示加载view（即ProgressBar），并在屏幕上显示加载的数据，或 者当加载失败时显示view错误。现在，下拉刷新支持很容易实现，由于SwipeRefreshLayout是Android支持库的组成部分。为了不 重复执行这一工做流，Mosby库的MVP模块提供了MvpLceView。

public interface MvpLceView<M> extends MvpView{
    /**
       * 显示一个加载中的视图
       * loading view 必须有个id 为 R.id.loadingView的View
       * @param pullToRefresh 若是是true,那么表示下拉刷新被触发了
       */
    public void showLoading(boolean pullToRefresh);
    /**
       * 显示 content view.
       * <content view 的id必须是R.id.contentView
       */
    public void showContent();

      /**
       * 显示错误信息
       */
    public void showError(Throwable e,boolean pullToRefresh);

    /**
       * The data that should be displayed with {@link #showContent()}
       */
    public void setData(M data);
}

针对那种类型的view咱们能够采用 MvpLceActivity implements MvpLceView 和 MvpLceFragment implements MvpLceView。二者均假设解析的xml布局包括了含有R.id.loadingView,R.id.contentView和R.id.errorView的view。

示例
接下来要举的例子Github上也有中，咱们使用CountriesAsyncLoader加载一系列的Country，并将其显示在Fragment的RecyclerView中。你们能够从这个连接https://db.tt/ycrCwt1L下载。

首先咱们要定义CountriesView这一view interface 。

public interface CountriesView extends MvpLceView<List<Country>>{
}

为何要为View定义接口呢？
1.由于定义了这个接口以后咱们能够更改view的实现。咱们能够简单地把代码从一个继承自 Activity的实现转移到继承自 Fragment的实现。

2.模块性：咱们能够移动独立的库项目中的整个业务逻辑层、Presenter以及View 接口，而后把这个包含了Presenter的库应用到各种app当中。下图中左侧是使用了嵌入在ViewPager中的Activity的kicker app，以及使用嵌入在ViewPager中的Fragment的meinVerein app，如图1-5。 二者采用的是同一个定义了View接口和Presenter且测试了单元的库。

因为咱们能够经过执行view接口来模拟view，因此咱们能够很容易地编写单元测试。还有一个更简单的方法就是在presenter中引入java接口并使用模拟presenter对象来编写单元测试。
还有一个良性反作用就是，定义了view接口以后，咱们不用直接从presenter再回调activity/fragment方法。咱们这样区分开来是 由于在执行presenter时咱们在IDE自动完成上看到的方法只是关于view接口的方法。就我我的体会来讲，我以为这个方法很是有用，特别是团队一 起工做的时候。须要注意的是，除了定义一个CountriesView接口以外，咱们还能够采用MvpLceView<List> 。可是，定义一个专门的接口能够提升代码可读性，而且未来能够灵活地定义更多其余的与View相关的方法。

Next we define our views xml layout file with the required ids:

下一步咱们须要按照指定的id来定义view xml 布局文件.

<FrameLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
>

    <!-- Loading View -->
    <ProgressBar
    android:id="@+id/loadingView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:indeterminate="true"
    />

    <!-- Content View -->
    <android.support.v4.widget.SwipeRefreshLayout
    android:id="@+id/contentView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >

    <android.support.v7.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
    />

    </android.support.v4.widget.SwipeRefreshLayout>


    <!-- Error view -->
    <TextView
        android:id="@+id/errorView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
    />

</FrameLayout>

CountriesPresenter控制CountriesView并运行CountriesAsyncLoader。

public class CountriesPresenter extends MvpBasePresenter<CountriesView>{

    @Override 
    public void loadCountries(final boolean pullToRefresh){
        getView().showLoading(pullToRefresh);

        CountriesAsyncLoader countriesLoader = new CountriesAsyncLoader(
        new CountriesAsyncLoader.CountriesLoaderListener(){

        @Override public void onSuccess(List<Country> countries){

            if(isViewAttached()){
                getView().setData(countries);
                getView().showContent();
            }
        }

        @Override public void onError(Exception e){

            if(isViewAttached()){
                getView().showError(e,pullToRefresh);
            }
        }
    });

        countriesLoader.execute();
    }
}

实现CountriesView接口 的CountriesFragment 以下所示：

public class CountriesFragment
 extends MvpLceFragment<SwipeRefreshLayout,List<Country>,CountriesView,CountriesPresenter>
 implements CountriesView,SwipeRefreshLayout.OnRefreshListener{

    @InjectView(R.id.recyclerView)RecyclerViewrecyclerView;
    CountriesAdapteradapter;

    @Override public void onViewCreated(View view,@Nullable Bundle savedInstance){
    super.onViewCreated(view,savedInstance);

        // Setup contentView == SwipeRefreshView
        contentView.setOnRefreshListener(this);

    // Setup recycler view
        adapter = new CountriesAdapter(getActivity());
        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
        recyclerView.setAdapter(adapter);
        loadData(false);
    }

    public void loadData(boolean pullToRefresh){
        presenter.loadCountries(pullToRefresh);
    }

    @Override protected CountriesPresenter createPresenter(){
        return new SimpleCountriesPresenter();
    }

    // Just a shorthand that will be called in onCreateView()
    @Override protected int getLayoutRes(){
        return R.layout.countries_list;
    }

    @Override public void setData(List<Country> data){
        adapter.setCountries(data);
        adapter.notifyDataSetChanged();
    }

    @Override public void onRefresh(){
        loadData(true);
    }
}

代码数量也并非不少嘛，对吧？这是由于基类已经执行了从加载view到content view或error view的转换。咱们可能第一眼看到那一列MvpLceFragment类属参数会以为灰心。可是我要解释一下：第一种类属参数表明的是content view的类型；第二种是指以fragment显示的Model；第三种是View接口;最后一种是Presenter的类型。总结起来就是：MvpLceFragment<AndroidView, Model, View接口, Presenter>。

你们可能还注意到的一个点就是 getLayoutRes()，它是MosbyFragment引入的用于解析xml view布局的速记法。

@Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
    Return  inflater.inflate(getLayoutRes(),container,false);
}

所以，咱们不用重写onCreateView()，只需重写getLayoutRes()。通常来讲，onCreateView()只能建立view而onViewCreated()须要被重写，以便为RecyclerView初始化Adapter等项。所以，千万不要忘记调用super.OnViewCreated()；

ViewState模块

看到这里你们应该大概了解了如何运用Mosby库。Mosby中的ViewState模块能帮助咱们在Android开发中解决一些棘手的难题：处理屏幕旋转。

问：若是把正在运行country这个例子的app并显示了一列country的设备从横屏旋转到竖屏，会出现什么状况？

答：你们到这个视频连接https://youtu.be/9iSBGEIZmUw中看看，结果是一个新的 CountriesFragment会被实例化，app开始显示ProgressBar（并从新加载country列表）而再也不在RecyclerView中显示country列表（屏幕旋转前的状态）

Mosby引入了ViewState来解决这个问题。原理就是，咱们跟踪presenter从关联的View中调用的方法。好比，presenter调用的是view.showContent()，一旦showContent()被调用，view就会意识到其状态变动为“showing content”，从而view把这一信息存储到一个ViewState。若是view在方向改变过程当中遭到破坏，那么ViewState 就会被存储到Activity.onSaveInstanceState(Bundle) 或 Fragment.onSaveInstanceState(Bundle) 中，并在Activity.onCreate(Bundle) 或Fragment.onActivityCreated(Bundle)中修复。

因为不是每种数据都能存储在Bundle中，因此不一样的数据类型采用不一样的ViewState 实现：数据类型ArrayList采用ArrayListLceViewState；数据类型Parcelable 采用Parcelable DataLceViewState；数据类型Serializeable采用SerializeableLceViewState。若是使用的是一个可保持( Retaining )的Fragment，那么 ViewState在屏幕旋转时不会被破坏，因此也就不须要存储到Bundle中。所以，它能够存储任何类型的数据。在这种状况下，咱们须要使用RetainingFragmentLceViewState。存储一个ViewState比较容易。因为咱们的架构比较整洁，咱们的View又有接口，ViewState 能够向presenter同样经过调用一样的接口方法来修复相关联的view。举个例子，MvpLceView通常有3种状态，即：显示showContent()，showLoading()和showError()，因此ViewState自己会调用相应的方法来修复view的状态。

那只是一些内部构件。若是你们想编写自定义的ViewState，了解以上内容就够了。ViewStates的使用很是简单。事实上，要把MvpLceFragment 迁移到MvpLceViewStateFragment ，咱们只须要另外执行createViewState() 和 getData()。下面咱们就在CountriesFragment中实践一下吧：

public class CountriesFragment
 extends MvpLceViewStateFragment<SwipeRefreshLayout,List<Country>,CountriesView,CountriesPresenter>
 implements CountriesView,SwipeRefreshLayout.OnRefreshListener{

    @InjectView(R.id.recyclerView)RecyclerView recyclerView;
    CountriesAdapter adapter;

    @Override public LceViewState<List<Country>,CountriesView> createViewState(){
        return new RetainingFragmentLceViewState<List<Country>,CountriesView>(this);
    }

    @Override public List<Country> getData(){
        return adapter == null? null : adapter.getCountries();
    }

    // The code below is the same as before

    @Override public void onViewCreated(Viewview,@Nullable Bundle savedInstance){
    super.onViewCreated(view,savedInstance);

    // Setup contentView == SwipeRefreshView
    contentView.setOnRefreshListener(this);

    // Setup recycler view
        adapter = new CountriesAdapter(getActivity());
        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
        recyclerView.setAdapter(adapter);
        loadData(false);
    }


    public void loadData(boolean pullToRefresh){
        presenter.loadCountries(pullToRefresh);
    }

    @Override protected CountriesPresenter createPresenter(){
        return new SimpleCountriesPresenter();
    }

    // Just a shorthand that will be called in onCreateView()
    @Override protected int getLayoutRes(){
        return R.layout.countries_list;
    }

    @Override public void setData(List<Country> data){
        adapter.setCountries(data);
        adapter.notifyDataSetChanged();
    }

    @Override public void onRefresh(){
        loadData(true);
    }
}

以上就是所有过程啦。咱们没必要更改presenter或其余代码。这里 是一个关于咱们的得到ViewState支持的CountriesFragment的视频。在这个视频中咱们能够看到，view在方位转变以后仍然处于同 样的“状态”，即，view横屏显示country列表，随后横屏显示country列表。View能横屏显示下拉刷新指示，变动为竖屏时也能显示。

自定义ViewState

ViewState确实是一个强大且灵活的概念。看到这里我相信你们都了解了LCE (Loading-Content-Error) ViewState的易用性。下面咱们就一块儿来编写本身的View和ViewState吧。咱们的View只显示两类不一样的数据对象：A和B。结果应该像 这个视频https://youtu.be/9iSBGEIZmUw 中演示的这样：

你们内心确定以为，这也不怎么样啊！别介啊，我只是想演示一下建立本身的ViewState是一件多么容易的事。

View 接口和数据对象（model）以下所示：

public class A implements Parcelable {
    String  name;

    public A(String  name){
        this.name=name;
    }

    public String  getName(){
        return name;
    }
}

public class B implements Parcelable {
    String  foo;

    public B(String  foo){
        this.foo=foo;
    }

    public String  getFoo(){
        return foo;
    }
}

public interface MyCustomView extends MvpView{

    public void showA(A a);

    public void showB(B b);
}

在这个简单的例子中咱们没有加入业务逻辑层。由于咱们假设在实际的app中若是有业务逻辑层的话会使整个生成A或B的操做变得复杂。Presenter以下所示：

public class MyCustomPresenter extends MvpBasePresenter<MyCustomView>{
    Random random = new Random();

    public void doA(){

        A a = new A("My name is A "+random.nextInt(10));

        if(isViewAttached()){
            getView().showA(a);
        }
    }

    public void doB(){
        B b = new B("I am B "+random.nextInt(10));

        if(isViewAttached()){
            getView().showB(b);
        }
    }
}

咱们定义了实现了MyCustomView接口的MyCustomActivity。

public class MyCustomActivity extends MvpViewStateActivity<MyCustomPresenter>
 implements MyCustomView{

    @InjectView(R.id.textViewA) TextViewaView;
    @InjectView(R.id.textViewB) TextViewbView;

    @Override protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.my_custom_view);
    }

    @Override public RestoreableViewState createViewState(){
        return new MyCustomViewState();// Our ViewState implementation
    }

    // Will be called when no view state exist yet,
    // which is the case the first time MyCustomActivity starts
    @Override public void onNew ViewStateInstance(){
        presenter.doA();
    }

    @Override protected MyCustomPresenter createPresenter(){
        return new MyCustomPresenter();
    }

    @Override public void showA(A a){
        MyCustomViewState vs = ((MyCustomViewState)viewState);
        vs.setShowingA(true);
        vs.setData(a);
        aView.setText(a.getName());
        aView.setVisibility(View.VISIBLE);
        bView.setVisibility(View.GONE);
    }

    @Override public void showB(B b){
        MyCustomViewState vs=((MyCustomViewState)viewState);
        vs.setShowingA(false);
        vs.setData(b);
        bView.setText(b.getFoo());
        aView.setVisibility(View.GONE);
        bView.setVisibility(View.VISIBLE);
    }

    @OnClick(R.id.loadA)public void onLoadAClicked(){
        presenter.doA();
    }

    @OnClick(R.id.loadB)public void onLoadBClicked(){
        presenter.doB();
    }
}

因为咱们没有LCE(Loading-Content-Error)，因此不把 MvpLceActivity做为基类。咱们采用的是最广泛的支持 ViewState的MvpViewStateActivity做为基类。基本上咱们的View只显示aView 或 bView。

在onNew ViewStateInstance()中，咱们须要明确在第一个Activity运行时须要作 什么，由于先前并不存在ViewState 例子用于修复。在showA(A a) 和 showB(B b)中，咱们须要将显示A 或 B的信息存储到ViewState。到这一步，咱们就差很少完成了，如今只差MyCustomViewState执行这一 步啦：

ublic class MyCustomViewState implements RestoreableViewState<MyCustomView>{

    private  final String  KEY_STATE="MyCustomViewState-flag";
    private  final String  KEY_DATA="MyCustomViewState-data";

    public boolean showingA=true;// if false, then show B
    public Parcelable  data;// Can be A or B

    @Override public void saveInstanceState(Bundle out){
        out.putBoolean (KEY_STATE,showingA);
        out.putParcelable (KEY_DATA,data);
    }

    @Override public boolean restoreInstanceState(Bundle in){
        if(in==null){
         return false;
        }

        showingA = in.getBoolean (KEY_STATE,true);
        data = in.getParcelable (KEY_DATA);
        return true;
    }

    @Override public void apply(MyCustomView view,boolean retained){

        if(showingA){
            view.showA((A)data);
        }else{
            view.showB((B)data);
        }
    }

    /**
       * @param a true if showing a, false if showing b
       */
    public void setShowingA(boolean a){
        this.showingA=a;
    }

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

你们能够看到，咱们须要把ViewState保存到从Activity.onSaveInstanceState()调用的 saveInstanceState()中，而且在从Activity.onCreate()调用的restoreInstanceState()中修复viewstate的数据。apply()方法将会从Activity中调用以修复view state。咱们像presenter同样经过调用一样的View interface 方法showA() 或 showB()来实现这一操做。

你们能够看到，咱们须要把ViewState保存到从Activity.onSaveInstanceState()调用的 saveInstanceState()中，而且在从Activity.onCreate()调用的restoreInstanceState()中修复viewstate的数据。apply()方法将会从Activity中调用以修复view state。咱们像presenter同样经过调用一样的View interface 方法showA() 或 showB()来实现这一操做。

这个外部的ViewState把view state修复的复杂性和职责从Activity代码中剥离，并入到这个单独的类中。而编写ViewState类的单元测试要比Activity类的单元测试容易得多。

怎样处理后台线程？

一般，Presenter会管理后台线程。Presenter如何处理后台线程取决于它所关联的Activity或者Fragment ，具体分为两种状况：

• 可保持的Fragment : 若是你调用了Fragment的setRetainInstanceState(true)那么这个Fragment在屏幕旋转时就不会被销毁。只有该 Fragment的GUI会被销毁，而且在屏幕旋转时从新调用onCreateView建立视图。这就是说当屏幕旋转时Fragment全部的成员成员变 量和Presenter不会发生变化。在这个示例中，咱们将新的视图关联到Presenter中。所以，Presenter不须要去掉任何正在运行中的后 台任务，由于Presenter已经关联了新的视图。例如:

1.竖屏状况下启动应用
2.实例化Fragment时会调用onCreate()、onCreateView()、createPresenter(), 而后经过调用presenter的attachView()函数将View关联到Presenter中。
3. 下一步咱们旋转手机屏幕，从竖屏切换到横屏；
4. 此时onDestroyView() 会调用，而onDestroyView() 又会调用presenter的detachView(true)函数。 咱们注意到detachView有个参数为true,这是告诉presenter这个Fragment是可持有的Fragment（不然这个参数应该为 false）。经过这个参数，presenter就知道它不须要取消正在运行的后台任务；
5. 应用如今是横屏状态了，在旋转时onCreateView方法会被调用，可是createPresenter()函数不会被调用，由于咱们会对 presenter 进行不为空的判断，当presenter为空时才调用createPresenter()函数。而Fragment的 setRetainInstanceState(true)会保持这个presenter对象，所以presenter此时不会被从新建立；
6. 在调用了presenter的attachView()以后新建立的View会被从新关联到presenter中。
7. ViewState会被恢复，可是没有后台任务会被取消，所以也没有后台任务须要从新启动。

• Activity和不保持的Fragment :在这个示例中工做流很是的简单。全部的东西都会被销毁，包括presenter。所以presenter对象应该取消全部正在运行的任务。例如 :
  咱们采用非保持fragment在竖屏状况下启动app。

8.咱们采用非保持fragment在竖屏状况下启动app。
9.Fragment被实例化以后，调用onCreate()， onCreateView()，和createPresenter()，而后经过调用presenter.attachView()将view（fragment）附着到presenter。
10.下一步咱们旋转设备屏幕，从竖屏切换到横屏。
11.此时onDestroyView() 会调用，而onDestroyView() 又会调用presenter的detachView(true)函数。Presenter取消后台任务。
12. onSaveInstanceState(Bundle)被调用， ViewState被保存到Bundle中。
13. App如今出于横屏状态。新的Fragment被实例化并调用onCreate()，onCreateView()和 createPresenter()来建立一个新的presenter例子，经过调用presenter.attachView()将新的view附着到新的presenter
14. ViewState会从Bundle中恢复，且view的状态也会被恢复。若是ViewState是showLoading，那么presenter会从新启动后台线程来加载数据。
15. 如下是得到ViewState支持的Activity的生命周期图解，如图1-6：

如下是得到ViewState支持的Fragment的生命周期图解， 如图 1-7：

Retrofit模块

Mosby提供了 LceRetrofitPresenter 和 LceCallback。为得到LCE方法showLoading(), showContent() 和 showError()支持的Retrofit编写presenter ，几行代码就能搞定。

public class MembersPresenter extends LceRetrofitPresenter<MembersView,List<User>>{

    private  GithubApigithubApi;

    public MembersPresenter(GithubApi githubApi){
        this.githubApi=githubApi;
    }

    public void loadSquareMembers(boolean pullToRefresh){
        githubApi.getMembers("square",new LceCallback(pullToRefresh));
    }
}

Dagger模块

想在不依靠注入式的状况下写应用？Ted Mosby告诉你，这是行不通滴！Dagger是java依赖注入式框架最经常使用的方法，也是Android开发者们的心头好。Mosby支持 Dagger1。Mosby经过一个叫作getObjectGraph()的方法提供Injector界面。一般，咱们的应用模块很是普遍。要想轻松分享 这一模块，咱们须要把android.app.Application纳入子类，使其执行Injector。以后全部的Activity和 Fragment均可以经过调用getObjectGraph()来存取ObjectGraph，由于DaggerActivity and DaggerFragment也 都是Injector。咱们也能够经过重写Activity 或 Fragment中的 getObjcetGraph() ，从而调用plus(Module)以增长模块。我我的已经用到Dagger2了，它与 Mosby也兼容。你们能够在Github上找到关于Dagger1 和 Dagger2的示例。点此这个连接https://db.tt/3fVqVdAzDagger1示例 apk；点此这个连接https://db.tt/z85y4fSYDagger2 示例 apk。

Rx模块

Observables赞爆了！如今稍微潮一点的小伙儿们都用RxJava了好吗！你猜结果怎么着？RxJava确实是太酷了！因此，Mosby给你们提供一个本质上是Subscriber的MvpLceRxPresenter，它能帮咱们自动处理onNext()， onCompleted() 和 onError()并回调相应的LCE方法，好比showLoading(), shwoContent() 和 showError()。 它还将 RxAndroid 附带到observerOn() Android主要 UI 线程。你可能以为，要是用了RxJava的话就再也不须要Model View Presenter了。呃，那只是你的一家之言。在我看来，把View和Model清晰地区分开来很是重要。并且我也认为其中的某些好用的功能在没有 MVP的状况下不容易执行。最后，你们要是还想回到过去那个Activity和Fragment包含了上千条又臭又长的代码行时代，那么我祝你在面条式代 码的地狱里过得愉快。好了，废话很少说，我介绍的方法不属于面条式代码是由于Observerables引入了一个结构齐整的工做流，把Activity 或Fragment作成一个BLOB的想法已经近在咫尺了。

测试模块

你们可能注意到这里存在着一个测试模块。这个模块用于Mosby库的内部测试。可是，它也能够为咱们本身的app所用。它使用 Robolectric为咱们的LCE Presenter， Activities 和 Fragments提供单元测试模板。它的基本功能是查看测试中的Presenter是否正确工做：经过观察presenter时候调用 showLoading()，
showContent() 和 showError()。咱们还能够验证setData()中的数据。因此咱们能够为Presenter和底层编写相似黑匣子的测试。Mosby的测试模块也提供了测试MvpLceFragment 或 MvpLceActivity的 可能性。它至关于一种“精简版”的UI 测试。这些测试经过查看xml布局是否包含R.id.loadingView， R.id.contentView 和R.id.errorView之类 的指定id、loadingView是否可视，在加载view时，是不是错误的view可视、content view可否处理由setData()提交的已加载数据等方面来检验Fragment或Activity是否正常工做，是否遇到crashing。它和 Espresso类的UI测试并不相同。我以为没有必要为LCE View单独写一个UI 测试。

如下是Ted Mosby库的一些测试小建议：
1. 编写传统的单元测试来测试业务逻辑层和model。
2. 使用MvpLcePresenterTest来测试presenter。
3.使用MvpLceFragmentTest 和 MvpLceActivityTest来测试MvpLceFragment 和 Activity。
4.若是有必要，可使用Espresso来编写UI测试。

测试模块还没有完成。你们能够看到这个模块是测试版，由于Robolectric 3.0还没完成，并且Android gradle plugin也没用彻底支持传统的单元测试。android gradle plugin 1.2应该会好得多。Robolectric 和 androids gradle plugin能够用了。

以后我会再写一篇关于Mosby，Dagger，Retrofit和RxJava单元测试的博客。