（1）前景

在使用rxjava的时候，如果没有及时解除订阅，在退出activity的时候，异步线程还在执行。
对activity还存在引用，此时就会产生内存泄漏。
RxLifecycle就是为了解决rxjava导致的内存泄漏而产生的。

（2）作用

它可以让Observable发布的事件和当前的组件绑定，实现生命周期同步。
从而实现当前组件生命周期结束时，自动取消对Observable订阅。
核心思想：通过监听Activity、Fragment的生命周期，来自动断开订阅防止内存泄漏。

（3）添加依赖

implementation 'io.reactivex.rxjava2:rxjava:2.1.3'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'

（4）分类

• Activity
  RxAppCompatActivity、RxActivity、RxFragmentActivity
• Fragment
  RxFragment、RxDialogFragment、RxPreferenceFragment、RxAppCompatDialogFragment

（5）Activity和Fragment的继承

Activity需要继承RxAppCompatActivity或RxActivity或RxFragmentActivity

比如：

public class BaseActivity extends RxAppCompatActivity {
    
}

Fragment和Activity一样，BaseFragment需要继承RxFragment或RxDialogFragment、RxPreferenceFragment、RxAppCompatDialogFragment

（6）让Observable发布的事件和当前的组件绑定

• bindUntilEvent

    Observable
            .interval(1000, TimeUnit.MILLISECONDS)
            .compose(this.<Long>bindUntilEvent(ActivityEvent.DESTROY))
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    Log.d("aaa", String.valueOf(aLong));
                }
            });
  

以上代码的意思是说，当前Activity执行到onDestroy时，Observable取消订阅。

bindUntilEvent后面的参数决定Observable什么时候被取消。

/**
 * Lifecycle events that can be emitted by Activities.
 */
public enum ActivityEvent {

    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY

}

以上参数和Activity的生命周期一一对应。

• bindToLifecycle

    Observable
            .interval(1000, TimeUnit.MILLISECONDS)
            .compose(this.<Long>bindToLifecycle())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    Log.d("aaa", String.valueOf(aLong));
                }
            });
  

假设当前Observable在onResume中执行的，那么当Activity执行到onPause时，Observable取消订阅。

bindToLifecycle没有参数，所以使用者不清楚Observable到底在什么时候取消订阅，那么我们来看也喜爱源码：

private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE =
    new Function<ActivityEvent, ActivityEvent>() {
        @Override
        public ActivityEvent apply(ActivityEvent lastEvent) throws Exception {
            switch (lastEvent) {
                case CREATE:
                    return ActivityEvent.DESTROY;
                case START:
                    return ActivityEvent.STOP;
                case RESUME:
                    return ActivityEvent.PAUSE;
                case PAUSE:
                    return ActivityEvent.STOP;
                case STOP:
                    return ActivityEvent.DESTROY;
                case DESTROY:
                    throw new OutsideLifecycleException("Cannot bind to Activity lifecycle when outside of it.");
                default:
                    throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
            }
        }
    };

源码的意思很明显：

• 如果Observable在onCreate执行，那么当执行到onDestroy时取消订阅；
• 如果Observable在onStart执行，那么当执行到onStop时取消订阅；
• 如果Observable在onResume执行，那么当执行到onPause时取消订阅；
• 如果Observable在onPause执行，那么当执行到onStop时取消订阅；
• 如果Observable在onStop执行，那么当执行到onDestroy时取消订阅；
• 如果Observable在onDestroy执行，则抛出异常；