Android三种框架的比较——教你认清MVC，MVP和MVVM

最新推荐文章于 2024-06-27 23:02:15 发布
最新推荐文章于 2024-06-27 23:02:15 发布
阅读量4k 收藏 19
点赞数 1
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42442129/article/details/80736265
版权
相信大家对MVC，MVP和MVVM都不陌生，作为三个最耳熟能详的Android框架，它们的应用可以是非常广泛的，但是对于一些新手来说，可能对于区分它们三个都有困难，更别说在实际的项目中应用了，有些时候想用MVP的，代码写着写着就变成了MVC，久而久之就对它们三个的选择产生了恐惧感，如果你也是这样的人群，那么这篇文章可能会对你有很大的帮助，希望大家看完都会有收获吧！

文章重点：

(1)了解并区分MVC，MVP，MVVM。

(2)知道这三种模式在Android中如何使用。

(3)走出data binding的误区。

(4)了解MVP+data binding的开发模式。

源代码：https://github.com/zjutkz/AndroidArchitectureDemo

MVC

MVC，Model View Controller，是软件架构中最常见的一种框架，简单来说就是通过controller的控制去操作model层的数据，并且返回给view层展示，具体见下图

mvc

当用户出发事件的时候，view层会发送指令到controller层，接着controller去通知model层更新数据，model层更新完数据以后直接显示在view层上，这就是MVC的工作原理。

那具体到Android上是怎么样一个情况呢？

大家都知道一个Android工程有什么对吧，有java的class文件，有res文件夹，里面是各种资源，还有类似manifest文件等等。对于原生的Android项目来说，layout.xml里面的xml文件就对应于MVC的view层，里面都是一些view的布局代码，而各种java bean，还有一些类似repository类就对应于model层，至于controller层嘛，当然就是各种activity咯。大家可以试着套用我上面说的MVC的工作原理是理解。比如你的界面有一个按钮，按下这个按钮去网络上下载一个文件，这个按钮是view层的，是使用xml来写的，而那些和网络连接相关的代码写在其他类里，比如你可以写一个专门的networkHelper类，这个就是model层，那怎么连接这两层呢？是通过button.setOnClickListener()这个函数，这个函数就写在了activity中，对应于controller层。是不是很清晰。

大家想过这样会有什么问题吗？显然是有的，不然为什么会有MVP和MVVM的诞生呢，是吧。问题就在于xml作为view层，控制能力实在太弱了，你想去动态的改变一个页面的背景，或者动态的隐藏/显示一个按钮，这些都没办法在xml中做，只能把代码写在activity中，造成了activity既是controller层，又是view层的这样一个窘境。大家回想一下自己写的代码，如果是一个逻辑很复杂的页面，activity或者fragment是不是动辄上千行呢？这样不仅写起来麻烦，维护起来更是噩梦。（当然看过Android源码的同学其实会发现上千行的代码不算啥，一个RecyclerView.class的代码都快上万行了呢。。）

MVC还有一个重要的缺陷，大家看上面那幅图，view层和model层是相互可知的，这意味着两层之间存在耦合，耦合对于一个大型程序来说是非常致命的，因为这表示开发，测试，维护都需要花大量的精力。

正因为MVC有这样那样的缺点，所以才演化出了MVP和MVVM这两种框架。

MVP

MVP作为MVC的演化，解决了MVC不少的缺点，对于Android来说，MVP的model层相对于MVC是一样的，而activity和fragment不再是controller层，而是纯粹的view层，所有关于用户事件的转发全部交由presenter层处理。下面还是让我们看图

mvp

从图中就可以看出，最明显的差别就是view层和model层不再相互可知，完全的解耦，取而代之的presenter层充当了桥梁的作用，用于操作view层发出的事件传递到presenter层中，presenter层去操作model层，并且将数据返回给view层，整个过程中view层和model层完全没有联系。看到这里大家可能会问，虽然view层和model层解耦了，但是view层和presenter层不是耦合在一起了吗？其实不是的，对于view层和presenter层的通信，我们是可以通过接口实现的，具体的意思就是说我们的activity，fragment可以去实现实现定义好的接口，而在对应的presenter中通过接口调用方法。不仅如此，我们还可以编写测试用的View，模拟用户的各种操作，从而实现对Presenter的测试。这就解决了MVC模式中测试，维护难的问题。

当然，其实最好的方式是使用fragment作为view层，而activity则是用于创建view层(fragment)和presenter层(presenter)的一个控制器。

MVVM

MVVM最早是由微软提出的

mvvm

这里要感谢泡在网上的日子，因为前面看到的三张图我都是从它的博客中摘取的，如果有人知道不允许这样做的话请告诉我，我会从我的博客中删除的，谢谢。

从图中看出，它和MVP的区别貌似不大，只不过是presenter层换成了viewmodel层，还有一点就是view层和viewmodel层是相互绑定的关系，这意味着当你更新viewmodel层的数据的时候，view层会相应的变动ui。

我们很难去说MVP和MVVM这两个MVC的变种孰优孰劣，还是要具体情况具体分析。

纸上得来终觉浅，绝知此事要躬行

对于程序员来说，空谈是最没效率的一种方式，相信大家看了我上面对于三种模式的分析，或多或少都会有点云里雾里，下面让我们结合代码来看看。

让我们试想一下下面这个情景，用户点击一个按钮A，获取github上对应公司对应仓库中贡献排行第一的任的名字，然后我们还会有一个按钮B，用户点击按钮B，界面上排行第一的那个人的名字就会换成自己的。

MVC

MVC实现是最简单的。

首先看对应view层的xml文件

[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.      xmlns:tools="http://schemas.android.com/tools"  
  4.      android:layout_width="match_parent"  
  5.      android:layout_height="match_parent"  
  6.      android:id="@+id/container"  
  7.      android:orientation="vertical"  
  8.      tools:context=".ui.view.MainActivity"  
  9.      android:fitsSystemWindows="true">  
  10.    
  11. <Button  
  12.      android:text="get"  
  13.      android:layout_width="match_parent"  
  14.      android:layout_height="wrap_content"  
  15.      android:onClick="get"/>  
  16.    
  17. <Button  
  18.      android:text="change"  
  19.      android:layout_width="match_parent"  
  20.      android:layout_height="wrap_content"  
  21.      android:onClick="change"/>  
  22.    
  23. <TextView  
  24.      android:id="@+id/top_contributor"  
  25.      android:layout_width="match_parent"  
  26.      android:layout_height="match_parent"  
  27.      android:gravity="center"  
  28.      android:textSize="30sp"/>  
  29.    
  30. </LinearLayout>  
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:id="@+id/container"
     android:orientation="vertical"
     tools:context=".ui.view.MainActivity"
     android:fitsSystemWindows="true">
 
<Button
     android:text="get"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:onClick="get"/>
 
<Button
     android:text="change"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:onClick="change"/>
 
<TextView
     android:id="@+id/top_contributor"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:gravity="center"
     android:textSize="30sp"/>
 
</LinearLayout>

很简单，两个Button一个TextView

接着看对应controller层的activity

[java] view plain copy
print ?
  1. public class MainActivity extends AppCompatActivity {  
  2.    
  3. private ProcessDialog dialog;  
  4. private Contributor contributor = new Contributor();  
  5.    
  6. private TextView topContributor;  
  7.    
  8. private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  9.    
  10.      @Override  
  11.      public void onStart() {  
  12.           showProgress();  
  13.      }  
  14.    
  15.      @Override  
  16.      public void onCompleted() {  
  17.      }  
  18.    
  19.      @Override  
  20.      public void onError(Throwable e) {  
  21.    
  22.      }  
  23.    
  24.      @Override  
  25.      public void onNext(Contributor contributor) {  
  26.           MainActivity.this.contributor = contributor;  
  27.    
  28.           topContributor.setText(contributor.login);  
  29.    
  30.           dismissProgress();  
  31.      }  
  32.  };  
  33.    
  34. @Override  
  35. protected void onCreate(Bundle savedInstanceState) {  
  36.      super.onCreate(savedInstanceState);  
  37.      setContentView(R.layout.activity_main);  
  38.      topContributor = (TextView)findViewById(R.id.top_contributor);  
  39. }  
  40.    
  41. public void get(View view){  
  42.      getTopContributor("square", "retrofit");  
  43. }  
  44.    
  45. public void change(View view){  
  46.      contributor.login = "zjutkz";  
  47.    
  48.      topContributor.setText(contributor.login);  
  49. }  
  50.    
  51. public void getTopContributor(String owner,String repo){  
  52.      GitHubApi.getContributors(owner, repo)  
  53.         .take(1)  
  54.         .observeOn(AndroidSchedulers.mainThread())  
  55.         .subscribeOn(Schedulers.newThread())  
  56.         .map(new Func1<List<Contributor>, Contributor>() {  
  57.    
  58.         @Override  
  59.         public Contributor call(List<Contributor> contributors) {  
  60.              return contributors.get(0);  
  61.        }  
  62.    })  
  63.    .subscribe(contributorSub);  
  64. }  
  65.    
  66. public void showProgress(){  
  67.      if(dialog == null){  
  68.           dialog = new ProcessDialog(this);  
  69.      }  
  70.    
  71.      dialog.showMessage("正在加载...");  
  72. }  
  73.    
  74. public void dismissProgress(){  
  75.      if(dialog == null){  
  76.           dialog = new ProcessDialog(this);  
  77.      }  
  78.    
  79.      dialog.dismiss();  
  80. }  
  81. }  
public class MainActivity extends AppCompatActivity {
 
private ProcessDialog dialog;
private Contributor contributor = new Contributor();
 
private TextView topContributor;
 
private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
     @Override
     public void onStart() {
          showProgress();
     }
 
     @Override
     public void onCompleted() {
     }
 
     @Override
     public void onError(Throwable e) {
 
     }
 
     @Override
     public void onNext(Contributor contributor) {
          MainActivity.this.contributor = contributor;
 
          topContributor.setText(contributor.login);
 
          dismissProgress();
     }
 };
 
@Override
protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     topContributor = (TextView)findViewById(R.id.top_contributor);
}
 
public void get(View view){
     getTopContributor("square", "retrofit");
}
 
public void change(View view){
     contributor.login = "zjutkz";
 
     topContributor.setText(contributor.login);
}
 
public void getTopContributor(String owner,String repo){
     GitHubApi.getContributors(owner, repo)
        .take(1)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.newThread())
        .map(new Func1<List<Contributor>, Contributor>() {
 
        @Override
        public Contributor call(List<Contributor> contributors) {
             return contributors.get(0);
       }
   })
   .subscribe(contributorSub);
}
 
public void showProgress(){
     if(dialog == null){
          dialog = new ProcessDialog(this);
     }
 
     dialog.showMessage("正在加载...");
}
 
public void dismissProgress(){
     if(dialog == null){
          dialog = new ProcessDialog(this);
     }
 
     dialog.dismiss();
}
}
我们看一下get()方法中调用的getTopContributor方法

[java] view plain copy
print ?
  1. public void getTopContributor(String owner,String repo){  
  2.      GitHubApi.getContributors(owner, repo)  
  3.           .take(1)  
  4.           .observeOn(AndroidSchedulers.mainThread())  
  5.           .subscribeOn(Schedulers.newThread())  
  6.           .map(new Func1<List<Contributor>, Contributor>() {  
  7.    
  8.                 @Override  
  9.                 public Contributor call(List<Contributor> contributors) {  
  10.                       return contributors.get(0);  
  11.                 }  
  12.            })  
  13.            .subscribe(contributorSub);  
  14. }  
public void getTopContributor(String owner,String repo){
     GitHubApi.getContributors(owner, repo)
          .take(1)
          .observeOn(AndroidSchedulers.mainThread())
          .subscribeOn(Schedulers.newThread())
          .map(new Func1<List<Contributor>, Contributor>() {
 
                @Override
                public Contributor call(List<Contributor> contributors) {
                      return contributors.get(0);
                }
           })
           .subscribe(contributorSub);
}

熟悉rxjava和retrofit的同学应该都明白这是啥意思，如果对这两个开源库不熟悉也没事，可以参考 给 Android 开发者的 RxJava 详解 和 用 Retrofit 2 简化 HTTP 请求 这两篇文章。
对于这里大家只要知道这段代码的意思就是去获取github上owner公司中的repo仓库里贡献排名第一的那个人。贡献者是通过Contributor这个java bean存储的。

[java] view plain copy
print ?
  1. public class Contributor {  
  2.    
  3.      public String login;  
  4.      public int contributions;  
  5.    
  6.      @Override  
  7.      public String toString() {  
  8.           return login + ", " + contributions;  
  9.      }  
  10. }  
public class Contributor {
 
     public String login;
     public int contributions;
 
     @Override
     public String toString() {
          return login + ", " + contributions;
     }
}

很简单，login表示贡献者的名字，contributor表示贡献的次数。

然后通过rxjava的subscriber中的onNext()函数得到这个数据。

[java] view plain copy
print ?
  1. private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  2.    
  3.      @Override  
  4.      public void onStart() {  
  5.           showProgress();  
  6.      }  
  7.    
  8.      @Override  
  9.      public void onCompleted() {  
  10.    
  11.      }  
  12.    
  13.      @Override  
  14.      public void onError(Throwable e) {  
  15.    
  16.      }  
  17.    
  18.      @Override  
  19.      public void onNext(Contributor contributor) {  
  20.           MainActivity.this.contributor = contributor;  
  21.    
  22.           topContributor.setText(contributor.login);  
  23.    
  24.           dismissProgress();  
  25.      }  
  26. };  
private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
     @Override
     public void onStart() {
          showProgress();
     }
 
     @Override
     public void onCompleted() {
 
     }
 
     @Override
     public void onError(Throwable e) {
 
     }
 
     @Override
     public void onNext(Contributor contributor) {
          MainActivity.this.contributor = contributor;
 
          topContributor.setText(contributor.login);
 
          dismissProgress();
     }
};

至于另外那个change按钮的工作大家应该都看得懂，这里不重复了。

好了，我们来回顾一遍整个流程。

首先在xml中写好布局代码。

其次，activity作为一个controller，里面的逻辑是监听用户点击按钮并作出相应的操作。比如针对get按钮，做的工作就是调用GithubApi的方法去获取数据。

GithubApi，Contributor等类则表示MVC中的model层，里面是数据和一些具体的逻辑操作。

说完了流程再来看看问题，还记得我们前面说的吗，MVC在Android上的应用，一个具体的问题就是activity的责任过重，既是controller又是view。这里是怎么体现的呢？看了代码大家发现其中有一个progressDialog，在加载数据的时候显示，加载完了以后取消，逻辑其实是view层的逻辑，但是这个我们没办法写到xml里面啊，包括TextView.setTextView()，这个也一样。我们只能把这些逻辑写到activity中，这就造成了activity的臃肿，这个例子可能还好，如果是一个复杂的页面呢？大家自己想象一下。

MVP

通过具体的代码大家知道了MVC在Android上是如何工作的，也知道了它的缺点，那MVP是如何修正的呢？

这里先向大家推荐github上的一个第三方库，通过这个库大家可以很轻松的实现MVP。好了，还是看代码吧。

首先还是xml

[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.      xmlns:tools="http://schemas.android.com/tools"  
  4.      android:layout_width="match_parent"  
  5.      android:layout_height="match_parent"  
  6.      android:id="@+id/container"  
  7.      android:orientation="vertical"  
  8.      tools:context=".ui.view.MainActivity"  
  9.      android:fitsSystemWindows="true">  
  10.    
  11.      <Button  
  12.           android:text="get"  
  13.           android:layout_width="match_parent"  
  14.           android:layout_height="wrap_content"  
  15.           android:onClick="get"/>  
  16.    
  17.      <Button  
  18.           android:text="change"  
  19.           android:layout_width="match_parent"  
  20.           android:layout_height="wrap_content"  
  21.           android:onClick="change"/>  
  22.    
  23.      <TextView  
  24.           android:id="@+id/top_contributor"  
  25.           android:layout_width="match_parent"  
  26.           android:layout_height="match_parent"  
  27.           android:gravity="center"  
  28.           android:textSize="30sp"/>  
  29.    
  30. </LinearLayout>  
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:id="@+id/container"
     android:orientation="vertical"
     tools:context=".ui.view.MainActivity"
     android:fitsSystemWindows="true">
 
     <Button
          android:text="get"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:onClick="get"/>
 
     <Button
          android:text="change"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:onClick="change"/>
 
     <TextView
          android:id="@+id/top_contributor"
          android:layout_width="match_parent"
          android:layout_height="match_parent"
          android:gravity="center"
          android:textSize="30sp"/>
 
</LinearLayout>

这个和MVC是一样的，毕竟界面的形式是一样的嘛。

接下去，我们看一个接口。

[java] view plain copy
print ?
  1. public interface ContributorView extends MvpView {  
  2.    
  3.      void onLoadContributorStart();  
  4.    
  5.      void onLoadContributorComplete(Contributor topContributor);  
  6.    
  7.      void onChangeContributorName(String name);  
  8. }  
public interface ContributorView extends MvpView {
 
     void onLoadContributorStart();
 
     void onLoadContributorComplete(Contributor topContributor);
 
     void onChangeContributorName(String name);
}

这个接口起什么作用呢？还记得我之前说的吗？MVP模式中，view层和presenter层靠的就是接口进行连接，而具体的就是上面的这个了，里面定义的三个方法，第一个是开始获取数据，第二个是获取数据成功，第三个是改名。我们的view层（activity）只要实现这个接口就可以了。

下面看activity的代码

[java] view plain copy
print ?
  1. public class MainActivity extends MvpActivity<ContributorView,ContributorPresenter> implements ContributorView {  
  2.    
  3.      private ProcessDialog dialog;  
  4.    
  5.      private TextView topContributor;  
  6.    
  7.      @Override  
  8.      protected void onCreate(Bundle savedInstanceState) {  
  9.           super.onCreate(savedInstanceState);  
  10.           setContentView(R.layout.activity_main);  
  11.           topContributor = (TextView)findViewById(R.id.top_contributor);  
  12.      }  
  13.    
  14.      @NonNull  
  15.      @Override  
  16.      public ContributorPresenter createPresenter() {  
  17.           return new ContributorPresenter();  
  18.      }  
  19.    
  20.      public void get(View view){  
  21.           getPresenter().get("square", "retrofit");  
  22.      }  
  23.    
  24.      public void change(View view){  
  25.           getPresenter().change();  
  26.      }  
  27.    
  28.      @Override  
  29.      public void onLoadContributorStart() {  
  30.           showProgress();  
  31.      }  
  32.    
  33.      @Override  
  34.      public void onLoadContributorComplete(Contributor contributor) {  
  35.    
  36.           topContributor.setText(contributor.toString());  
  37.    
  38.           dismissProgress();  
  39.      }  
  40.    
  41.      @Override  
  42.      public void onChangeContributorName(String name) {  
  43.           topContributor.setText(name);  
  44.      }  
  45.    
  46.      public void showProgress(){  
  47.           if(dialog == null){  
  48.                dialog = new ProcessDialog(this);  
  49.           }  
  50.    
  51.           dialog.showMessage("正在加载...");  
  52.      }  
  53.    
  54.      public void dismissProgress(){  
  55.           if(dialog == null){  
  56.                 dialog = new ProcessDialog(this);  
  57.           }  
  58.    
  59.           dialog.dismiss();  
  60.      }  
  61. }  
public class MainActivity extends MvpActivity<ContributorView,ContributorPresenter> implements ContributorView {
 
     private ProcessDialog dialog;
 
     private TextView topContributor;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          topContributor = (TextView)findViewById(R.id.top_contributor);
     }
 
     @NonNull
     @Override
     public ContributorPresenter createPresenter() {
          return new ContributorPresenter();
     }
 
     public void get(View view){
          getPresenter().get("square", "retrofit");
     }
 
     public void change(View view){
          getPresenter().change();
     }
 
     @Override
     public void onLoadContributorStart() {
          showProgress();
     }
 
     @Override
     public void onLoadContributorComplete(Contributor contributor) {
 
          topContributor.setText(contributor.toString());
 
          dismissProgress();
     }
 
     @Override
     public void onChangeContributorName(String name) {
          topContributor.setText(name);
     }
 
     public void showProgress(){
          if(dialog == null){
               dialog = new ProcessDialog(this);
          }
 
          dialog.showMessage("正在加载...");
     }
 
     public void dismissProgress(){
          if(dialog == null){
                dialog = new ProcessDialog(this);
          }
 
          dialog.dismiss();
     }
}

get()和change()这两个方法是我们点击按钮以后执行的，可以看到，里面完完全全没有任何和model层逻辑相关的东西，只是简单的委托给了presenter，那我们再看看presenter层做了什么

[java] view plain copy
print ?
  1. public class ContributorPresenter extends MvpBasePresenter<ContributorView> {  
  2.    
  3.      private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  4.    
  5.      @Override  
  6.      public void onStart() {  
  7.           ContributorView view = getView();  
  8.           if(view != null){  
  9.                view.onLoadContributorStart();  
  10.           }  
  11.      }  
  12.    
  13.      @Override  
  14.      public void onCompleted() {  
  15.    
  16.      }  
  17.    
  18.      @Override  
  19.      public void onError(Throwable e) {  
  20.    
  21.      }  
  22.    
  23.      @Override  
  24.      public void onNext(Contributor topContributor) {  
  25.           ContributorView view = getView();  
  26.           if(view != null){  
  27.                view.onLoadContributorComplete(topContributor);  
  28.           }  
  29.       }  
  30.  };  
  31.    
  32. public void get(String owner,String repo){  
  33.      GitHubApi.getContributors(owner, repo)  
  34.            .take(1)  
  35.            .observeOn(AndroidSchedulers.mainThread())  
  36.            .subscribeOn(Schedulers.newThread())  
  37.            .map(new Func1<List<Contributor>, Contributor>() {  
  38.    
  39.                  @Override  
  40.                  public Contributor call(List<Contributor> contributors) {  
  41.                        return contributors.get(0);  
  42.                  }  
  43.             })  
  44.             .subscribe(contributorSub);  
  45.        }  
  46.    
  47.        public void change(){  
  48.             ContributorView view = getView();  
  49.             if(view != null){  
  50.                   view.onChangeContributorName("zjutkz");  
  51.             }  
  52.       }  
  53. }  
public class ContributorPresenter extends MvpBasePresenter<ContributorView> {
 
     private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
     @Override
     public void onStart() {
          ContributorView view = getView();
          if(view != null){
               view.onLoadContributorStart();
          }
     }
 
     @Override
     public void onCompleted() {
 
     }
 
     @Override
     public void onError(Throwable e) {
 
     }
 
     @Override
     public void onNext(Contributor topContributor) {
          ContributorView view = getView();
          if(view != null){
               view.onLoadContributorComplete(topContributor);
          }
      }
 };
 
public void get(String owner,String repo){
     GitHubApi.getContributors(owner, repo)
           .take(1)
           .observeOn(AndroidSchedulers.mainThread())
           .subscribeOn(Schedulers.newThread())
           .map(new Func1<List<Contributor>, Contributor>() {
 
                 @Override
                 public Contributor call(List<Contributor> contributors) {
                       return contributors.get(0);
                 }
            })
            .subscribe(contributorSub);
       }
 
       public void change(){
            ContributorView view = getView();
            if(view != null){
                  view.onChangeContributorName("zjutkz");
            }
      }
}

其实就是把刚才MVC中activity的那部分和model层相关的逻辑抽取了出来，并且在相应的时机调用ContributorView接口对应的方法，而我们的activity是实现了这个接口的，自然会走到对应的方法中。

好了，我们来捋一捋。

首先，和MVC最大的不同，MVP把activity作为了view层，通过代码也可以看到，整个activity没有任何和model层相关的逻辑代码，取而代之的是把代码放到了presenter层中，presenter获取了model层的数据之后，通过接口的形式将view层需要的数据返回给它就OK了。

这样的好处是什么呢？首先，activity的代码逻辑减少了，其次，view层和model层完全解耦，具体来说，如果你需要测试一个http请求是否顺利，你不需要写一个activity，只需要写一个java类，实现对应的接口，presenter获取了数据自然会调用相应的方法，相应的，你也可以自己在presenter中mock数据，分发给view层，用来测试布局是否正确。

MVVM

首先在看这段内容之前，你需要保证你对data binding框架有基础的了解。不了解的同学可以去看下这篇文章。在接下去让我们开始探索MVVM，MVVM最近在Android上可谓十分之火，最主要的原因就是谷歌推出了data binding这个框架，可以轻松的实现MVVM。但是，我在网上查阅关于Android的data binding资料的时候，发现国内有很多人都误解了，首先，我们从一篇错误的文章开始。当然我在这里引用这篇文章也是对事不对人，如果对文章的作者产生了不好的影响我这里说一声抱歉。

上面那篇文章是一个关于data binding的使用，看起来很美好，但是，其中有一个错误可以说是非常，非常，非常严重的。

blob.png

它竟然说data binding的viewmodel层是binding类，其实不止是这篇文章，其他有一些开发者写的关于data binding的文章里都犯了一样的错误。大家如果也有这样的概念，请务必纠正过来！！

说完了错误的概念，那data binding中真正的viewmodel是什么呢？我们还是以之前MVC，MVP的那个例子做引导。

首先是view层，这没啥好说的，和MVP一样，view层就是xml和activity。

[html] view plain copy
print ?
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.       xmlns:tools="http://schemas.android.com/tools"  
  4.       android:layout_width="match_parent"  
  5.       android:layout_height="match_parent"  
  6.       android:id="@+id/container"  
  7.       android:orientation="vertical"  
  8.       tools:context=".ui.view.MainActivity"  
  9.       android:fitsSystemWindows="true">  
  10.    
  11.       <Button  
  12.             android:text="get"  
  13.             android:layout_width="match_parent"  
  14.             android:layout_height="wrap_content"  
  15.             android:onClick="get"/>  
  16.    
  17.       <Button  
  18.             android:text="change"  
  19.             android:layout_width="match_parent"  
  20.             android:layout_height="wrap_content"  
  21.             android:onClick="change"/>  
  22.    
  23.      <TextView  
  24.             android:id="@+id/top_contributor"  
  25.             android:layout_width="match_parent"  
  26.             android:layout_height="match_parent"  
  27.             android:gravity="center"  
  28.             android:textSize="30sp"/>  
  29.    
  30. </LinearLayout>  
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:tools="http://schemas.android.com/tools"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:id="@+id/container"
      android:orientation="vertical"
      tools:context=".ui.view.MainActivity"
      android:fitsSystemWindows="true">
 
      <Button
            android:text="get"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="get"/>
 
      <Button
            android:text="change"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="change"/>
 
     <TextView
            android:id="@+id/top_contributor"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center"
            android:textSize="30sp"/>
 
</LinearLayout>

[java] view plain copy
print ?
  1. public class MainActivity extends AppCompatActivity {  
  2.    
  3.      private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  4.    
  5.           @Override  
  6.           public void onStart() {  
  7.                showProgress();  
  8.           }  
  9.    
  10.           @Override  
  11.           public void onCompleted() {  
  12.    
  13.           }  
  14.    
  15.           @Override  
  16.           public void onError(Throwable e) {  
  17.    
  18.           }  
  19.    
  20.           @Override  
  21.           public void onNext(Contributor contributor) {  
  22.                binding.setContributor(contributor);  
  23.    
  24.                dismissProgress();  
  25.           }  
  26.      };  
  27.    
  28.      private ProcessDialog dialog;  
  29.    
  30.      private MvvmActivityMainBinding binding;  
  31.    
  32.      @Override  
  33.      protected void onCreate(Bundle savedInstanceState) {  
  34.            super.onCreate(savedInstanceState);  
  35.            binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);  
  36.      }  
  37.    
  38.      public void get(View view){  
  39.           getContributors("square", "retrofit");  
  40.      }  
  41.    
  42.      public void change(View view){  
  43.           if(binding.getContributor() != null){  
  44.                  binding.getContributor().setLogin("zjutkz");  
  45.           }  
  46.      }  
  47.    
  48.      public void showProgress(){  
  49.           if(dialog == null){  
  50.                 dialog = new ProcessDialog(this);  
  51.           }  
  52.    
  53.           dialog.showMessage("正在加载...");  
  54.      }  
  55.    
  56.      public void dismissProgress(){  
  57.           if(dialog == null){  
  58.                 dialog = new ProcessDialog(this);  
  59.           }  
  60.    
  61.           dialog.dismiss();  
  62.      }  
  63.    
  64.      public void getContributors(String owner,String repo){  
  65.            GitHubApi.getContributors(owner, repo)  
  66.                 .take(1)  
  67.                 .observeOn(AndroidSchedulers.mainThread())  
  68.                 .subscribeOn(Schedulers.newThread())  
  69.                 .map(new Func1<List<Contributor>, Contributor>() {  
  70.    
  71.                      @Override  
  72.                      public Contributor call(List<Contributor> contributors) {  
  73.                           return contributors.get(0);  
  74.                      }  
  75.             })  
  76.            .subscribe(contributorSub);  
  77.      }  
  78. }  
public class MainActivity extends AppCompatActivity {
 
     private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
          @Override
          public void onStart() {
               showProgress();
          }
 
          @Override
          public void onCompleted() {
 
          }
 
          @Override
          public void onError(Throwable e) {
 
          }
 
          @Override
          public void onNext(Contributor contributor) {
               binding.setContributor(contributor);
 
               dismissProgress();
          }
     };
 
     private ProcessDialog dialog;
 
     private MvvmActivityMainBinding binding;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);
     }
 
     public void get(View view){
          getContributors("square", "retrofit");
     }
 
     public void change(View view){
          if(binding.getContributor() != null){
                 binding.getContributor().setLogin("zjutkz");
          }
     }
 
     public void showProgress(){
          if(dialog == null){
                dialog = new ProcessDialog(this);
          }
 
          dialog.showMessage("正在加载...");
     }
 
     public void dismissProgress(){
          if(dialog == null){
                dialog = new ProcessDialog(this);
          }
 
          dialog.dismiss();
     }
 
     public void getContributors(String owner,String repo){
           GitHubApi.getContributors(owner, repo)
                .take(1)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.newThread())
                .map(new Func1<List<Contributor>, Contributor>() {
 
                     @Override
                     public Contributor call(List<Contributor> contributors) {
                          return contributors.get(0);
                     }
            })
           .subscribe(contributorSub);
     }
}

如果你对data binding框架是有了解的，上面的代码你能轻松的看懂。

那model层又是什么呢？当然就是那些和数据相关的类，GithubApi等等。

重点来了，viewmodel层呢？好吧，viewmodel层就是是Contributor类！大家不要惊讶，我慢慢的来说。

[java] view plain copy
print ?
  1. public class Contributor extends BaseObservable{  
  2.    
  3. private String login;  
  4. private int contributions;  
  5.    
  6. @Bindable  
  7. public String getLogin(){  
  8.       return login;  
  9. }  
  10.    
  11. @Bindable  
  12. public int getContributions(){  
  13.       return contributions;  
  14. }  
  15.    
  16. public void setLogin(String login){  
  17.      this.login = login;  
  18.      notifyPropertyChanged(BR.login);  
  19. }  
  20.    
  21. public void setContributions(int contributions){  
  22.      this.contributions = contributions;  
  23.      notifyPropertyChanged(BR.contributions);  
  24. }  
  25.    
  26. @Override  
  27. public String toString() {  
  28.      return login + ", " + contributions;  
  29. }  
  30. }  
public class Contributor extends BaseObservable{
 
private String login;
private int contributions;
 
@Bindable
public String getLogin(){
      return login;
}
 
@Bindable
public int getContributions(){
      return contributions;
}
 
public void setLogin(String login){
     this.login = login;
     notifyPropertyChanged(BR.login);
}
 
public void setContributions(int contributions){
     this.contributions = contributions;
     notifyPropertyChanged(BR.contributions);
}
 
@Override
public String toString() {
     return login + ", " + contributions;
}
}

我们可以看到，Contributor和MVP相比，继承自了BaseObservable，有基础的同学都知道这是为了当Contributor内部的variable改变的时候ui可以同步的作出响应。

我为什么说Contributor是一个viewmodel呢。大家还记得viewmodel的概念吗？view和viewmodel相互绑定在一起，viewmodel的改变会同步到view层，从而view层作出响应。这不就是Contributor和xml中那些组件元素的关系吗？所以，大家不要被binding类迷惑了，data binding框架中的viewmodel是自己定义的那些看似是model类的东西！比如这里的Contributor！

话说到这里，那binding类又是什么呢？其实具体对应到之前MVVM的那张图就很好理解了，我们想一下，binding类的工作是什么？

[java] view plain copy
print ?
  1. binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);  
  2.    
  3. binding.setContributor(contributor);  
binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);
 
binding.setContributor(contributor);

首先，binding要通过DataBindingUtil.setContentView()方法将xml，也就是view层设定。

接着，通过setXXX()方法将viewmodel层注入进去。

由于这两个工作，view层(xml的各个组件)和viewmodel层(contributor)绑定在了一起。

好了，大家知道了吗，binding类，其实就是上图中view和viewmodel中间的那根线啊！！

真理在荒谬被证实以前，都只是暗室里的装饰

前面讨论了MVC，MVP和MVVM具体的实现方案，大家肯定都了解了它们三者的关系和使用方式。但是，这里我想说，不要把一个框架看作万能的，其实MVP和MVVM都是有自己的缺陷的！下面我一一来说。

MVP

MVP的问题在于，由于我们使用了接口的方式去连接view层和presenter层，这样就导致了一个问题，如果你有一个逻辑很复杂的页面，你的接口会有很多，十几二十个都不足为奇。想象一个app中有很多个这样复杂的页面，维护接口的成本就会非常的大。

这个问题的解决方案就是你得根据自己的业务逻辑去斟酌着写接口。你可以定义一些基类接口，把一些公共的逻辑，比如网络请求成功失败，toast等等放在里面，之后你再定义新的接口的时候可以继承自那些基类，这样会好不少。

MVVM

MVVM的问题呢，其实和MVC有一点像。data binding框架解决了数据绑定的问题，但是view层还是会过重，大家可以看我上面那个MVVM模式下的activity

[java] view plain copy
print ?
  1. public class MainActivity extends AppCompatActivity {  
  2.    
  3.      private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  4.    
  5.          @Override  
  6.          public void onStart() {  
  7.               showProgress();  
  8.          }  
  9.    
  10.          @Override  
  11.          public void onCompleted() {  
  12.    
  13.          }  
  14.    
  15.          @Override  
  16.          public void onError(Throwable e) {  
  17.    
  18.          }  
  19.    
  20.          @Override  
  21.          public void onNext(Contributor contributor) {  
  22.               binding.setContributor(contributor);  
  23.    
  24.               dismissProgress();  
  25.          }  
  26.      };  
  27.    
  28.      private ProcessDialog dialog;  
  29.    
  30.      private MvvmActivityMainBinding binding;  
  31.    
  32.      @Override  
  33.      protected void onCreate(Bundle savedInstanceState) {  
  34.            super.onCreate(savedInstanceState);  
  35.            binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);  
  36.      }  
  37.    
  38.      public void get(View view){  
  39.           getContributors("square", "retrofit");  
  40.      }  
  41.    
  42.      public void change(View view){  
  43.           if(binding.getContributor() != null){  
  44.                 binding.getContributor().setLogin("zjutkz");  
  45.           }  
  46.      }  
  47.    
  48.      public void showProgress(){  
  49.           if(dialog == null){  
  50.                 dialog = new ProcessDialog(this);  
  51.           }  
  52.    
  53.           dialog.showMessage("正在加载...");  
  54.     }  
  55.    
  56.     public void dismissProgress(){  
  57.          if(dialog == null){  
  58.                dialog = new ProcessDialog(this);  
  59.          }  
  60.    
  61.          dialog.dismiss();  
  62.     }  
  63.    
  64.     public void getContributors(String owner,String repo){  
  65.          GitHubApi.getContributors(owner, repo)  
  66.              .take(1)  
  67.              .observeOn(AndroidSchedulers.mainThread())  
  68.              .subscribeOn(Schedulers.newThread())  
  69.              .map(new Func1<List<Contributor>, Contributor>() {  
  70.    
  71.                   @Override  
  72.                   public Contributor call(List<Contributor> contributors) {  
  73.                        return contributors.get(0);  
  74.                  }  
  75.             })  
  76.             .subscribe(contributorSub);  
  77.        }  
  78. }  
public class MainActivity extends AppCompatActivity {
 
     private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
         @Override
         public void onStart() {
              showProgress();
         }
 
         @Override
         public void onCompleted() {
 
         }
 
         @Override
         public void onError(Throwable e) {
 
         }
 
         @Override
         public void onNext(Contributor contributor) {
              binding.setContributor(contributor);
 
              dismissProgress();
         }
     };
 
     private ProcessDialog dialog;
 
     private MvvmActivityMainBinding binding;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           binding = DataBindingUtil.setContentView(this, R.layout.mvvm_activity_main);
     }
 
     public void get(View view){
          getContributors("square", "retrofit");
     }
 
     public void change(View view){
          if(binding.getContributor() != null){
                binding.getContributor().setLogin("zjutkz");
          }
     }
 
     public void showProgress(){
          if(dialog == null){
                dialog = new ProcessDialog(this);
          }
 
          dialog.showMessage("正在加载...");
    }
 
    public void dismissProgress(){
         if(dialog == null){
               dialog = new ProcessDialog(this);
         }
 
         dialog.dismiss();
    }
 
    public void getContributors(String owner,String repo){
         GitHubApi.getContributors(owner, repo)
             .take(1)
             .observeOn(AndroidSchedulers.mainThread())
             .subscribeOn(Schedulers.newThread())
             .map(new Func1<List<Contributor>, Contributor>() {
 
                  @Override
                  public Contributor call(List<Contributor> contributors) {
                       return contributors.get(0);
                 }
            })
            .subscribe(contributorSub);
       }
}

大家有没有发现，activity在MVVM中应该是view层的，但是里面却和MVC一样写了对model的处理。有人会说你可以把对model的处理放到viewmodel层中，这样不是更符合MVVM的设计理念吗？这样确实可以，但是progressDialog的show和dismiss呢？你怎么在viewmodel层中控制？这是view层的东西啊，而且在xml中也没有，我相信会有解决的方案，但是我们有没有一种更加便捷的方式呢？

路漫漫其修远兮，吾将上下而求索

其实，真正的最佳实践都是人想出来的，我们为何不结合一下MVP和MVVM的特点呢？其实谷歌已经做了这样的事，大家可以看下这个。没错，就是MVP+data binding，我们可以使用presenter去做和model层的通信，并且使用data binding去轻松的bind data。还是让我们看代码吧。

首先还是view层。

[html] view plain copy
print ?
  1. <layout xmlns:android="http://schemas.android.com/apk/res/android">  
  2.      <data>  
  3.           <variable name="contributor" type="zjutkz.com.mvpdatabinding.viewmodel.Contributor"/>  
  4.      </data>  
  5.      <LinearLayout  
  6.          android:layout_width="match_parent"  
  7.          android:layout_height="match_parent"  
  8.          android:id="@+id/container"  
  9.          android:orientation="vertical"  
  10.          android:fitsSystemWindows="true">  
  11.    
  12.          <Button  
  13.               android:id="@+id/get"  
  14.               android:text="get"  
  15.               android:layout_width="match_parent"  
  16.               android:layout_height="wrap_content"  
  17.               android:onClick="get"/>  
  18.    
  19.          <Button  
  20.               android:id="@+id/change"  
  21.               android:text="change"  
  22.               android:layout_width="match_parent"  
  23.               android:layout_height="wrap_content"  
  24.               android:onClick="change"/>  
  25.    
  26.         <TextView  
  27.               android:id="@+id/top_contributor"  
  28.               android:layout_width="match_parent"  
  29.               android:layout_height="match_parent"  
  30.               android:gravity="center"  
  31.               android:textSize="30sp"  
  32.               android:text="@{contributor.login}"/>  
  33.      </LinearLayout>  
  34.    
  35. </layout>  
<layout xmlns:android="http://schemas.android.com/apk/res/android">
     <data>
          <variable name="contributor" type="zjutkz.com.mvpdatabinding.viewmodel.Contributor"/>
     </data>
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:id="@+id/container"
         android:orientation="vertical"
         android:fitsSystemWindows="true">
 
         <Button
              android:id="@+id/get"
              android:text="get"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:onClick="get"/>
 
         <Button
              android:id="@+id/change"
              android:text="change"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:onClick="change"/>
 
        <TextView
              android:id="@+id/top_contributor"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:gravity="center"
              android:textSize="30sp"
              android:text="@{contributor.login}"/>
     </LinearLayout>
 
</layout>
[java] view plain copy
print ?
  1. public class MainActivity extends MvpActivity<ContributorView,ContributorPresenter> implements ContributorView {  
  2.    
  3.      private ProcessDialog dialog;  
  4.    
  5.      private ActivityMainBinding binding;  
  6.    
  7.      @Override  
  8.      protected void onCreate(Bundle savedInstanceState) {  
  9.           super.onCreate(savedInstanceState);  
  10.           binding = DataBindingUtil.setContentView(this, R.layout.activity_main);  
  11.      }  
  12.    
  13.      @NonNull  
  14.      @Override  
  15.      public ContributorPresenter createPresenter() {  
  16.           return new ContributorPresenter();  
  17.      }  
  18.    
  19.      public void get(View view){  
  20.           getPresenter().get("square", "retrofit");  
  21.      }  
  22.    
  23.      public void change(View view){  
  24.          if(binding.getContributor() != null){  
  25.               binding.getContributor().setLogin("zjutkz");  
  26.          }  
  27.      }  
  28.    
  29.     @Override  
  30.     public void onLoadContributorStart() {  
  31.         showProgress();  
  32.     }  
  33.    
  34.    @Override  
  35.    public void onLoadContributorComplete(Contributor contributor) {  
  36.        binding.setContributor(contributor);  
  37.        dismissProgress();  
  38.    }  
  39.    
  40.    public void showProgress(){  
  41.        if(dialog == null){  
  42.             dialog = new ProcessDialog(this);  
  43.        }  
  44.    
  45.        dialog.showMessage("正在加载...");  
  46.    }  
  47.    
  48.    public void dismissProgress(){  
  49.        if(dialog == null){  
  50.            dialog = new ProcessDialog(this);  
  51.        }  
  52.    
  53.        dialog.dismiss();  
  54.    }  
  55. }  
public class MainActivity extends MvpActivity<ContributorView,ContributorPresenter> implements ContributorView {
 
     private ProcessDialog dialog;
 
     private ActivityMainBinding binding;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
     }
 
     @NonNull
     @Override
     public ContributorPresenter createPresenter() {
          return new ContributorPresenter();
     }
 
     public void get(View view){
          getPresenter().get("square", "retrofit");
     }
 
     public void change(View view){
         if(binding.getContributor() != null){
              binding.getContributor().setLogin("zjutkz");
         }
     }
 
    @Override
    public void onLoadContributorStart() {
        showProgress();
    }
 
   @Override
   public void onLoadContributorComplete(Contributor contributor) {
       binding.setContributor(contributor);
       dismissProgress();
   }
 
   public void showProgress(){
       if(dialog == null){
            dialog = new ProcessDialog(this);
       }
 
       dialog.showMessage("正在加载...");
   }
 
   public void dismissProgress(){
       if(dialog == null){
           dialog = new ProcessDialog(this);
       }
 
       dialog.dismiss();
   }
}

然后是presenter层
[java] view plain copy
print ?
  1. public class ContributorPresenter extends MvpBasePresenter<ContributorView> {  
  2.    
  3.      private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {  
  4.    
  5.      @Override  
  6.      public void onStart() {  
  7.           ContributorView view = getView();  
  8.           if(view != null){  
  9.                view.onLoadContributorStart();  
  10.           }  
  11.      }  
  12.    
  13.      @Override  
  14.      public void onCompleted() {  
  15.    
  16.     }  
  17.    
  18.     @Override  
  19.     public void onError(Throwable e) {  
  20.    
  21.     }  
  22.    
  23.     @Override  
  24.     public void onNext(Contributor topContributor) {  
  25.         ContributorView view = getView();  
  26.         if(view != null){  
  27.              view.onLoadContributorComplete(topContributor);  
  28.         }  
  29.     }  
  30.  };  
  31.    
  32. public void get(String owner,String repo){  
  33.      GitHubApi.getContributors(owner, repo)  
  34.         .take(1)  
  35.         .observeOn(AndroidSchedulers.mainThread())  
  36.         .subscribeOn(Schedulers.newThread())  
  37.         .map(new Func1<List<Contributor>, Contributor>() {  
  38.    
  39.              @Override  
  40.              public Contributor call(List<Contributor> contributors) {  
  41.                   return contributors.get(0);  
  42.              }  
  43.        })  
  44.        .subscribe(contributorSub);  
  45.     }  
  46. }  
public class ContributorPresenter extends MvpBasePresenter<ContributorView> {
 
     private Subscriber<Contributor> contributorSub = new Subscriber<Contributor>() {
 
     @Override
     public void onStart() {
          ContributorView view = getView();
          if(view != null){
               view.onLoadContributorStart();
          }
     }
 
     @Override
     public void onCompleted() {
 
    }
 
    @Override
    public void onError(Throwable e) {
 
    }
 
    @Override
    public void onNext(Contributor topContributor) {
        ContributorView view = getView();
        if(view != null){
             view.onLoadContributorComplete(topContributor);
        }
    }
 };
 
public void get(String owner,String repo){
     GitHubApi.getContributors(owner, repo)
        .take(1)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.newThread())
        .map(new Func1<List<Contributor>, Contributor>() {
 
             @Override
             public Contributor call(List<Contributor> contributors) {
                  return contributors.get(0);
             }
       })
       .subscribe(contributorSub);
    }
}

model层就是GithubApi等等。

我们使用了data binding框架去节省了类似findViewById和数据绑定的时间，又使用了presenter去将业务逻辑和view层分离。

当然这也不是固定的，你大可以在viewmodel中实现相应的接口，presenter层的数据直接发送到viewmodel中，在viewmodel里更新，因为view和viewmodel是绑定的，这样view也会相应的作出反应。

说到这里，我还是想重复刚才的那句话，最佳实践都是人想出来的，用这些框架根本的原因也是为了尽量低的耦合性和尽量高的可复用性。

转载自：http://www.androidchina.net/4800.html
xiaoyugehang
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
轻量级的mvvm框架-Android开发
05-26
轻量级的mvvm框架Yox与Vue一样，但是比Vue更轻量且易于使用。 关键功能是Yox支持IE6。 QQ组：232021930安装CDN
MVC模式和MVP模式的区别
m0_45217404的博客
11-02 700
1. MVC框架 MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。 1. MVC 编程模式 MVC 是一种使用 MVC（Model View Controller 模型-
Android 设计模式：MVVM 深入浅出
最新发布
u011464172的专栏
06-27 663
MVVM 是一个强大而灵活的设计模式，它能够帮助你构建更易于维护、可扩展、可测试的 Android 应用程序。通过学习和实践 MVVM，你能够更高效地开发高质量的应用程序。
一篇文章讲清楚Android中的MVC、MVP、MVVM架构 （附实现代码）
bugyinyin的博客
02-08 5044
MVC、MVP、MVVM大体上都是把系统划分成3个模块：视图层、业务层、数据层。但是他们的通信方式、数据流动方向不一致，形成了不同的架构。其后面产生的架构都是为了更好的解耦，解决已有架构的不足。每个架构都有自己的优缺点，没有最好的架构，只有最合适的架构。
Android架构之MVC，MVP，MVVM解析
ChenYiRan123456的博客
07-11 1019
Presenter中同时持有View层的interface的引用以及Model层的引用，而View层持有Presenter层引用。当View层某个界面需要展示某些数据的时候，首先会调用Presenter层的引用，通知Presenter层加载数据，然后Presenter层会调用Model层请求数据，当Model层数据加载成功之后会调用Presenter层的回调方法通知Presenter层数据加载情况，最后Presenter层在调用View层的接口将加载后的数据展示给用户。比如说首页，详情页面，播放器页面。
Android 中MVC，MVP，MVVM三者框架对比介绍
yanhuomatou2015的博客
12-16 4134
1.什么是MVC应用框架 MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。 1.1数据关系 (1) View 接受用户交互请求 (2) View 将请求转交给Controller (3) Controller 操作Model进行数据更新 (4) 数据更新之后Model通知View更新
Android MVVM 解读 2.MVC, MVP, MVVM
01-06
你真的理解了MVC, MVP, MVVM吗？ 其中第一篇文章是比较偏理论的分析, 第二篇文章中,在介绍时,包含了一些实际的案例 看完这两篇文章,可以总结如下: 1.1 MVC 1.1.1 类图 1.1.2. 活动图 1.1.3. 依赖关系 Vie
基于Java的Android MVC/MVP/MVVM框架设计源码
05-24
本项目是基于Java的Android MVC/MVP/MVVM框架设计源码，包含428个文件，其中包括316个Java文件、42个XML文件、34个PNG图片文件、15个Gradle文件、8个Markdown文件、3个Gitignore文件、2个TXT文件、2个Properties文件...
Android mvc、mvp、mvvm示例
03-12
在你提供的示例项目中，`MVC+MVP+MVVM`这个压缩包很可能包含了使用这三种模式实现的Android项目实例。通过查看和学习这些示例，开发者可以更直观地理解每种模式的实现方式，以及它们在实际开发中的应用。每个模式都...
android框架 mvc+mvp+mvvm实例
02-13
本文将深入探讨三种常见的设计模式：Model-View-Controller (MVC)，Model-View-Presenter (MVP) 和 Model-View-ViewModel (MVVM)。这三种模式在Android开发中广泛应用于组织代码结构，提高代码复用性和可测试性。 *...
mvc-mvp-mvvm:javascript简单实现mvc mvp mvvm
05-24
在软件开发领域，模型-视图-控制器（MVC）、模型-视图- presenter（MVP）和模型-视图-ViewModel（MVVM）是三种常见的设计模式，尤其是在JavaScript开发中广泛使用。这些模式主要用于分离应用程序的业务逻辑、数据...
android mvc开发模式,Android 开发模式（MVC、MVP、MVVM）
weixin_31143391的博客
05-31 505
MVC、MVP和MVVM都是为了解决界面呈现和逻辑代码分离而出现的开发模式。MVP和MVVM都是在MVC的基础上演化而来。一、MVC模式MVC是Model-View-Controller的简称。Model：模型层，负责处理数据的加载或者存储。View：视图层，负责界面数据的展示，与用户进行交互。Controller：控制器层，负责逻辑业务的处理。MVC关系模型图在MVC里，View是可以直接访问M...
android 架构 MVC 、MVP、 MVVM对比
skyang在路上
05-12 2047
转自Android中的MVC、MVP、MVVM MVC MVC的全称是Model-View-Controller，也就是模型-视图-控制器。 在Android中View层一般由XML布局文件充当。在Model层中我们会进行一些数据处理的工作，比如网络数据请求、数据库操作等。Controller层通常由Activity、Fragment充当，并在其中进行界面、数据相关的业务处理。 可见在Android中，作为Controller的Activity或Fragment主要起到的作用就是解耦，将View和Mod
Android安卓架构MVC、MVP、MVVM模式的概念与区别
m0_74293254的博客
02-17 2730
MVC（Model-View-Controller）、MVP（Model-View-Presenter）、MVVM（Model-View-ViewModel）是三种常见的软件架构模式，它们的目的都是将应用程序的不同部分分离开来，以提高代码的可维护性、可扩展性和可测试性。在 Android 开发中，MVP（Model-View-Presenter）是一种常用的架构模式，它是基于MVC模式的改进，旨在进一步分离应用程序的各个组件，提高代码的可测试性和可维护性。同时，也使得代码更加清晰、简洁，降低了维护成本。
选择恐惧症的福音！教你认清MVC，MVP和MVVM
LightLu
04-15 2194
相信大家对MVC，MVP和MVVM都不陌生，作为三个最耳熟能详的Android框架，它们的应用可以是非常广泛的，但是对于一些新手来说，可能对于区分它们三个都有困难，更别说在实际的项目中应用了，有些时候想用MVP的，代码写着写着就变成了MVC，久而久之就对它们三个的选择产生了恐惧感，如果你也是这样的人群，那么这篇文章可能会对你有很大的帮助，希望大家看完都会有收获吧！ 文章重点： (1)了
MVC、MVP、MVVM模式的概念与区别
小孟来码的博客
09-13 7169
首先MVC，MVP，MVVM都是为了解决UI页面与逻辑代码分离而出现的模式，MVP和MVVM都是MVC的基础上演化而来。他不属于某种语言的框架，只要是有UI页面与逻辑代码我们都可以使用这几种框架去搭建我们的项目。他是一种框架模式。M和V分别指Model层和View层，但其功能会因为框架的不同而变化。Model层是数据模型，用来存储数据；View层是视图，展示Model层的数据。虽然在不同的MV(XX)框架中，Model层和View层的内容可能会有所差别，但是其基础功能不变，变的只是 数据的传输方式。
Android中的MVC和MVP以及MVVM
QYgujingjing的专栏
07-26 300
Android中的MVC和MVP以及MVVM
Android MVC、MVP、MVVM架构模式
5ingwings(SiHao)的博客
11-11 2424
MVC架构模式1 View XML界面 2 Model 数据库，网络的操作 3 Controller Activity 处理业务逻辑 流程： 圈1 用户操作，传送指令到Controller 圈2 Controller完成逻辑处理，对Model的数据进行修改 圈3 model将修改了的数据再传给View
Android 开发架构-MVC MVP MVVM详解
nwu_qilin的博客
03-10 2618
这篇文章我们讲了是什么是架构和三种架构模式MVC、MVP、MVVM的架构思想，最后再讲了三种架构的区别与选择。相信通过这篇文章读者可能对这三种架构有了一定的认识。一个完美的架构模式是一个架构师一生的追求，在使用的时候我们可以多多思考这些架构模式的本质以及背景，想想架构师为什么这么设计，可以帮我们更好地理解架构。全文到此为止。笔者才疏学浅，有不同观点欢迎评论区或私信讨论。如需转载私信告知即可。另外欢迎阅读笔者的个人博客一只修仙的猿的个人博客，更精美的UI，拥有更好的阅读体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值