MVP架构

1、MVP思想

关系：

• View收到用户操作
• View把用户的操作，交给Presenter
• Presenter控制Model进行业务逻辑处理
• Presenter处理完毕后，数据封装到Model
• Presenter收到通知后，更新View

方式：是双向的通信方式

优点：

• View层与Model层完全分离
• 所有逻辑交互都在Presenter
• MVP分层较为严谨

2、MVP思想项目基础架构搭建

我们用一个用户登录的Demo,来讲MVP基础架构搭建

处理的事件：输入用户名和密码，点击登录

LoginContract.java合约类，将Model层、View层、Presenter层协商的共同业务，封装成接口

// 契约、合同
public interface LoginContract {
        interface Model {
            // Model层子类完成方法的具体实现----------------2
            void executeLogin(String name, String pwd) throws Exception;
        }
        interface View<T extends BaseEntity> {
            // 真实的项目中，请求结果往往是以javabean--------------4
            void handlerResult(T t);
        }
        interface Presenter<T extends BaseEntity> {
            // 登录请求（接收到View层指令，可以自己做，也可以让Model层去执行）-----------1
            void requestLogin(String name, String pwd);
            // 结果响应（接收到Model层处理的结果，通知View层刷新）---------------3
            void responseResult(T t);
        }

}

View的基类，继承了Activity，我们需要在实现类中实现其中的两个抽象方法。

public abstract class BaseView<P extends BasePresenter, CONTRACT> extends Activity {
    protected P p;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 弱引用
        p = getPresenter();
        // 绑定
        p.bindView(this);
    }
    // 让P层做什么需求
    public abstract CONTRACT getContract();
    // 从子类中获取具体的契约
    public abstract P getPresenter();
    // 如果Presenter层出现了异常，需要告知View层
    public void error(Exception e) {
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 解除绑定
        p.unBindView();
    }
}

Model的基类，我们需要在实现类中实现抽象方法

public abstract class BaseModel<P extends BasePresenter, CONTRACT> {
    protected P p;
    // 业务结束，通过Presenter调用契约、合同（接口中的方法）void responseResult(T t)
    public BaseModel(P p) {
        this.p = p;
    }
    public abstract CONTRACT getContract();
}

Presenter的基类，我们需要在实现类中实现抽象方法

public abstract class BasePresenter<V extends BaseView, M extends BaseModel, CONTRACT> {
    protected M m;
    // 绑定View层弱引用
    private WeakReference<V> vWeakReference;
    public BasePresenter() {
        m = getModel();
    }
    //在BaseView创建的时候调用
    public void bindView(V v) {
        vWeakReference = new WeakReference<>(v);
    }
    //在BaseView销毁的时候调用
    public void unBindView() {
        if (vWeakReference != null) {
            vWeakReference.clear();
            vWeakReference = null;
            System.gc();
        }
    }
    // 获取View，P -- V
    public V getView() {
        if (vWeakReference != null) {
            return vWeakReference.get();
        }
        return null;
    }
    // 获取子类具体契约（Model层和View层协商的共同业务）
    public abstract CONTRACT getContract();
    //获取Mode
    public abstract M getModel();
}

LoginActivity.java,View的实现类,调用P去请求登录验证，P中responseResult调用LoginActivity中的getContract().handlerResult(UserInfo userInfo)方法。

public class LoginActivity extends BaseView<LoginPresenter, LoginContract.View> {

    private EditText nameEt;
    private EditText pwdEt;
    private Button btn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        initView();
    }
    // 初始化控件
    private void initView() {
        nameEt = findViewById(R.id.et_name);
        pwdEt = findViewById(R.id.et_pwd);
        btn = findViewById(R.id.bt_login);
    }
    // 点击事件
    public void doLoginAction(View view) {
        String name = nameEt.getText().toString();
        String pwd = pwdEt.getText().toString();
        // 发起需求，让Presenter处理
        p.getContract().requestLogin(name, pwd);
    }
    //BaseView的抽象方法的实现，创建LoginContract.View对象
    @Override
    public LoginContract.View getContract() {
        return new LoginContract.View<UserInfo>() {
            @Override
            public void handlerResult(UserInfo userInfo) {
                if (userInfo != null) {
                    Toast.makeText(LoginActivity.this, userInfo.toString(), Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(LoginActivity.this, "登录失败！", Toast.LENGTH_SHORT).show();
                }
            }
        };
    }
    //BaseView的抽象方法的实现，创建LoginPresenter对象
    @Override
    public LoginPresenter getPresenter() {
        return new LoginPresenter();
    }
}

LoginPresenter.java,BasePresenter的实现类，把事情交给Model去做，M处理完后，会调用P中的responseResult(UserInfo userInfo)方法，responseResult会调用View的handlerResult(UserInfo userInfo) 方法。

public class LoginPresenter extends BasePresenter<LoginActivity, LoginMode, LoginContract.Presenter> {
    //BasePresenter的抽象方法的实现
    @Override
    public LoginContract.Presenter getContract() {
        // 既要履行View给它的需求，又要分配工作给Model去完成这个需求
        return new LoginContract.Presenter<UserInfo>() {
            @Override
            public void requestLogin(String name, String pwd) {
                try {
                    // 第二种，交给mode去做（P层很极端，要么不做事只做转发，要么就是拼命一个人干活）
                    m.getContract().executeLogin(name, pwd);
                    // 第一种，P层自己处理（谷歌例子）
                    /*if ("migill".equalsIgnoreCase(name) && "123".equals(pwd)) {
                        responseResult(new UserInfo("*******", "migill"));
                    } else {
                        responseResult(null);
                    }*/
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            @Override
            public void responseResult(UserInfo userInfo) {
                // 不管谁完成需求，有结果就告知View层
                getView().getContract().handlerResult(userInfo);
            }
        };
    }

    //BasePresenter的抽象方法的实现
    @Override
    public LoginMode getModel() {
        return new LoginMode(this);
    }
}

LoginMode.java,BaseModel的实现类，接收P层交给它的需求，处理完成后，调用P中的responseResult方法。

public class LoginMode extends BaseModel<LoginPresenter, LoginContract.Model> {

    public LoginMode(LoginPresenter loginPresenter) {
        super(loginPresenter);
    }
    //BaseModel的抽象方法实现，根据执行结构，调用P中的responseResult方法。
    @Override
    public LoginContract.Model getContract() {
        return new LoginContract.Model() {
            @Override
            public void executeLogin(String name, String pwd) throws Exception {
                if ("migill".equalsIgnoreCase(name) && "123".equals(pwd)) {
                    p.getContract().responseResult(new UserInfo("*******", "migill"));
                } else {
                    p.getContract().responseResult(null);
                }
            }
        };
    }
}

最后，就是进行内存泄漏测试。
在LoginPresenter文件中的requestLogin中开启一个线程做消耗，按下返回键，点击GC，可以看到MainActivity对象没有了，所以没有发生内存泄漏。