MVP的基类抽取，绑定解除View（可以避免内存泄漏）

朴灿烈づ我的快乐病毒、 2023-10-17 22:18 19阅读 0赞

**绑定解除View（可以避免内存泄漏）**

使用MVP还遇到过一个问题，容易产生内存泄漏的问题，我的项目里面有成百上千个Activity类，每一个Presenter我都做解决内存泄漏这个操作，很容易有些地方疏忽了，那一天可能加班，有点累，就没有注意内存泄漏这方面，结果就给我的项目带来很大的麻烦，而且我这个项目后期别人接手他可能意识不到内存泄漏的问题，他在基于我的框架写MVP的时候有可能也不做内存泄漏，那这样子的话，内存泄漏的多了就会造成OOM我们的程序就会奔溃。所以我当时在抽基类的时候我就想到，要定义规范，抽基类就两点，把冗余的代码简化一下放在基类里面，不必要每个子类都写一样的业务逻辑。第二就是定义规范，比如所有的子类都要进行一个初始化控件的操作，那么我就写一个抽象方法，你只要继承我的基类，那么你必然要实现抽象方法，只要实现抽象方法，那你一看抽象方法这个方法你就知道，他是做什么逻辑的，你就把你的逻辑放到你实现的抽象方法里面，那这样的话代码阅读性更高，每个人不管怎么做，这个操作都必须要做，我抽了一个Presenter。我在做MVP的时候抽了一个BasePresenter,通过泛型我把内存泄漏就处理了，任何一个MVP的子类只要继承我的BasePresenter，就自动把内存泄漏给解决了。别人就不用考虑这个方面了，不论是我自己还是别人接手我的项目，都可以省很多功夫，那么我们APP的健壮性更好。

**依赖：**

dependencies {
      
        compile 'com.android.support:appcompat-v7:26.0.0-alpha1'
        compile 'com.android.support:support-v4:26.0.0-alpha1'
        testCompile 'junit:junit:4.12'
        /*5.0新控件的依赖*/
        compile 'com.android.support:design:26.0.0-alpha1'
    
        /*RxJava与RxAndroid的依赖*/
        compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
        compile 'io.reactivex.rxjava2:rxjava:2.1.0'
    
        /*Retrofit与RxAndroid配置依赖*/
        compile 'com.squareup.retrofit2:retrofit:2.3.0'
        compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
    
        /*使Retrofit的转化器自定义完成数据的转化
        * 就是我们可以接口中少写一些bean类
        * */
        compile 'com.squareup.retrofit2:converter-scalars:+'
    
        /*gson解析*/
        compile 'com.google.code.gson:gson:2.8.1'
        /*Log工具:http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2015/1115/3685.html*/
        compile 'com.github.zhaokaiqiang.klog:library:1.6.0'
    }

/**
     * MVP的基本封装
     * 1.搭建框架,首先创建基类(IActivity,BasePresenter,BaseMvpActivity)
     * 2.在SplashActivity使用一下MVP(SplashView,SplashPresenter)
     * 3.自己搭建Fragment的MVP的基类,并使用一下(IFragment,BaseMvpFragment)
     */
    public class SplashActivity extends BaseMvpActivity<SplashView,SplashPresenter> {
    
        @Override
        public SplashPresenter initPresenter() {
            return new SplashPresenter();
        }
    
        @Override
        protected  void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            presenter.getData();
        }
    
    }

activity\_main

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".SplashActivity">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"/>
    </RelativeLayout>

/**
     * 这是MVP的Activity,一个抽象类.在对应的生命周期里绑定资源,释放资源,避免MVP带来的内存泄漏
     * @param <V> 这个泛型代表当前的View
     * @param <T> 这个泛型代表当前的presenter
     * 提示:因为每个Activity创建的presenter,View都不同,所有用泛型
        抽取基类的原则:子类共有且实现方式相同的代码,我们直接抽到我们的基类,提供效率,增加代码的阅读性
     * 子类共有且实现方式不相同的代码,我们以抽象方法的形象在我们基类中体现,这样没有一个继承该基类的子类,都要去做规定的业务
      比如说初始化控件,每个子类都要做,但是具体fb的代码不可能相同,因此我们可以用抽象方法行,强行让子类记着要初始化控件,然后怎么实现就不做要求
    为什么定义接口,定义泛型,就是为让你按照我定义规则去写代码.只有按我的规则写代码,代码才会便于维护,阅读.
     * 3个Android工程师,我写规则,内存泄漏,释放资源等等,我再定义规则都写好,你就在我写的这个框架内,去实现就可以
     * 从moudle里拿到网上数据,把数据解析,更新UI控件显示,就可以了.你们传数据,MD5,时间戳,签名去封装然后你才够请求
     * 掉我写的工具类,你把参数传进去,拿到结果,你去请求网络,薪资在15一上.
     */
    public abstract class BaseMvpActivity<V,T extends BasePresenter<V>> extends IActivity {
    
        public T presenter ;
    
        public abstract T initPresenter();
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_base_mvp);
            presenter = initPresenter();
        }
    
        //绑定资源
        @Override
        protected void onResume() {
            super.onResume();
            presenter.attach((V) this);
        }
        //释放资源
        @Override
        protected void onDestroy() {
            super.onDestroy();
            presenter.detach();
        }
    
    }

activity\_base\_mvp

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_base_mvp"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".base.BaseMvpActivity">
    
    </RelativeLayout>

/**
     * 使用MVP的架构,同时参数为泛型
     * 解决:MVP最常见的,内存泄漏的问题
     * @param <T>
     */
    public abstract class BasePresenter<T> {
        public T view;
    
        public void attach(T view) {
            this.view = view;
        }
    
        //防止内存泄漏,将对象置为null
        public void detach() {
            this.view = null;
        }
    }

/**
     * 所有的 activity 都继承这个Activity,这是一个简单的Activity
     * 我们的项目并不是所有的模块都是MVP,对应业务逻辑不复杂的Activity,没必要抽成MVP,比如启动页
     */
    public class IActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_i);
        }
    }

activity\_i

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/activity_i"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".base.IActivity">
    
    </RelativeLayout>

public interface SplashView {
    
    }

/* function:Presenter与module想关联
    * 提示:这里的View对象,我们在 BasePresenter
    */       
    public class SplashPresenter extends BasePresenter<SplashView> {
        
        private SplashModelImpl splashModel;
        
        public SplashPresenter() {
            splashModel =new SplashModelImpl();
        }
        //A.presenter里和Module进行交互,暴露一个获取数据的方法
        public void getData(){
            splashModel.getData();
        }
    }

/**
     * function:module层,使用封装的RetrofitFactory工厂,从网络获取数据.
     */
    
    public class SplashModelImpl {
    
        public void getData() {
    
    //        //我们可以用一个适配器设计模式避免写那么多无用的回调
    //        RetrofitFactory.apiService.get("http://www.baidu.com")
    //                .subscribeOn(Schedulers.io())//被观察者运行在子线程
    //                .observeOn(AndroidSchedulers.mainThread())//观察运行在主线程
    //                .subscribe(new Observer<String>() {
    //                    @Override
    //                    public void onSubscribe(@NonNull Disposable d) {}
    //                    @Override
    //                    public void onNext(@NonNull String s) {}
    //                    @Override
    //                    public void onError(@NonNull Throwable e) {}
    //                    @Override
    //                    public void onComplete() {}
    //                });
    
    
            RetrofitFactory.get("https://api-quality.jiemian.com/goodsCat/getBrandList").subscribe(new BaseObserver() {
                @Override
                public void onSuccess(String result) {
                    System.out.println("result = " + result);
                }
    
                @Override
                public void onFailed() {}
            });
    
        }
    }

/**
     * Retrofit底层用的就是okhttpclient(Retrofit就是okhttp的封装)
     * 1.使项目就一个okhttpClient,和Retrofit对象,节省内存,并设置基础Url
     * 2.使Retrofit与RxJava结合使用
     * 3.我们使用通用接口,减少了接口的定义的数量
     * 子线程不能更新UI,主线程里面不能做耗时操作
     * 子线程咱们做耗时操作,主线程咱们UI更新.
     */
    public class RetrofitFactory {
    
        //使全局就一个OKHttpClient对象
        public static OkHttpClient okHttpClient = new OkHttpClient.Builder()
    //            .cookieJar(new CookiesManager())
                .connectTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .addInterceptor(new LoggingInterceptor())
                .build();
    
        //使全局就一个Retrofit对象,设置基础Url
        public static ApiService apiService = new Retrofit.Builder()
                .baseUrl("http://qbh.2dyt.com")
                //使我们能高度自定义转化器
                .addConverterFactory(ScalarsConverterFactory.create())
                .client(okHttpClient)
                //把 以前的 call 转化成 Observable,这是Retrofit与RxJava结合使用的关键
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build().create(ApiService.class);
    
    
        public static Observable<String> get(String url) {
            return apiService.get(url)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    
    
        public static Observable<String> get(String url, Map<String, String> map) {
            return apiService.get(url, map).subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    
    
        public static Observable<String> post(String url, Map<String, String> map) {
            return apiService.post(url, map).subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    
    }

//网络请求日志拦截器,直接拷贝使用即可
    class LoggingInterceptor implements Interceptor {
        @Override public Response intercept(Interceptor.Chain chain) throws IOException {
            Request request = chain.request();
    
            long t1 = System.nanoTime();
            KLog.i(String.format("Sending request %s on %s%n%s",
                    request.url(), chain.connection(), request.headers()));
    
            Response response = chain.proceed(request);
    
            long t2 = System.nanoTime();
            KLog.i(String.format("Received response for %s in %.1fms%n%s",
                    response.request().url(), (t2 - t1) / 1e6d, response.headers()));
    
            return response;
        }
    }

public interface ApiService {
    
        /**
         * Get基本请求,这里从Call改为Observable被观察者
         * @param url
         * @return
         */
        @GET
        public Observable<String> get(@Url String url);
    
        /**
         * Get请求提交表单
         * @param url
         * @param map
         * @return
         */
        @GET
        public Observable<String> get(@Url String url, @QueryMap Map<String,String> map);
    
        /**
         * Post请求提交表单
         * @param url
         * @param map
         * @return
         */
        @FormUrlEncoded
        @POST
        public Observable<String> post(@Url String url , @FieldMap Map<String,String> map);
    }

public abstract class BaseObserver implements Observer<String> {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
        }
    
        @Override
        public void onNext(@NonNull String s) {
            onSuccess(s);
        }
        //自己封装失败的回调
        @Override
        public void onError(@NonNull Throwable e) {
        }
    
        @Override
        public void onComplete() {
        }
    
        public abstract void onSuccess(String result);
    
        public abstract void onFailed();
    
    }