Android MVP模式

不念不忘少年蓝@ 2022-12-27 08:42 372阅读 0赞

**一、MVP概述**

**MVP，全称 Model-View-Presenter，即模型-视图-层现器。**

MVP是基于MVC的基础发展而来的。MVC，全称Model-View-Controller，即模型-视图-控制器。

View：对应于布局文件

Model：业务逻辑和实体模型

Controllor：对应于Activity

但是View对应于布局文件，其实能做的事情特别少，实际上关于该布局文件中的数据绑定的操作，事件处理的代码都在Activity中，造成了Activity既像View又像Controller，使得Activity变得臃肿。

而当将架构改为MVP以后，Presenter的出现，将Actvity视为View层，Presenter负责完成View层与Model层的交互。现在是这样的：

**View 对应于Activity，负责View的绘制以及与用户交互**

Model 依然是业务逻辑和实体模型

Presenter 负责完成View于Model间的交互

MVP模式通过Presenter实现数据和视图之间的交互，简化了Activity的职责。同时即避免了View和Model的直接联系，又通过Presenter实现两者之间的沟通。

总结：MVP模式减少了Activity的职责，简化了Activity中的代码，将复杂的逻辑代码提取到了Presenter中进行处理，模块职责划分明显，层次清晰。与之对应的好处就是，耦合度更低，更方便的进行测试。

** MVC和MVP的区别**

![3bbf3ab4e19064cc76662db05e113415.png][]

MVC中是允许Model和View进行交互的，而MVP中很明显，Model与View之间的交互由Presenter完成。还有一点就是Presenter与View之间的交互是通过接口的。

还有一点注意：MVC中V对应的是布局文件，MVP中V对应的是Activity。

**二、MVP的简单使用**

大多数MVP模式的示例都使用登录案例进行介绍。因为简单方便，同时能提现出MVP的特点。今天我们也以此例进行学习。 使用MVP的好处之一就是模块职责划分明显，层次清晰。 该例的结构图即可展现此优点。

![96a8b613ac4bf7cf95af544d7500a708.png][]

**1.Model层**

在本例中，M0del层负责对从登录页面获取地帐号密码进行验证（一般需要请求服务器进行验证，本例直接模拟这一过程）。 从上图的包结构图中可以看出，Model层包含内容：

①实体类bean

②接口，表示Model层所要执行的业务逻辑

③接口实现类，具体实现业务逻辑，包含的一些主要方法

下面以代码的形式一一展开。

***①实体类bean***

public class User {
        private String password;
        private String username;
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "password='" + password + '\'' +
                    ", username='" + username + '\'' +
                    '}';
        }
    }

封装了用户名、密码，方便数据传递。

***②接口***

public interface LoginModel {
        void login(User user, OnLoginFinishedListener listener);
    }

其中OnLoginFinishedListener 是presenter层的接口，方便实现回调presenter，通知presenter业务逻辑的返回结果，具体在presenter层介绍。

***③接口实现类***

public class LoginModelImpl implements LoginModel {
        @Override
        public void login(User user, final OnLoginFinishedListener listener) {
            final String username = user.getUsername();
            final String password = user.getPassword();
            new Handler().postDelayed(new Runnable() {
                @Override public void run() {
                    boolean error = false;
                    if (TextUtils.isEmpty(username)){
                        listener.onUsernameError();//model层里面回调listener
                        error = true;
                    }
                    if (TextUtils.isEmpty(password)){
                        listener.onPasswordError();
                        error = true;
                    }
                    if (!error){
                        listener.onSuccess();
                    }
                }
            }, 2000);
        }
    }

实现Model层逻辑：延时模拟登陆（2s），如果用户名或者密码为空则登陆失败，否则登陆成功。

**2.View层**

视图：将Modle层请求的数据呈现给用户。一般的视图都只是包含用户界面(UI)，而不包含界面逻辑，界面逻辑由Presenter来实现。

从上图的包结构图中可以看出，View包含内容：

①接口，上面我们说过Presenter与View交互是通过接口。其中接口中方法的定义是根据Activity用户交互需要展示的控件确定的。

②接口实现类，将上述定义的接口中的方法在Activity中对应实现具体操作。

下面以代码的形式一一展开。

*** ①接口***

public interface LoginView {
        //login是个耗时操作，我们需要给用户一个友好的提示，一般就是操作ProgressBar
        void showProgress();
    
        void hideProgress();
       //login当然存在登录成功与失败的处理，失败给出提示
        void setUsernameError();
    
        void setPasswordError();
       //login成功，也给个提示
        void showSuccess();
    }

上述5个方法都是presenter根据model层返回结果需要view执行的对应的操作。

***②接口实现类***

即对应的登录的Activity，需要实现LoginView接口。

public class LoginActivity extends AppCompatActivity implements LoginView, View.OnClickListener {
        private ProgressBar progressBar;
        private EditText username;
        private EditText password;
        private LoginPresenter presenter;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_login);
            progressBar = (ProgressBar) findViewById(R.id.progress);
            username = (EditText) findViewById(R.id.username);
            password = (EditText) findViewById(R.id.password);
            findViewById(R.id.button).setOnClickListener(this);
           //创建一个presenter对象，当点击登录按钮时，让presenter去调用model层的login()方法，验证帐号密码
            presenter = new LoginPresenterImpl(this);
        }
    
        @Override
        protected void onDestroy() {
            presenter.onDestroy();
            super.onDestroy();
        }
    
        @Override
        public void showProgress() {
            progressBar.setVisibility(View.VISIBLE);
        }
    
        @Override
        public void hideProgress() {
            progressBar.setVisibility(View.GONE);
        }
    
        @Override
        public void setUsernameError() {
            username.setError(getString(R.string.username_error));
        }
    
        @Override
        public void setPasswordError() {
            password.setError(getString(R.string.password_error));
        }
    
        @Override
        public void showSuccess() {
             progressBar.setVisibility(View.GONE);
            Toast.makeText(this,"login success",Toast.LENGTH_SHORT).show();
        }
    
        @Override
        public void onClick(View v) {
            User user = new User();
            user.setPassword(password.getText().toString());
            user.setUsername(username.getText().toString());
            presenter.validateCredentials(user);
        }
    
    }

View层实现Presenter层需要调用的控件操作，方便Presenter层根据Model层返回的结果进行操作View层进行对应的显示。

**3.Presenter层**

Presenter是用作Model和View之间交互的桥梁。 从上图的包结构图中可以看出，Presenter包含内容：

①接口，包含Presenter需要进行Model和View之间交互逻辑的接口，以及上面提到的Model层数据请求完成后回调的接口。

②接口实现类，即实现具体的Presenter类逻辑。

下面以代码的形式一一展开。

***①接口***

public interface OnLoginFinishedListener {
        void onUsernameError();
    
        void onPasswordError();
    
        void onSuccess();
    }

当Model层得到请求的结果，需要回调Presenter层，让Presenter层调用View层的接口方法。

public interface LoginPresenter {
        void validateCredentials(User user);
    
        void onDestroy();
    }

登陆的Presenter 的接口，实现类为LoginPresenterImpl，完成登陆的验证，以及销毁当前view。

***②接口实现类***

public class LoginPresenterImpl implements LoginPresenter, OnLoginFinishedListener {
        private LoginView loginView;
        private LoginModel loginModel;
    
        public LoginPresenterImpl(LoginView loginView) {
            this.loginView = loginView;
            this.loginModel = new LoginModelImpl();
        }
    
        @Override
        public void validateCredentials(User user) {
            if (loginView != null) {
                loginView.showProgress();
            }
    
            loginModel.login(user, this);
        }
    
        @Override
        public void onDestroy() {
            loginView = null;
        }
    
        @Override
        public void onUsernameError() {
            if (loginView != null) {
                loginView.setUsernameError();
                loginView.hideProgress();
            }
        }
    
        @Override
        public void onPasswordError() {
            if (loginView != null) {
                loginView.setPasswordError();
                loginView.hideProgress();
            }
        }
    
        @Override
        public void onSuccess() {
            if (loginView != null) {
                loginView.showSuccess();
            }
        }
    }

由于presenter完成二者的交互，那么肯定需要二者的实现类（通过传入参数，或者new）。

presenter里面有个OnLoginFinishedListener， 其在Presenter层实现，给Model层回调，更改View层的状态， 确保 Model层不直接操作View层。

**三、总结**

MVP模式的整个核心流程：

View与Model并不直接交互，而是使用Presenter作为View与Model之间的桥梁。其中Presenter中同时持有View层的Interface的引用以及Model层的引用，而View层持有Presenter层引用。当View层某个界面需要展示某些数据的时候，首先会调用Presenter层的引用，然后Presenter层会调用Model层请求数据，当Model层数据加载成功之后会调用Presenter层的回调方法通知Presenter层数据加载情况，最后Presenter层再调用View层的接口将加载后的数据展示给用户。

![020b0f07f6a2d40524f5ae39758bd939.png][]

**四、MVP升级版**

通过上面一揽子场景的分析，得出的第一个结论就是MVP的结构太过于繁重，所以为了避免多写重复代码和日后需要进行无意义的修改，在开发前一定要设计好逻辑调用图，这样才能事半功倍。

对于上面经典的通过业务逻辑继承实现包含重复逻辑的方法，其实也可以在一个Presenter中写好完整的逻辑方法，对于不同的Activity需要哪个业务逻辑方法就调用哪个，这样岂不就简单多了。但是从架构设计角度看这种做法是不严谨的，可能存在漏洞，所以为保持软件架构的健壮还是不要偷懒的好。

以上MVP模式，调用View可能引发的空指针异常，举一个例子，在上述MVP架构中的应用请求网络数据时需要等待后台反馈数据后更新界面，但是在请求过程中当前Activity突然因为某种原因被销毁，Presenter收到后台反馈并调用View接口处理UI逻辑时由于Activity已经被销毁，就会引发空指针异常。

想要避免这种情况的发生就需要每次调用View前都知道宿主Activity的生命状态。

之前是在Presenter的构造方法中得到View接口的引用，现在我们需要修改Presenter引用View接口的方式让View接口与宿主Activity共存亡：

public class MvpPresenter {
        // View接口
        private MvpView mView;
        public MvpPresenter(){
            //构造方法中不再需要View参数
        }
      　/**
         * 绑定view，一般在初始化中调用该方法
         */
        public void attachView(MvpView  mvpView) {
            this.mView= mvpView;
        }
        /**
         * 断开view，一般在onDestroy中调用
         */
        public void detachView() {
            this.mView= null;
        }
        /**
         * 是否与View建立连接
         * 每次调用业务请求的时候都要出先调用方法检查是否与View建立连接
         */
        public boolean isViewAttached(){
            return mView!= null;
        }
        /**
         * 获取网络数据
         * @param params 参数
         */
        public void getData(String params){
            //显示正在加载进度条
            mView.showLoading();
            // 调用Model请求数据
            MvpModel.getNetData(params, new MvpCallback() {
                @Override
                public void onSuccess(String data) {
                    //调用view接口显示数据
                    if(isViewAttached()){
                        mView.showData(data);
                    }
                }
                @Override
                public void onFailure(String msg) {
                    //调用view接口提示失败信息
                    if(isViewAttached()){
                         mView.showFailureMessage(msg);
                    }          
                }
                @Override
                public void onError() {
                    //调用view接口提示请求异常
                    if(isViewAttached()){
                        mView.showErrorMessage();
                    } 
                }
                @Override
                public void onComplete() {
                    // 隐藏正在加载进度条
                    if(isViewAttached()){
                        mView.hideLoading();
                    } 
                }
            });
        }
    }

上面Presenter代码中比之前增加了三个方法：

*  `attachView()` 绑定View引用。
 *  `detachView` 断开View引用。
 *  `isViewAttached()` 判断View引用是否存在。

其中`attachView()`和`detachView()`是为Activity准备的，`isViewAttached()`作用是Presenter内部每次调用View接口中的方法是判断View 的引用是否存在。

把绑定View的方法写到Activity的生命周期中

public class MainActivity extends Activity implements MvpView{
      MvpPresenter presenter;
      @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //初始化Presenter
            presenter = new MvpPresenter();
            // 绑定View引用
            presenter.attachView(this);
        }
        @Override
        protected void onDestroy() {
            super.onDestroy();
            // 断开View引用
            presenter.detachView();
        }
    }

### 结合Activity构建base层 ###

写到这里，相信大多数人都会惊讶于MVP模式代码量的巨大，冗余代码实在太多，所以接下需要为MVP中所有单元都设计一个顶级父类来减少重复的冗余代码。同样的道理，我们也为Activity设计一个父类方便与MVP架构更完美的结合。最后将所有父类单独分到一个`base`包中供外界继承调用。

### Callback ###

在以上MVP版中Callback接口中的`onSuccess()`方法需要根据请求数据类型的不同设置为不同类型的参数，所以每当有新的数据类型都需要新建一个Callback，解决方法是引入泛型的概念，用调用者去定义具体想要接收的数据类型：

public interface MvpCallback<T> {
        /**
         * 数据请求成功
         * @param data 请求到的数据
         */
        void onSuccess(T data);
        /**
         *  使用网络API接口请求方式时，虽然已经请求成功但是由
         *  于{@code msg}的原因无法正常返回数据。
         */
        void onFailure(String msg);
        /**
         * 请求数据失败，指在请求网络API接口请求方式时，出现无法联网、
         * 缺少权限，内存泄露等原因导致无法连接到请求数据源。
         */
        void onError();
        /**
         * 当请求数据结束时，无论请求结果是成功，失败或是抛出异常都会执行此方法给用户做处理，通常做网络
         * 请求时可以在此处隐藏“正在加载”的等待控件
         */
        void onComplete();
    }

### BaseView ###

View接口中定义Activity的UI逻辑。因为有很多方法几乎在每个Activity中都会用到，例如显示和隐藏正在加载进度条，显示Toast提示等，索性将这些方法变成通用的：

public interface IBaseView {
        /**
         * 显示正在加载view
         */
        void showLoading();
        /**
         * 关闭正在加载view
         */
        void hideLoading();
        /**
         * 显示提示
         * @param msg
         */
        void showToast(String msg);
        /**
         * 显示请求错误提示
         */
        void showErr();
        /**
         * 获取上下文
         * @return 上下文
         */
        Context getContext();
    }

### BasePresenter ###

Presenter中可共用的代码就是对View引用的方法了，值得注意的是，上面已经定义好了`BaseView`，所以我们希望Presenter中持有的View都是`BaseView`的子类，这里同样需要泛型来约束：

public class BasePresenter<V extends IBaseView> {
        /**
         * 绑定的view
         */
        private V mvpView;
    
        /**
         * 绑定view，一般在初始化中调用该方法
         */
        public void attachView(V mvpView) {
            this.mvpView = mvpView;
        }
    
        /**
         * 断开view，一般在onDestroy中调用
         */
        public void detachView() {
            this.mvpView = null;
        }
    
        /**
         * 是否与View建立连接
         * 每次调用业务请求的时候都要出先调用方法检查是否与View建立连接
         */
        public boolean isViewAttached() {
            return mvpView != null;
        }
    
        /**
         * 获取连接的view
         */
        public V getView() {
            return mvpView;
        }
    }

### BaseActivity ###

BaseActivity主要是负责实现 BaseView 中通用的UI逻辑方法，如此这些通用的方法就不用每个Activity都要去实现一遍了。

public abstract class BaseActivity extends Activity implements IBaseView {
        private ProgressDialog mProgressDialog;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            mProgressDialog = new ProgressDialog(this);
            mProgressDialog.setCancelable(false);
        }
    
        @Override
        public void showLoading() {
            if (!mProgressDialog.isShowing()) {
                mProgressDialog.show();
            }
        }
    
        @Override
        public void hideLoading() {
            if (mProgressDialog.isShowing()) {
                mProgressDialog.dismiss();
            }
        }
    
        @Override
        public void showToast(String msg) {
            Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
        }
    
        @Override
        public void showErr() {
            showToast("error");
        }
    
        @Override
        public Context getContext() {
            return BaseActivity.this;
        }
    }

封装好了base层我们的升级版MVP架构就完成了，下面再来实现一遍完整的MVP实现的应用。

### Model ###

public class MvpModel {
        /**
         * 获取网络接口数据
         * @param param 请求参数
         * @param callback 数据回调接口
         */
        public static void getNetData(final String param, final MvpCallback<String> callback){
            // 利用postDelayed方法模拟网络请求数据的耗时操作
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    switch (param){
                        case "normal":
                            callback.onSuccess("根据参数"+param+"的请求网络数据成功");
                            break;
                        case "failure":
                            callback.onFailure("请求失败：参数有误");
                            break;
                        case "error":
                            callback.onError();
                            break;
                    }
                    callback.onComplete();
                }
            },2000);
        }
    }

### View 接口 ###

public interface MvpView extends BaseView{
        /**
         * 当数据请求成功后，调用此接口显示数据
         * @param data 数据源
         */
        void showData(String data);
    }

### Presenter类 ###

public class MvpPresenter extends BasePresenter<MvpView> {
        /**
         * 获取网络数据
         * @param params 参数
         */
        public void getData(String params){
            if (!isViewAttached()){
                //如果没有View引用就不加载数据
                return;
            }
            //显示正在加载进度条
            getView().showLoading();
            // 调用Model请求数据
            MvpModel.getNetData(params, new MvpCallback<String>() {
                @Override
                public void onSuccess(String data) {
                    //调用view接口显示数据
                    if(isViewAttached()){
                        getView().showData(data);
                    }
                }
                @Override
                public void onFailure(String msg) {
                    //调用view接口提示失败信息
                    if(isViewAttached()){
                        getView().showToast(msg);
                    }
                }
                @Override
                public void onError() {
                    //调用view接口提示请求异常
                    if(isViewAttached()){
                        getView().showErr();
                    }
                }
                @Override
                public void onComplete() {
                    // 隐藏正在加载进度条
                    if(isViewAttached()){
                        getView().hideLoading();
                    }
                }
            });
        }
    }

### Activity ###

public class MainActivity extends BaseActivity implements MvpView {
        TextView text;
        MvpPresenter presenter;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            text = (TextView)findViewById(R.id.text);
            //初始化Presenter
            presenter = new MvpPresenter();
            presenter.attachView(this);
    
            findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    presenter.getData("normal");
                }
            });
        }
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //断开View引用
            presenter.detachView();
        }
        @Override
        public void showData(String data) {
            text.setText(data);
        }
        // button 点击事件调用方法
        public void getData(View view){
            presenter.getData("normal");
        }
        // button 点击事件调用方法
        public void getDataForFailure(View view){
            presenter.getData("failure");
        }
        // button 点击事件调用方法
        public void getDataForError(View view){
            presenter.getData("error");
        }
    }

## Fragment怎么办？ ##

日常开发中，并不是所有的UI处理都在Activity中进行，Fragment也是其中很重要的一员，那么如何将Fragment结合到MVP中呢？

实现BaseFragement做法跟BaseActivity很类似，需要注意一下Fragement与宿主Activity的链接情况就可以。

public abstract class BaseFragment extends Fragment implements BaseView {
        public abstract int getContentViewId();
        protected abstract void initAllMembersView(Bundle savedInstanceState);
        protected Context mContext;
        protected View mRootView;
        @Nullable
        @Override
        public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
            mRootView = inflater.inflate(getContentViewId(), container, false);
            this.mContext = getActivity();
            initAllMembersView(savedInstanceState);
            return mRootView;
        }
        @Override
        public void showLoading() {
            checkActivityAttached();
            ((BaseFragmentActivity) mContext).showLoading();
        }
        @Override
        public void showLoading(String msg) {
            checkActivityAttached();
            ((BaseFragmentActivity) mContext).showLoading(msg);
        }
        @Override
        public void hideLoading() {
            checkActivityAttached();
            ((BaseFragmentActivity) mContext).hideLoading();
        }
        @Override
        public void showToast(String msg) {
            checkActivityAttached();
            ((BaseFragmentActivity) mContext).showToast(msg);
        }
        @Override
        public void showErr() {
            checkActivityAttached();
            ((BaseFragmentActivity) mContext).showErr();
        }
        protected boolean isAttachedContext(){
            return getActivity() != null;
        }
        /**
         * 检查activity连接情况
         */
        public void checkActivityAttached() {
            if (getActivity() == null) {
                throw new ActivityNotAttachedException();
            }
        }
        public static class ActivityNotAttachedException extends RuntimeException {
            public ActivityNotAttachedException() {
                super("Fragment has disconnected from Activity ! - -.");
            }
        }
    }

[3bbf3ab4e19064cc76662db05e113415.png]: /images/20221120/9b9d5231e1b247748e7066af2fce2f2f.png
[96a8b613ac4bf7cf95af544d7500a708.png]: /images/20221120/ed9a282d8b3e44c99346469b3dcf401b.png
[020b0f07f6a2d40524f5ae39758bd939.png]: /images/20221120/832ab8812c894fbe8fa2829f616f6c3c.png