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对象没有了，所以没有发生内存泄漏。
网友评论