Android源码设计模式学习笔记-MVC,MVP架构模式

MVC架构模式

MVC全称是Model-View-Controller也就是模型-视图-控制器，MVC是一个框架模式而非设计模式，那么框架模式和设计模式又有什么区别呢？框架模式中会用到设计模式，你可以简单的理解框架面向于一系列相同行为代码的重用，设计则面向的是一系列相同结构代码的重用。

MVC在Android中的应用

Android中对MVC的应用很经典，对Android本身来说，其界面部分的开发就涉及了模型-视图-控制器3者的交互，在Android中视图view层一般采用xml文件进行界面的描述，比如以下一段比较常见的xml布局文件代码

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.huangli.bridgepattern.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

对于模型Model层大多对应于本地的数据文件或网络获取的数据体，很多情况下我们的对数据处理的业务逻辑也会在这一层，Controller层对应的则是Activity.

public class MainActivity extends AppCompatActivity {

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

一般情况下会在Activity中获取数据以及界面元素，并将两者进行绑定. Activity的作用主要是解耦，将视图View和模型Model进行分离，两者在Activity中进行绑定。

MVP架构模式

MVP全称Model View Presenter,之前提到的MVC模式，常常会在Activity中夹杂着业务逻辑，比如说异步请求后再次异步请求，使得Activity变得臃肿， MVP能够有效的降低这种复杂性，MVP可以接触View和Model的耦合，通过Presenter。
MVP可以分离显示层和逻辑层，它们之间使用接口进行通信，降低耦合.

image.png
Presenter-交互中间人
Presenter主要作为沟通View和Model的桥梁，它从Model层检索数据后，返回给View层，使得View和Model之间没有耦合，它将业务逻辑从View角色上抽离出来.
View-用户界面
View通常是指Activity,Fragment或者某个View控件，它含有一个Presenter成员变量。通常View需要实现一个逻辑接口，将View上的操作通过会交给Presenter进行实现，最后，Presenter调用View逻辑接口将结果返回给View元素
Model-数据的存取
对于一个结构化的App来说，Model角色主要是提供数据的存取功能。Presenter需要通过Model层存储，获取数据，Model就像一个数据仓库。更直白的说，Model是封装了数据库DAO或者网络获取数据的角色，或者两种数据获取方式的集合.

这里我们回头看看MVC

image.png

它的问题：
1，可以看出MVC的耦合性是比MVP高的，View是可以和Model互相访问的（例如在一些自定义view中，不依附于Activity去获取数据进行存取）
2，在MVC中Activity是作为Controller的，但是在MVP中Activity就是View层了，在Activity充当Controller过程的时候或多或少会涉及到部分业务逻辑，在MVP中就完全不会出现这种Activity夹杂业务逻辑的情况.
如果使用MVP架构就可以解决掉这种高耦合性的问题。

image.png

我们使用MVP的设计模式去做一个登录的操作，首先我们必须要明确一点的是Presenter是通过接口对View进行操作的，所以我们要设计一套登录接口让Activity继承

public interface IUserLoginView {
    String getUserName();
    String getPassword();
    void clearUserName();
    void clearPassword();
    void showLoading();
    void hideLoading();
    void toMainActivity(User user);
    void showFailedError();
}

接下来是Presenter

public class UserLoginPresenter {
    private IUserLoginView iUserLoginView;
    private IUserBiz userBiz;
    private Handler mHandler = new Handler();

    public UserLoginPresenter(IUserLoginView iUserLoginView) {
        this.iUserLoginView = iUserLoginView;
        userBiz = new UserBiz();
    }

    public void login(){
        iUserLoginView.showLoading();
        userBiz.login(iUserLoginView.getUserName(), iUserLoginView.getPassword(), new OnLoginListener() {
            @Override
            public void loginSuccess(final User user) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        iUserLoginView.toMainActivity(user);
                        iUserLoginView.hideLoading();
                    }
                });
            }

            @Override
            public void loginFail() {
                iUserLoginView.showFailedError();
                iUserLoginView.hideLoading();
            }
        });
    }
}

可以看出来UserLoginPresenter中有一个IUserLoginView的引用，我们操作View就靠它了，接下来是一些业务逻辑相关的代码,也就是Model层

public class User {
    private String username;
    private String password;

    public String getUsername(){
        return username;
    }

    public void setUsername(String username){
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

public interface IUserBiz {
    void login(final String username,final String password, final OnLoginListener loginListener);
}

public interface OnLoginListener {
    void loginSuccess(User user);
    void loginFail();
}

public class UserBiz implements IUserBiz {
    @Override
    public void login(final String username,final String password, final OnLoginListener loginListener) {
        new Thread(){
            @Override
            public void run() {
                super.run();
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if ("zhy".equals(username) && "123".equals(password)){
                    User user = new User();
                    user.setPassword(password);
                    user.setUsername(username);
                    loginListener.loginSuccess(user);
                }else{
                    loginListener.loginFail();
                }
            }
        }.start();
    }
}

最终让Activity继承IUserLoginView，然后初始化UserLoginPresenter.

public class MvpDemoActivity extends Activity implements IUserLoginView {

    private UserLoginPresenter userLoginPresenter;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userLoginPresenter = new UserLoginPresenter(this);
    }

    @Override
    public String getUserName() {
        return null;
    }

    @Override
    public String getPassword() {
        return null;
    }

    @Override
    public void clearUserName() {

    }

    @Override
    public void clearPassword() {

    }

    @Override
    public void showLoading() {

    }

    @Override
    public void hideLoading() {

    }

    @Override
    public void toMainActivity(User user) {

    }

    @Override
    public void showFailedError() {

    }
}

以上就是一个 mvp架构设计的一个登录流程.

MVP与Activity,Fragment的生命周期

mvp有很多优点，易于维护，易于测试，松耦合，复用性高，健壮稳定，易于扩展等. Presenter通常会执行一些耗时操作，这样它把持者Activity就会导致内存泄露。我们可以通过弱引用来解决。

public abstract class BasePresenter<T>{
    protected Reference<T> mViewRef;

    public void attachView(T view){
        mViewRef = new WeakReference<T>(view);
    }

    protected T getView(){
        return mViewRef.get();
    }

    public boolean isViewAttached(){
        return mViewRef != null && mViewRef.get() != null;
    }

    public void detachView(){
        if (mViewRef != null){
            mViewRef.clear();
            mViewRef = null;
        }
    }
}

BasePresenter中把持一个WeakReference，WeakReference用来存放外部View的引用

public abstract class MVPBaseActivity<V,T extends BasePresenter<V>> extends Activity{
    protected T mPresenter;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mPresenter = createPresenter();
        mPresenter.attachView((V)this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mPresenter.detachView();
    }

    protected abstract T createPresenter();
}

MVPBaseActivity用来建立与BasePresenter的关系，最终我们的Activity和Presenter分别继承于它们

public class ActualPresenter extends BasePresenter<IUserLoginView>{
    public ActualPresenter() {
    }
}

public class ActualMVPActivity extends MVPBaseActivity<IUserLoginView,ActualPresenter>{
    @Override
    protected ActualPresenter createPresenter() {
        return null;
    }
}

这里因为BasePresenter维护的是一个Activity的弱引用，所以就不会存在Activity在onDestory后Presenter执行耗时操作Activity不被释放导致内存泄露.

总结

MVP是一个非常值得推荐的设计模式，它带来了可扩展性，可测试性，稳定性，可维护性.