如果还不知道MVP是什么，请自行google了，我这里是简单实现MVP的框架，就是将Activity,或Fragment复制一份，真正的Activity、fragment负责V层，复制的Activity、Fragment充当P层。我们先看看代码，分析下是如何封装的，以便于我们充分理解后进行扩展
复制Activity其实就是让我们的presenter实现BasePresenterInterface接口，实现activity各个生命周期的方法，然后在Activity的生命周期中调用这些方法，这样presenter看上去就像一个Activity了，有点像包装设计模式，持有一个真正Activity的引用
BasePresenterInterface:
public interface BasePresenterInterface {
void onCreate(Bundle bundle);
void onStart();
void onResume();
void onPause();
void onDestroy();
void onStop();
}
复制Activity：
/**
* Created by zhangy on 2016/4/15.
* <p/>
* des : 将presenter与UI层绑定
*/
public abstract class BaseMVPActivity<T extends BasePresenter<U>, U extends BaseUI> extends FragmentActivity {//泛型控制，保证每个V层都有对应的P层
//要绑定的Presenter，每个Activity都会有一个与自己对应的Presenter
private T mPresenter;
protected abstract T createPresenter();
//这里的U是一个接口，定义了我们要返回的UI，例如，activity中有ListView，fragment，TextView等等，我们如果想暴露给外面，可以在这个接口中声明
protected abstract U getUi();
public T getPresenter() {
return mPresenter;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mPresenter = createPresenter();//创建Presenter
mPresenter.onUiReady(getUi(), this);//给 P 层传递我们的 V 层（MVP）
mPresenter.onCreate(getIntent().getExtras());
}
@Override
protected void onStart() {
super.onStart();
mPresenter.onStart();
}
@Override
public void onDestroy() {
super.onDestroy();
mPresenter.onUiDestroy(getUi());
mPresenter.onDestroy();
}
@Override
protected void onResume() {
super.onResume();
mPresenter.onResume();
}
@Override
protected void onPause() {
super.onPause();
mPresenter.onPause();
}
@Override
protected void onStop() {
super.onStop();
mPresenter.onStop();
}
}
请注意到我们在BaseMVPActivity中我们重写了Activity的生命周期方法，并调用presenter对应的方法，这相当于又复制出一个Activity，以后我们就可以像使用Activity一样使用presenter
从类名我们看到，在创建Activity的时候就必须创建一个与之对应的presenter，UI接口。这样我们的Activity只负责UI的显示，对应的presenter负责具体的业务逻辑，与数据交互，通过BaseUI接口暴漏Activity的成员变量，指定Activity的特殊展示。
BasePresenter：
/**
* Created by zhangy on 2016/4/15.
*/
public class BasePresenter <U extends BaseUI> implements BasePresenterInterface {
/**
* 是否是Fragment 备用
*/
private boolean mIsFragment;
/** 绑定的V层，有可能是Activity、Fragment */
private U mUi;
private Activity mActivity;
private Fragment mFragment;
public BasePresenter(boolean isFragment){
super();
mIsFragment = isFragment;
}
/** 在Fragment中绑定的V层 */
public void onFragmentAttach(Activity activity, Fragment fragment) {
mActivity = activity;
mFragment = fragment;
}
/** 绑定Activity */
public void onUiReady(U ui,Activity activity) {
mUi = ui;
mActivity = activity;
}
/**
* @author ：zhangy
*
* @description : 在UI销毁时调用
*
* DATE : 2016/4/15
*/
public final void onUiDestroy(U ui) {
onUiUnready(ui);
mUi = null;
}
public U getUi() {
return mUi;
}
public Activity getActivity() {
return mActivity;
}
public Fragment getFragment() {
return mFragment;
}
/**
* @author ：zhangy
*
* @description : 当Fragment或者Activity即将被销毁时调用，可用于取消监听事件、取消注册事件
*
* DATE : 2016/4/15
*/
public void onUiUnready(U ui) {
}
// 默认空实现Activity生命周期
@Override
public void onCreate(Bundle bundle) {
}
@Override
public void onStart() {
}
@Override
public void onResume() {
}
@Override
public void onPause() {
}
@Override
public void onDestroy() {
}
@Override
public void onStop() {
}
}
在BasePresenter中主要是实现Activity、Fragment生命周期的方法，绑定V层。具体的业务由子类根绝UI接口扩展添加
我们看下BaseUI接口：
public interface BaseUI {
ListView getListView();//这里我只是举个例子，不一定每个页面都有listView
}
使用方法很简单，在我们创建Activity时继承BaseMVPActivity，并创建对应的presenter，UI接口即可。例如我创建的Demo
public class MainActivity extends BaseMVPActivity<MainPresenter, MainUI> implements MainUI {
private ListView mListView;
private MainPresenter mainPresenter;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mListView = (ListView) findViewById(R.id.list_view);
loadData();
}
@Override
public void loadData() {
mainPresenter.loadData();
}
@Override
protected MainPresenter createPresenter() {
mainPresenter = new MainPresenter(false);
return mainPresenter;
}
@Override
protected MainUI getUi() {
return this;
}
@Override
public ListView getListView() {
return mListView;
}
}
我们再来看下怎么实现presenter层，它又干了什么
public class MainPresenter extends BasePresenter<MainUI> {
/** Mode层管理类 */
private FrontMode frontMode;
public MainPresenter(boolean isFragment) {
super(isFragment);
frontMode = new FrontMode();//创建一个Mode层管理类
}
public void loadData() {
/** 让Mode管理层去处理数据的请求，解析，我们只处理回调 */
frontMode.requestData(getActivity(), new RequestListener() {
@Override
public void onSucces(List datas) {
setDatas(datas);
}
@Override
public void onFail() {
}
});
}
/**
* author : zhangy
*
* des : 给V层加载数据
*
* date : 2016/5/5
*/
private void setDatas(List datas) {
getUi().getListView().setAdapter(new ArrayAdapter(getActivity(), android.R.layout.simple_list_item_1, datas));
}
}
在presenter层我们把具体的业务逻辑分离出来，将V层与M层解耦。再看下M层
/**
* Created by zhangy on 2016/5/5.
* <p/>
* MVP中的M层，处理网络请求，数据解析、数据封装，与Bean、presenter交互
*/
public class FrontMode {
/**
* author : zhangy
* <p/>
* des : 这里的数据请求可以换成volley、okHttp.
* <p/>
* date : 2016/5/5
*/
public List requestData(final Activity activity, final RequestListener listener) {
final ArrayList datas = new ArrayList();
//模拟数据请求
new Thread(new Runnable() {
@Override
public void run() {
SystemClock.sleep(2000);//模拟耗时
datas.add("pfg");
datas.add("124");
datas.add("234");
datas.add("456");
datas.add("567");
if (datas.isEmpty()) {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
listener.onFail();
}
});
} else {
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
listener.onSucces(datas);
}
});
}
}
}).start();
return datas;
}
}
//回调接口
public interface RequestListener {
void onSucces(List datas);
void onFail();
}
所有的数据相关的处理都放在FrontMode统一管理。这里我用的是线程模拟数据请求，大家可以继承喜欢的网络框架。
通过上面的框架我们就简单的实现了MVP模型，以后代码的管理维护更简单，思路清晰，分工明确。
感兴趣的童鞋可以到我的github上下载。记得star下（!_!）
