MVP封装

最新推荐文章于 2024-03-17 18:00:34 发布
最新推荐文章于 2024-03-17 18:00:34 发布
阅读量367 收藏
点赞数
分类专栏： Android必备技
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawN4get/article/details/80110458
版权

穷人版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();
    }
}
dawN4get
关注
专栏目录
Flutter MVP 封装
03-28 402
在 Android 开发中经常会用到一些架构，从 MVC 到 MVVP、MVVM等，这些架构会大大的解耦我们代码的功能模块，让我们的代码在项目中后期更容易扩展和维护。   在Flutter中同样有 MVC、MVP、MVVM等架构。在Android实际开发中，也有把项目从 MVC切换到 MVP，形成了一套 MVP 快速开发框架，且做了一个 AS 快速代码生成插件。所以在 Flutter 开发中也想着...
MVP简单封装
11-28
mvp框架简单封装，支持加载更多数据，get put 请求 mvp框架简单封装，支持加载更多数据，get put 请求
MVP架构封装
lemon15588的博客
01-31 425
Android MVP框架设计MVP结构:M层数据层,数据可以是从远程服务器获取,也可以是从本地数据库获取.一般android应用中数据原大都为 远程服务器,所以M层的工作可以暂且看成就是网络请求部分. m层具体体现应该为网络请求相关代码 V层数据展示层,将M层获取到的数据展示到前台告诉用户结果,具体体现为activity或者fragment等前台页面以及一些弹窗,TOAST提示等交互 P层Pre
封装mvp
CruleRui的博客
03-17 226
view层 /** * @Author：h * @E-mail： 2973627661@163.com * @Date：2019/3/17 18:59 * @Description：描述信息 */ public interface MainView { void success(String data); void fail(); } model层 /** * ...
Android mvp封装
09-27
基于retrofit2-rxjava2封装的完整版mvp框架,下载即可用.加入了eventbus butterknife.
mvp封装+baseactivity封装.
11-28
MVP封装则是对这一模式的进一步优化，使得开发者可以更方便地在项目中使用MVP架构。`BaseActivity`是很多Android开发者用来做基础Activity封装的类，通常包含了一些通用的功能，以减少代码重复，提高代码复用性。 ...
MVP高级封装
09-12
【MVP高级封装】是Android应用开发中一种常见的设计模式，它将业务逻辑、数据处理和用户界面进行了明确的分离，极大地提高了代码的可维护性和可测试性。在这个主题下，我们将深入探讨MVP模式的基本概念、优势以及...
MVP框架封装
11-06
封装的MVP框架，还在一直改进中，当然有看到不当之处也欢迎能够指出问题，如果你没有资源分，可去github下载地址：https://github.com/gitwangyang/MVP
MVP通用框架封装
09-28
一个通用的优雅的MVP框架封装和具体是使用方式，使用方便，结构清晰。
MVP模式的经典封装
weixin_34254823的博客
01-19 311
人之所以能，是相信能。 说到MVP，大家应该都不陌生了，由于其高度解等等优点，越来越多的项目使用这个设计模式。然而，优点虽在，缺点也不少，其中一个就是类多了很多，而且V与P直接要项目通信，那么P就得持有V得实例，但如果活动挂掉了，如果没有对V进行释放，还有导致内存溢出得问题，而且，那么多的接口函数，看得到人眼花缭乱，也使得很多人在使用这个模式的时候望而尚步。 回归正题，最近在进行代码重构，决定...
MVP简单封装，不用再手写了
zrx_z的博客
11-18 1378
前言： 本文的源码是根据一位前辈的帖子加入了本人的理解总结的，如果感觉不错，感谢采用，如果有瑕疵，请及时沟通，我会尽快修复不足。只是喜欢代码，谈不上精通。 正文： 导入依赖 项目gradle allprojects { repositories { ... maven { url 'https://jitpack.io' } } } app的gradle implementation 'com.github.xiangs
Android MVP框架封装
热爱生活，热爱技术
04-07 198
Android MVP框架的封装，具体封装细节和使用方法请看 github地址
Android MVP架构简单封装
食種之食物
05-29 2473
最近在研究MVP和MVVM架构模式，看了看觉得还是MVP好做点，特意查查资料，做了下简单的封装。先看一下自己封装项目的基本库结构。 来看看源码吧 BasePresenter.javapublic abstract class BasePresenter<T> { protected Reference<T> mViewRef;//View接口类型的弱引用 public void
MVP模式的经典封装，android开发面试
最新发布
m0_60635321的博客
03-17 1048
先来观察下这个base类：先设置一泛型T，T为与presenter相关的view。BasePresenter中持有一个view的软引用。在关联方法中将view对象传入，并存入软引用中，创建获取、取消关联和判断方法。至于使用软引用，是为了防止所持的view都销毁了，但presenter一直持有，导致内存泄漏。
Android mvp之P,V的封装
悟空吃饭饭的博客
03-11 872
在MVP模式中，我们知道通常Presenter层会与View层进行绑定联系。由Presenter层控制View，同时，View层也将调用Presenter进行逻辑及界面显示。View层通常是我们的Fragment或者Activity，那么本文就注册的界面（RegisterFragment） 对最顶部的Presenter，View一直到BasePresenter，BaseView进行封装。 首先，...
专高4Mvp封装
zhl2015260367的博客
07-18 77
千万级别封装
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值