穷人版MVP结构图
M <–> P <–> M
内存泄漏
若M层还在请求数据的时候，Activity或Fragment关闭了，由于V层持有P层的引用，P层又持有M层的引用，从而导致了内存泄漏。如果请求到的数据是在展现在View上的，那么还有空指针异常。
解决方案一： 让presenter绑定Activity的生命周期，让它写一个绑定和解绑的方法，在Activity创建Presenter时进行绑定，在onDestroy中进行解绑。
步骤
1.创建一个基类View，让所有View接口都必须实现
public interface BaseMvpView {
//以后要是有让所有子类一起实现的业务，可以加在这里
}2.创建一个基类的Presenter，在类上规定View泛型，然后定义绑定和解绑的方法，对外在提供一个获取View的方法，让子类直接通过方法来获取View使用即可,添加生命周期的方法
public abstract class BaseMvpPresenter<V extends BaseMvpView> {
private V mMvpView;
/**
* 绑定V层
* @param view
*/
public void attachMvpView(V view){
this.mMvpView = view;
}
/**
* 解除绑定V层
*/
public void detachMvpView(){
mMvpView = null;
}
/**
* Presenter被销毁时调用
*/
public void onDestroyPersenter() {
}
/**
* 在Presenter意外销毁的时候被调用，它的调用时机和Activity、Fragment、View中的onSaveInstanceState
* 时机相同
*
* @param outState
*/
public void onSaveInstanceState(Bundle outState) {
}
/**
* 获取V层
* @return
*/
public V getmMvpView() {
return mMvpView;
}
}3.创建一个基类的Activity，帮子类创建Presenter,因为要帮子类去绑定和解绑那么就需要拿到BaseMvpPresenter的子类Presenter才行，可以声明泛型在方法上使用泛型来达到目的。
那么怎么让父类去帮子类创建Presenter呢？
我们可以采用注解的方式，在子类上声明一个注解并注明要创建的类型，剩下的事情就让父类去做了,但是父类得考虑如果子类不想这么干怎么办，那也还是不能写死吧，可以使用策略模式加工厂模式来实现，我们默认使用这种注解的工厂，但是如果子类不喜欢可以通过父类提供的一个方法来创建自己的工厂。
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface CreatePresenter {
Class<? extends BaseMvpPresenter> value();
}@Inherited表明这个class是可以被继承的，这个注解将被用于该class的子类。因为需要用到反射，所以注解的生命周期必须是 RetentionPolicy.RUNTIME 。
我们既然要采用工厂模式才创建Presenter，那么我们首先来创建一个工厂接口：
public interface PresenterMvpFactory<V extends BaseMvpView,P extends BaseMvpPresenter<V>> {
/**
* 创建Presenter的接口方法
* @return 需要创建的Presenter
*/
P createMvpPresenter();
}注解工厂：
public class PresenterMvpFactoryImpl<V extends BaseMvpView, P extends BaseMvpPresenter<V>> implements PresenterMvpFactory<V, P> {
/**
* 需要创建的Presenter的类型
*/
private final Class<P> mPresenterClass;
/**
* 根据注解创建Presenter的工厂实现类
* @param viewClazz 需要创建Presenter的V层实现类
* @param <V> 当前View实现的接口类型
* @param <P> 当前要创建的Presenter类型
* @return 工厂类
*/
public static <V extends BaseMvpView, P extends BaseMvpPresenter<V>> PresenterMvpFactoryImpl<V,P> createFactory(Class<?> viewClazz){
CreatePresenter annotation = viewClazz.getAnnotation(CreatePresenter.class);
Class<P> aClass = null;
if(annotation != null){
aClass = (Class<P>) annotation.value();
}
return aClass == null ? null : new PresenterMvpFactoryImpl<V, P>(aClass);
}
private PresenterMvpFactoryImpl(Class<P> presenterClass) {
this.mPresenterClass = presenterClass;
}
@Override
public P createMvpPresenter() {
try {
return mPresenterClass.newInstance();
} catch (Exception e) {
throw new RuntimeException("Presenter创建失败!，检查是否声明了@CreatePresenter(xx.class)注解");
}
}
}我们说了不能写死这个工厂，那么我们需要使用者可以自定义，那么我们还需要给使用者提供一个设置的方法，我们定义一个接口提供设置工厂、获取工厂、获取Presenter的方法，然后让V层来实现这个接口，这样V层的子类就可以通过相应的方法使用了:
public interface PresenterProxyInterface<V extends BaseMvpView,P extends BaseMvpPresenter<V>> {
/**
* 设置创建Presenter的工厂
* @param presenterFactory PresenterFactory类型
*/
void setPresenterFactory(PresenterMvpFactory<V,P> presenterFactory);
/**
* 获取Presenter的工厂类
* @return 返回PresenterMvpFactory类型
*/
PresenterMvpFactory<V,P> getPresenterFactory();
/**
* 获取创建的Presenter
* @return 指定类型的Presenter
*/
P getMvpPresenter();
}使用代理模式将绑定和解绑view的操作抽离出来
public class BaseMvpProxy<V extends BaseMvpView, P extends BaseMvpPresenter<V>> implements PresenterProxyInterface<V, P>{
/**
* 获取onSaveInstanceState中bundle的key
*/
private static final String PRESENTER_KEY = "presenter_key";
/**
* Presenter工厂类
*/
private PresenterMvpFactory<V, P> mFactory;
private P mPresenter;
private Bundle mBundle;
private boolean mIsAttchView;
public BaseMvpProxy(PresenterMvpFactory<V, P> presenterMvpFactory) {
this.mFactory = presenterMvpFactory;
}
/**
* 设置Presenter的工厂类,这个方法只能在创建Presenter之前调用,也就是调用getMvpPresenter()之前，如果Presenter已经创建则不能再修改
*
* @param presenterFactory PresenterFactory类型
*/
@Override
public void setPresenterFactory(PresenterMvpFactory<V, P> presenterFactory) {
if (mPresenter != null) {
throw new IllegalArgumentException("这个方法只能在getMvpPresenter()之前调用，如果Presenter已经创建则不能再修改");
}
this.mFactory = presenterFactory;
}
/**
* 获取Presenter的工厂类
*
* @return PresenterMvpFactory类型
*/
@Override
public PresenterMvpFactory<V, P> getPresenterFactory() {
return mFactory;
}
/**
* 获取创建的Presenter
*
* @return 指定类型的Presenter
* 如果之前创建过，而且是以外销毁则从Bundle中恢复
*/
@Override
public P getMvpPresenter() {
if (mFactory != null) {
if (mPresenter == null) {
mPresenter = mFactory.createMvpPresenter();
mPresenter.onCreatePersenter(mBundle == null ? null : mBundle.getBundle(PRESENTER_KEY));
}
}
return mPresenter;
}
/**
* 绑定Presenter和view
* @param mvpView
*/
public void onResume(V mvpView) {
getMvpPresenter();
if (mPresenter != null && !mIsAttchView) {
mPresenter.onAttachMvpView(mvpView);
mIsAttchView = true;
}
}
/**
* 销毁Presenter持有的View
*/
private void onDetachMvpView() {
if (mPresenter != null && mIsAttchView) {
mPresenter.onDetachMvpView();
mIsAttchView = false;
}
}
/**
* 销毁Presenter
*/
public void onDestroy() {
if (mPresenter != null ) {
onDetachMvpView();
mPresenter.onDestroyPersenter();
mPresenter = null;
}
}
/**
* 意外销毁的时候调用
* @return Bundle，存入回调给Presenter的Bundle和当前Presenter的id
*/
public Bundle onSaveInstanceState() {
Bundle bundle = new Bundle();
getMvpPresenter();
if(mPresenter != null){
Bundle presenterBundle = new Bundle();
//回调Presenter
mPresenter.onSaveInstanceState(presenterBundle);
bundle.putBundle(PRESENTER_KEY,presenterBundle);
}
return bundle;
}
/**
* 意外关闭恢复Presenter
* @param savedInstanceState 意外关闭时存储的Bundler
*/
public void onRestoreInstanceState(Bundle savedInstanceState) {
mBundle = savedInstanceState;
}
}最后V层实现，首先实现设置工厂的接口，然后创建一个代理并传入默认工厂，在V层生命周期中使用代理去实现管理Presenter的生命周期
public abstract class AbstractMvpActivitiy<V extends BaseMvpView, P extends BaseMvpPresenter<V>> extends Activity implements PresenterProxyInterface<V,P> {
private static final String PRESENTER_SAVE_KEY = "presenter_save_key";
/**
* 创建被代理对象,传入默认Presenter的工厂
*/
private BaseMvpProxy<V,P> mProxy = new BaseMvpProxy<>(PresenterMvpFactoryImpl.<V,P>createFactory(getClass()));
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(savedInstanceState != null){
mProxy.onRestoreInstanceState(savedInstanceState.getBundle(PRESENTER_SAVE_KEY));
}
}
@Override
protected void onResume() {
super.onResume();
mProxy.onResume((V) this);
}
@Override
protected void onDestroy() {
super.onDestroy();
mProxy.onDestroy();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBundle(PRESENTER_SAVE_KEY,mProxy.onSaveInstanceState());
}
@Override
public void setPresenterFactory(PresenterMvpFactory<V, P> presenterFactory) {
mProxy.setPresenterFactory(presenterFactory);
}
@Override
public PresenterMvpFactory<V, P> getPresenterFactory() {
return mProxy.getPresenterFactory();
}
@Override
public P getMvpPresenter() {
return mProxy.getMvpPresenter();
}
}最后看一下使用，首先在V层上定义需要创建的Presenter，声明自己模块具体的View接口类型和Presenter类型，最后实现自己View接口就ok了，还有就是如果要设置自己的Presenter创建工厂，必须在调用onResume方法和getMvpPresenter方法之前设置 ：
//声明需要创建的Presenter
@CreatePresenter(RequestPresenter5.class)
public class MainActivity extends AbstractMvpActivitiy<RequestView, RequestPresenter> implements RequestView {
@FieldView(R.id.tv_text)
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ViewFind.bind(this);
//设置自己的Presenter工厂，如果你想自定义的话
// setPresenterFactory(xxx);
if(savedInstanceState != null){
Log.e("perfect-mvp","MainActivity onCreate 测试 = " + savedInstanceState.getString("test") );
}
}
//点击事件
public void request(View view) {
getMvpPresenter().clickRequest("101010100");
}
@Override
public void requestLoading() {
textView.setText("请求中,请稍后...");
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
Log.e("perfect-mvp","MainActivity onSaveInstanceState 测试");
outState.putString("test","test_save");
}
@Override
public void resultSuccess(WeatherBean result) {
//成功
textView.setText(result.getWeatherinfo().toString());
}
@Override
public void resultFailure(String result) {
//失败
textView.setText(result);
}
}这时候如果界面意外销毁,Presenter可以通过重写以下方法进行释放资源，存储数据，和恢复数据，例如：
@Override
public void onCreatePersenter(@Nullable Bundle savedState) {
super.onCreatePersenter(savedState);
if(savedState != null){
Log.e("perfect-mvp","RequestPresenter5 onCreatePersenter 测试 = " + savedState.getString("test2") );
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
Log.e("perfect-mvp","RequestPresenter5 onSaveInstanceState 测试 " );
outState.putString("test2","test_save2");
}
@Override
public void onDestroyPersenter() {
super.onDestroyPersenter();
}其他的代码
public interface RequestView extends BaseMvpView{
void requestLoading();
void resultSuccess(WeatherBean result);
void resultFailure(String result);
}public class RequestPresenter extends BaseMvpPresenter<RequestView> {
private final RequestMode mRequestMode;
public RequestPresenter() {
this.mRequestMode = new RequestMode4();
}
public void clickRequest(final String cityId){
if(getMvpView() != null){
getMvpView().requestLoading();
}
//模拟网络延迟，可以显示出加载中
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
mRequestMode.request(cityId, new Callback<WeatherBean>() {
@Override
public void onResponse(Call<WeatherBean> call, Response<WeatherBean> response) {
if(getMvpView() != null){
getMvpView().resultSuccess(response.body());
}
}
@Override
public void onFailure(Call<WeatherBean> call, Throwable t) {
if(getMvpView() != null){
getMvpView().resultFailure(Log.getStackTraceString(t));
}
}
});
}
},2000);
}
@Override
public void onCreatePersenter(@Nullable Bundle savedState) {
super.onCreatePersenter(savedState);
if(savedState != null){
Log.e("perfect-mvp","RequestPresenter5 onCreatePersenter 测试 = " + savedState.getString("test2") );
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putString("test2","test_save2");
}
@Override
public void onDestroyPersenter() {
super.onDestroyPersenter();
}
public void interruptHttp(){
mRequestMode.interruptHttp();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
