Android MVC MVP MVVM

MVC

MVC

• Controller
  • 用户动作映射成模型更新
  • 选择响应的视图
• View
  • 获取模型数据
  • 模型展示、更新
  • 收集用户行为，发送给控制器
• Model
  • 封装应用程序状态
  • 响应状态查询
  • 通知视图更新

这里将 Controller、View 放在同一级别，主要是为了说明其调用关系，Controller 对 View 是单向调用，Controller 和 View 对 Model 的调用也是单向的，以实箭头表示。Model 将数据传递给 Controller 或者是 View，传递的方式可以是调用的时候返回，也可以是以回调接口的方式传递，这里用虚箭头表示。

在 Android 中，MVC 又各表示什么呢？
Activity 属于控制器，它接收了所有的用户输入请求；layout.xml 等各种界面布局属于视图；各种 bean、repository 等属于模型。不过在 Android 中，也可以把 Activity 也看作视图，它响应用户的输入，从模型层获取数据，进而控制视图的显示与隐藏，主要原因是 xml 没有自处理的能力，只能靠 Activity 来控制，这样就只能把 Activity 和 xml 等都归属于视图，类似在 iOS 中 ViewController 的作用。

在 Android 中使用 MVC 模式，正是因为 Controller 和 View 不清不楚的关系，很容易就写出万能的 Activity 类，业务越复杂，代码量越膨胀，动不动就是上千行。

Model 层可以使用接口来抽象，达到解耦的目的。

• 对于复杂度不高的业务，使用 MVC，代码会比较少，比较直接，也能快速实现
• 对于没有太多合作的业务来说，可以使用 MVC，可以由同一人来实现 View 和 Controller 部分。

MVVM

MVVM 全名是 Model View ViewModel，其本质是在 View 和 Model 之间加入了一层中间层，将 Model 表示为一个可展示的对象，其结构图如下

MVVM

• View
  • 用户动作映射成模型更新
  • 选择响应的视图
  • 获取模型数据
  • 模型展示、更新
• Model
  • 封装应用程序状态
  • 响应状态查询
  • 通知视图更新
• ViewModel
  • 将 Model 层数据适配为 View 层所需要的数据

相对于 MVC 模式，View 层包含了 MVC 中 View、Controller 的职责，Model 的职责并没有发生变化，ViewModel 可以看做是一个适配器，将 Model 层的数据适配成 View 需要展示的数据。

MVVM 是一种设计范例，它也有多种实现方式，业内最多的实现方式是以 data binding 的形式去实现，而且在该设计范例中，更强调数据绑定的作用。谷歌官方实现了 data binding 的框架，下面我们来看看是如何实现的。

//build.gradle
android {

    dataBinding {
        enabled = true
    }
}

在 gradle 的默认设置中加入 data binding 的支持。

View

//activity_home_item.xml


  <-- 相对于 MVC 中的 activity_home_item.xml，这里增加了一个 data 节点，用来声明 Task 对象，将 TextView 的显示字段直接绑定到 Task 对象的 title 字段上 -->
    
        
    
    
         ...
         
        

    

//HomeListAdapter.java
@Override
public View getView(int position, View convertView, ViewGroup parent) {
    ActivityHomeItemBinding binding;//框架生成的 ActivityHomeItemBinding 对象
    Task task = mTasks.get(position);
    if (convertView == null) {
        binding = ActivityHomeItemBinding.inflate(mLayoutInflater, parent, false);
    } else {
        binding = DataBindingUtil.getBinding(convertView);
    }
    binding.setTask(task);//更新的时候直接使用 setTask 即可将数据绑定到视图上
    binding.executePendingBindings();

    return binding.getRoot();
}

这里的实现与 MVC 不同的地方在于不需要再手动将 Task 的 title 字段设置到 ImageView 控件上，框架会自动完成。使用了 data binding 框架，可以减少我们手工去绑定数据的过程，这里只是绑定一个控件，如果在大量控件的情况下，是能提高开发效率的。data binding 框架需要 ViewModel 的支持，下面来看看 ViewModel 是如何实现的。

ViewModel

// Task.java
public final class Task extends BaseObservable {//继承 BaseObservable

    private long mId;
    private String mTitle;

    public Task() {
        this.mId = 0L;
        this.mTitle = "";
    }

    public long getId() {
        return mId;
    }

    public void setId(long id) {
        mId = id;
    }

    @Bindable//被绑定的字段提供一个定义了 @Bindable 注解的 getter 方法
    public String getTitle() {
        return mTitle;
    }

    public void setTitle(String title) {
        mTitle = title;
        notifyPropertyChanged(BR.title);
    }
}

很多文章将 ActivityHomeItemBinding 描述为 ViewModel 对象，是一种错误的说法，ActivityHomeItemBinding 只是一个自动生成的辅助工具类，数据要更新到视图上。xml 文件中的 task.title 在显示时会调用 Task.getTitle 方法。

• MVVM 着重强调数据绑定，使用数据绑定工具，可以提高开发效率
• 抛开 MVVM 这种模式，其数据绑定用在其他模式上也一样实用，可以不把 MVVM 当作一种模式，它只是使用工具代替了人工绑定数据而已

MVP

一般来说，对于有图形界面的客户端软件来说，我们可以简单地分为三层

分层

我们所用的图形界面，看到的是什么？本质上来说就是数据的可视化呈现。这里就正式引入 MVP 概念了，它是 Model View Presenter 的简称，Model 提供数据，View 负责展示，Presenter 负责处理逻辑，它的结构图如下

mvp

和上面的分层一摸一样！在 MVP 里，Presenter 完全把 Model 和 View 进行了分离，主要的程序逻辑在 Presenter 里实现。而且，Presenter 与具体的 View 是没有直接关联的，而是通过定义好的接口进行交互，从而使得在变更 View 时候可以保持 Presenter 的不变，即重用！

从上到下是直接调用，用实箭头表示。从下到上是回调，用虚箭头表示。依赖关系是上层对下层是直接依赖，下层不能依赖上层。

MVP 很好地将 View 与 Model 做了分离，同时 Presenter 也是可以复用的，假设有有两个页面，一个显示列表大纲，一个显示列表详情，如果操作大致一样，那可以复用同一个 Presenter。将 Presenter 的功能做一个最小集的拆分，有利于 Presenter 的复用，同一个视图里面可以同时存在多个 Presenter，每个 Presenter 实现不同的功能，更新不同的区域。总之，在 MVP 架构中，每一层均可以拆分成独立的可复用的组件，因为彼此都可以只是接口依赖。

下面给出一个 MVP 的代码实现的例子。

View

activity_home.xml，activity_home_item.xml 与 MVC一致，不再重复。

//HomeActivity.java
public class HomeActivity extends AppCompatActivity implements HomeContract.View {

    private ListView mList;
    private HomeListAdapter mListAdapter;
  
  private HomeContract.Presenter mPresenter;

    @Override
    public void onCreate(Bundle savedInstanceState) {
       ...
        mList = (ListView)findViewById(R.id.list);

        Context context = getApplicationContext();
        BaseScheduler scheduler = ThreadPoolScheduler.getInstance();
        BaseThread thread = new HandlerThread();

        TaskRepository taskRepository = TaskRepository.getInstance(
                Injection.provideLocalProxy(),
                Injection.provideRemoteProxy());

        mPresenter = new HomePresenter(this, scheduler, thread, taskRepository);
        mPresenter.start();

        mListAdapter = new HomeListAdapter(context, mPresenter);
        mList.setAdapter(mListAdapter);
    }

    @Override
    public void onResume() {
        super.onResume();
        mPresenter.loadTasks(true);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mPresenter.stop();
    }

    @Override
    public void onTasksLoaded(List tasks) {
        mListAdapter.setTasks(tasks);
    }
}

这里创建了一个 HomePresenter 的实例，当然这里也可以使用工厂模式去解耦，类似

public class Injection {
    public static RemoteProxy provideRemoteProxy() {
        return new TaskServerApi();
    }

    public static LocalProxy provideLocalProxy() {
        return new TaskDbApi();
    }
}

HomeActivity 里面只是调用了 HomePresenter 的 loadTasks 方法，以及 start，stop 方法，这里 View 只是对 Presenter 有依赖，对 Model 层是没有依赖的。

public interface BasePresenter {
    void start();
    void stop();
}

public interface BaseView {
    void setPresenter(T presenter);//一个 Presenter 属于一个 View
}

//协议类
public class HomeContract {

    public interface View extends BaseView {
        void onTasksLoaded(List tasks);
        void onTasksNotAvailable();
        void onError(int code, String message);
    }

    public interface Presenter extends BasePresenter {
        void loadTasks(boolean refresh);
    }
}

public class HomePresenter implements HomeContract.Presenter {

    private HomeContract.View mView;
    private Repository mRepository;//Model
    private BaseScheduler mScheduler;
    private BaseThread mMainThread;
    private LoadTask mLoadTask;

    public HomePresenter(HomeContract.View view, BaseScheduler scheduler, BaseThread thread, Repository repository) {
        this.mView = view;//这里传进了view
        this.mScheduler = scheduler;
        this.mMainThread = thread;
        this.mRepository = repository;

        mLoadTask = new LoadTask(mScheduler);
    }

    @Override
    public void loadTasks(boolean refresh) {
        LoadTask.RequestValues requestValues = new LoadTask.RequestValues();
        requestValues.setRefresh(refresh);
        requestValues.setRepository(mRepository);
        mLoadTask.setRequestValues(requestValues);

        mLoadTask.execute(new LoadTask.Callback() {//定义了一个callback来接受Model处理的回调

            @Override
            public void onSuccess(final LoadTask.ResponseValues response) {
                mMainThread.post(new Runnable() {
                    @Override
                    public void run() {
                        List tasks = response.getTasks();
                        if (tasks != null && tasks.size() > 0) {
                            mView.onTasksLoaded(tasks);//通知给view
                        } else {
                            mView.onTasksNotAvailable();
                        }
                    }
                });
            }

            @Override
            public void onError(final int code, final String msg) {
                mMainThread.post(new Runnable() {
                    @Override
                    public void run() {
                        mView.onError(code, msg);
                    }
                });
            }
        }, true);
    }

    @Override
    public void start() {

    }

    @Override
    public void stop() {

    }
}

HomePresenter 是一个具体的实现，它实现了具体的业务逻辑即 loadTasks，并且将结果通过接口 onTasksLoaded 返回给 View 层去做展示。对于 Presenter 来说，View 是它的上一层，只能通过这种回调的方式返回数据，或者做数据更新。

Model

TaskRepository.java 与 MVC 中一致。

//BaseTask.java
public abstract class BaseTask implements Runnable {

    public interface Callback
 {//回调接口
        void onSuccess(P response);
        void onError(int code, String msg);
    }
    public void execute(Callback callback, boolean schedule) {...}
}

//LoadTask.java
public class LoadTask extends BaseTask {

    public static final class RequestValues implements BaseTask.RequestValues {...}

    public static final class ResponseValues implements BaseTask.ResponseValues {...}
       

    }
}
//再使用 refreshTasks 获取服务端数据，传回给 Presenter，它对上层的数据返回也是通过定义的回调函数完成的，即上面的 LoadTask.Callback。

MVP小结

• MVP 是最符合客户端软件分层的架构
• 上层对下层的依赖可以是直接依赖，也可以是接口依赖
• 下层对上层只能是接口依赖
• 使用接口依赖，可以实现各个层的独立测试，也就是 clean 架构的思想。
• MVP 中，每一层都可以拆分成独立的组件，实现复用。一个视图可以包含多个 Presenter，一个 Presenter 的逻辑可以展示在不同的 View 上，因为每一层之间都可以只是接口依赖

最后再重申一遍：架构来源于业务，并没有好坏之分。好的架构是在业务、成本、时间之间取得一个完美的平衡

ref:
深入浅出 MVC、MVVM、MVP
android MVC && MVP && MVVM分析和对比