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可以分离显示层和逻辑层，它们之间使用接口进行通信，降低耦合.
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
它的问题：
1，可以看出MVC的耦合性是比MVP高的，View是可以和Model互相访问的（例如在一些自定义view中，不依附于Activity去获取数据进行存取）
2，在MVC中Activity是作为Controller的，但是在MVP中Activity就是View层了，在Activity充当Controller过程的时候或多或少会涉及到部分业务逻辑，在MVP中就完全不会出现这种Activity夹杂业务逻辑的情况.
如果使用MVP架构就可以解决掉这种高耦合性的问题。
我们使用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是一个非常值得推荐的设计模式，它带来了可扩展性，可测试性，稳定性，可维护性.
