关于android:Android-解决RxJava内存泄露之AutoDispose

Android 解决RxJava内存泄露之AutoDispose

一.概述
通常（尤其是在挪动应用程序中），Rx 订阅须要进行以响应某些事件（例如，当 Activity#onStop() 在 Android 应用程序中执行时）。为了在 RxJava 2 中反对这种常见的场景，咱们构建了 AutoDispose。
增加依赖：你能够依据GitHub上最新的版本

 //AutoDispose
    implementation 'com.uber.autodispose:autodispose:0.6.1'
    implementation 'com.uber.autodispose:autodispose-android-archcomponents:0.6.1'

二.应用

  Observable.interval(3, TimeUnit.SECONDS)
                .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))//最简略的应用就是这样
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d("aaa", String.valueOf(aLong));
                    }
                });

那咱们就须要从新拿说进去剖析

as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))

1.咱们看到咱们传递了一个参数this
这个this代表的是什么了这个this直观的讲，就是Activity自身，当然它也能够是Fragment，这个参数对象只有一个要求，就是必须实现LifecycleOwner接口。
依据源码from办法能够看出：

public final class AndroidLifecycleScopeProvider implements LifecycleScopeProvider<Event> {
    private static final Function<Event, Event> DEFAULT_CORRESPONDING_EVENTS = new Function<Event, Event>() {
        public Event apply(Event lastEvent) throws Exception {
            switch(lastEvent) {
            case ON_CREATE:
                return Event.ON_DESTROY;
            case ON_START:
                return Event.ON_STOP;
            case ON_RESUME:
                return Event.ON_PAUSE;
            case ON_PAUSE:
                return Event.ON_STOP;
            case ON_STOP:
            case ON_DESTROY:
            default:
                throw new LifecycleEndedException("Lifecycle has ended! Last event was " + lastEvent);
            }
        }
    };
    private final Function<Event, Event> boundaryResolver;
    private final LifecycleEventsObservable lifecycleObservable;
//在这里传递this,是实现了LifecycleOwner接口
    public static AndroidLifecycleScopeProvider from(LifecycleOwner owner) {
        return from(owner.getLifecycle());
    }

    public static AndroidLifecycleScopeProvider from(LifecycleOwner owner, Event untilEvent) {
        return from(owner.getLifecycle(), untilEvent);
    }
}

而Google Android官网的架构中都实现了这个
LifecycleOwner接口是Google Android官网架构组件:Lifecycle的一个重要组件，在v7包中，FragmentActivity和Fragment都实现了这个接口，实现了这个接口的对象都领有生命周期（Lifecycle）。

这意味着，不仅是AppCompatActiviy（FragmentActivity的子类）和Fragment，只有是实现了LifecycleOwner的类，都能够作为参数传给AutoDispose，用以管制Observable和组件生命周期的绑定。
如果咱们要封装的话要实现这个接口，封装起来传递
2.咱们传递了this，即传递了要绑定的Activity和Fragment,咱们怎么绑定生命周期了
咱们能够看一下AndroidLifecycleScopeProvider的源码

public final class AndroidLifecycleScopeProvider
    implements LifecycleScopeProvider<Lifecycle.Event> {

  private static final Function<Lifecycle.Event, Lifecycle.Event> DEFAULT_CORRESPONDING_EVENTS =
      new Function<Lifecycle.Event, Lifecycle.Event>() {
        @Override public Lifecycle.Event apply(Lifecycle.Event lastEvent) throws Exception {
          switch (lastEvent) {
            case ON_CREATE:
              return Lifecycle.Event.ON_DESTROY;
            case ON_START:
              return Lifecycle.Event.ON_STOP;
            case ON_RESUME:
              return Lifecycle.Event.ON_PAUSE;
            case ON_PAUSE:
              return Lifecycle.Event.ON_STOP;
            case ON_STOP:
            case ON_DESTROY:
            default:
              throw new LifecycleEndedException("Lifecycle has ended! Last event was " + lastEvent);
          }
        }
      };

也就是说，在咱们的ObservableA订阅时，就曾经晓得了本人在Activity的哪个生命周期让AutoDispose外部自定义的ObservableB主动发射事件，ObservableA监听到这个事件时且未dispose，解除订阅防止内存透露。
这种和RxLifecycle的bindToLifecycle()办法差不多
这里咱们也能够绑定生命周期办法，这样就和bindUntilEvent()的一样
例如：这样能够绑定咱们须要的生命周期

   Observable.interval(3, TimeUnit.SECONDS)
                .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this, Lifecycle.Event.ON_DESTROY)))//这种是当生命周期办法到onDestory()时候解除绑定
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d("aaa", String.valueOf(aLong));
                    }
                });
                
     //后果,我按下home键回到桌面，没有走onDestroy()办法，故继续执行，没有解除绑定
aaa: 0
aaa: 1
aaa: 2
aaa: onPause()
aaa: 3
aaa: 4
aaa: 5
aaa: 6
 onDestory()

3.as办法执行后生成了一个什么？
as办法外部生成了一个AutoDisposeConverter对象，相似于compose,不同的是，Observable通过compose生成的对象还是Observable，但as办法生成的则是一个新的对象：

 public final <R> R as(@NonNull ObservableConverter<T, ? extends R> converter) {
        return ObjectHelper.requireNonNull(converter, "converter is null").apply(this);
    }

实际上，抛开简单的细节，AutoDispose最终将原来的Observable，生成了一个新的AutoDisposeObservable对象, 在执行订阅时，也生成了一个新的AutoDisposingObserverImpl对象，在新的Observerble中解决逻辑，并将后果return

END:不负韶华，不负本人