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

37次阅读

共计 3677 个字符，预计需要花费 10 分钟才能阅读完成。

一. 概述
通常（尤其是在挪动应用程序中），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: 不负韶华，不负本人

正文完