前言

MVP的相关文章在刚哥、郭神的公众号看过挺多的，对于一个刚开始学MVP的初学者来说，还是一脸懵逼，要自己独立去写一个有一种无从下手的感觉。早段时间在简书上看到一篇转载的文章，里面有一段写的很好：MVP 把 Activity 中的 UI 逻辑抽象成 View 接口，把业务逻辑抽象成 Presenter 接口，Model 类还是原来的 Model（博客地址）。文章所讲述内容是对一个基础MVP的实现，并没有通过各种基类来达到解耦封装。

MVC和MVP

全名Model View Contorller，用于隔离业务逻辑、数据、界面展示，在更改ui界面时不需要对业务逻辑进行代码变更。
优点：便于理解，开发快速，一定程度隔离业务与ui的耦合度。
缺点：业务复杂有可能导致controller爆炸，不利于维护。

MVC.png

MVP全名Mode View Presenter，Presenter处理逻辑业务，Model提供数据，View更新展示界面。完全隔离界面显示与业务逻辑，不论更改界面或者更改业务逻辑均为单方面更改。
优点：完全隔离业务逻辑与ui显示，便与迭代维护测试。
缺点：开发效率低下（时间上），接口类过多。

MVP.png

接口

基础的MVP开发需要编写一定的接口，View层和Model层越复杂，接口类的定义就越多，因此，对接口的理解和运用对MVP的理解很重要。

接口是对行为的抽象，简单地理解就是这个对象会做什么，就是所说的方法，从某种意义上理解，可以把接口看作是包含某一类对象的行为的一个集合，比如动物“吃”的行为，鸡和猫是不一样的。另外，接口有一个很重要的特性，它不能实例化，只能通过它的实现类来实例化对象，我们可以使用接口来声明一个变量，但只能由实现类来初始化变量，将它实例化，因此，接口可以实现回调的功能。

那么，我们在View层（Model层）定义好接口，在Presenter层使用接口声明变量，在它的构造方法中，通过其实现类来初始化接口变量，至于实现类如何实现，在哪实现就不是Presenter层所关心的，它只要拿到View层和Model层的引用并且处理好它们之间的业务逻辑就可以了。

对于Model层，我们可以只把实现的方法暴露出去，其它的实现细节可以隐藏掉，体现了Java的封装性。

实现过程

先看下这个模块（一个小作品中的一个模块）的项目结构，它是一个用户登录的场景：

项目结构.png

那么，下面就直接上代码了，先看Model层的：

// 接口-IUserLogin
public interface IUserLogin {

    void login(String account, String password);

}

// 接口-IUserLoginListener
public interface IUserLoginListener {

    void success();

    void failed();

    // 请求登录过程中出现的错误，如密码错误
    void error(int type);

}

// 实现类-UserLoginModel
public class UserLoginModel implements IUserLogin {

    private IUserLoginListener loginListener;
    private MyHandler handler;

    public UserLoginModel(IUserLoginListener loginListener) {
        this.loginListener = loginListener;
        handler = new MyHandler();
    }

    @Override
    public void login(String account, String password) {
        if (account.length() == 0 || password.length() == 0) {
            loginListener.error(Constant.TYPE_ACCOUNT_PASSWORD_ERROR_NULL);
            return;
        }

        OkHttpClient client = new OkHttpClient();

        FormBody.Builder formBody = new FormBody.Builder();
        formBody.add("account", account);
        formBody.add("password", password);

        Request request = new Request.Builder()
                .url(Constant.RESOURCE_URL + "LoginServlet")
                .post(formBody.build())
                .build();

        client.newCall(request).enqueue(new LoginCallBack());
    }

    private class LoginCallBack implements Callback {
        @Override
        public void onFailure(@NotNull Call call, @NotNull IOException e) {
            loginListener.failed();
            e.printStackTrace();
        }

        @Override
        public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
            if (response.isSuccessful()) {
                String result = response.body().string();
                Log.d(Constant.TAG, "result:" + result);
                
                // 不能再子线程更新UI
                Message message = handler.obtainMessage();
                message.obj = result;
                handler.sendMessage(message);
            }
        }
    }

    private class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            String result = (String) msg.obj;
            if ("success".equals(result)) {
                loginListener.success();
            } else if ("not_exist".equals(result)) {
                loginListener.error(Constant.TYPE_ACCOUNT_NOT_EXIST);
            } else if ("error_password".equals(result)) {
                loginListener.error(Constant.TYPE_PASSWORD_ERROR);
            }
        }
    }

}

接着是View层：

// 接口-ILoginView
public interface ILoginView {

    void loginSuccess();

    void loginFailed();

    // 账号出现错误
    void updateAccountView(String info);

    // 密码出现错误
    void updatePasswordView(String info);

    // 根据不同的类型清空输入框
    void clear(int type);

    // 信息验证不通过时
    void checkout();

    void updateView();

    // 销毁LoginActivity
    void destroyActivity();

}

// LoginActivity
public class LoginActivity extends AppCompatActivity implements View.OnClickListener, ILoginView {

    private TextInputLayout tilAccount;
    private TextInputLayout tilPassword;
    private TextInputEditText tieAccount;
    private TextInputEditText tiePassword;
    private MaterialButton btnLogin;
    private MaterialButton btnRegisterActivity;

    private LoginPresenter presenter;

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

        presenter = new LoginPresenter(this, this);

        String a = RecordInfoState.getAccount(this);
        if (!"account".equals(a) && a != null) {
            startActivity(new Intent(this, MainActivity.class));
            finish();
        }

        init();
    }

    private void init() {
        tilAccount = findViewById(R.id.til_account);
        tilPassword = findViewById(R.id.til_password);
        tieAccount = findViewById(R.id.tie_account);
        tiePassword = findViewById(R.id.tie_password);

        btnLogin = findViewById(R.id.btn_login);
        btnRegisterActivity = findViewById(R.id.btn_register_activity);

        btnLogin.setOnClickListener(this);
        btnRegisterActivity.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_login:
                String account = tieAccount.getText().toString();
                String password = tiePassword.getText().toString();
                presenter.doLogin(account, password);
                break;
            case R.id.btn_register_activity:
                startActivity(new Intent(LoginActivity.this, RegisterActivity.class));
                finish();
                break;
            default:
                break;
        }
    }

    @Override
    public void loginSuccess() {
        Toast.makeText(LoginActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void loginFailed() {
        Toast.makeText(LoginActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void updateAccountView(String info) {
        tilAccount.setErrorEnabled(true);
        tilAccount.setError(info);
    }

    @Override
    public void updatePasswordView(String info) {
        tilPassword.setErrorEnabled(true);
        tilPassword.setError(info);
    }

    @Override
    public void clear(int type) {
        switch (type) {
            case Constant.TYPE_ACCOUNT_NOT_EXIST:
                tieAccount.setText("");
                break;
            case Constant.TYPE_PASSWORD_ERROR:
                tiePassword.setText("");
                break;
            default:
                break;
        }
    }

    @Override
    public void checkout() {
        Toast.makeText(LoginActivity.this, "账号或密码不能为空", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void updateView() {
        tilAccount.setErrorEnabled(false);
        tilPassword.setErrorEnabled(false);
    }

    @Override
    public void destroyActivity() {
        this.finish();
    }
}

最后时Presenter层的：

// LoginPresenter
public class LoginPresenter {

    private ILoginView loginView;
    private IUserLogin loginModel;
    private Context context;
    private String accout;

    public LoginPresenter(Context context, ILoginView loginView) {
        this.context = context;
        this.loginView = loginView;
        loginModel = new UserLoginModel(new UserLoginListerImpl());
    }

    public void doLogin(String account, String password) {
        this.accout = account;
        loginView.updateView();
        loginModel.login(account, password);
    }

    private class UserLoginListerImpl implements IUserLoginListener {
        @Override
        public void success() {
            RecordInfoState.logined(context, accout);
            loginView.loginSuccess();
            initPunchCard();
            RecordInfoState.recordPlan(context, "4");
            context.startActivity(new Intent(context, MainActivity.class));
            loginView.destroyActivity();
        }

        // 将保存在远程数据库里的打卡日期缓存到本地
        public void initPunchCard() {
            OkHttpClient client = new OkHttpClient();
            FormBody.Builder body = new FormBody.Builder();
            body.add("type", "4");
            body.add("name", RecordInfoState.getAccount(context));

            Request request = new Request.Builder()
                    .url(Constant.RESOURCE_URL + "ResPathServlet")
                    .post(body.build())
                    .build();

            client.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(@NotNull Call call, @NotNull IOException e) {

                }

                @Override
                public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                    if (response.isSuccessful()) {
                        String pathJson = response.body().string();

                        try {
                            JSONArray jsonArray = new JSONArray(pathJson);
                            for (int i = 0; i < jsonArray.length(); i++) {
                                JSONObject jsonObject = jsonArray.getJSONObject(i);
                                if (jsonObject != null) {
                                    RecordInfoState.recordPunchCard(context, jsonObject.getString("date"));
                                }
                            }
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }

        @Override
        public void failed() {
            loginView.loginFailed();
        }

        @Override
        public void error(int type) {
            switch (type) {
                case Constant.TYPE_ACCOUNT_PASSWORD_ERROR_NULL:
                    loginView.checkout();
                    break;
                case Constant.TYPE_ACCOUNT_NOT_EXIST:
                    loginView.updateAccountView("账号不存在！");
                    loginView.clear(Constant.TYPE_ACCOUNT_NOT_EXIST);
                    break;
                case Constant.TYPE_PASSWORD_ERROR:
                    loginView.updatePasswordView("密码错误！");
                    loginView.clear(Constant.TYPE_PASSWORD_ERROR);
                    break;
                default:
                    break;
            }
        }
    }

}

总结

一个简单的MVP模式就实现完了，笔者认为对接口的理解和运用时理解MVP的关键。通过接口的方式将定义与实现分开，实现View层与Model层的解耦。还有要明确不同层之间的工作：

• View：对应于Activity和XML（在一些特殊的场景下，dialog，fragment也可以充当View），负责View的绘制以及与用户的交互。
• Model：依然是实体模型。
• Presenter：负责完成View与Model间的交互和业务逻辑。
  所以，View做的工作Model不关心，Model做的工作View也不关心，Presenter充当了工作类似现实生活中的中介工作，它使得View与Model可以愉快地沟通。

你只要从View层与Model层需要解耦这个切入点去思考，来不断解决心中的疑问，比如为什么要通过定义接口来实现？别人为什么这样写？如果业务和UI更复杂了应该怎么写等等。不管思考的过程怎样（不要一直死磕），但一定要有自己的总结、反思。积累够了，自然而然就要一种恍然大悟的感觉。

源码地址