RxJava2应用场景案列

1.资源释放

1.资源释放

     if(disposable!=null&&!disposable.isDisposed()){
        disposable.isDisposed();
      }

2.拿到disposable的三种方式
2.1.1 方式一

    Disposable disposable = Observable.just(1).subscribe(onNext, onError,onAction);

2.1.2这种方式有一个问题，因为多是三个独立的回调，所以这种方式很难复用。
2.1.3.使用Observer

    Observable.just(1).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
          Disposable disposable=d;
        },onnext,onError,onComplete
      });

2.1.4这种方式话 Observer本事可以实现继承，但是拿到disposable很不方便.我们很难在基类中做释放操作。
2.2第二种方式

    Observer<String> disable = Observable.just("1").subscribeWith(new Observer<String>() {
           onSubscribe,onNext,onError,onComplete);

2.2.1我们在基类中写一个addSubscribe():

    protected CompositeDisposable mCompositeDisposable;
    protected void addSubscribe(Disposable subscription) {
        if (mCompositeDisposable == null) {
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(subscription);
    }

    protected void unSubscribe() {
        if (mCompositeDisposable != null) {
            mCompositeDisposable.clear();
        }
    }

2.2.2.在基(activity,fragment)相应的生命周期中做释放操作:

    public void onDestory(){
        unSubscribe();
    }

2.2.3.额外,基于subscibeWith的复用:

    public MyObserver extend Observer{
    private BaseView mView;

    public MyObserver (View view){
         mView=view;
    }

    @Override
    public void onError(Throwable e) {
        mView.showErrorMsg(e);
    }
    @Override
    public void onComplete() {
        ....同理
    }
}

2.3.1基于rxLifecycler ,使用方式,官方例子:

    //我的actity
    public class MyActity extends RxAppCompatActivity{
    protected void onCreate(Bundle savedInstanceState) {
    Observable.interval(1, TimeUnit.SECONDS)
                .doOnDispose(action)
            .compose(this.<Long>bindUntilEvent(ActivityEvent.PAUSE))
            .subscribe(onNext);
    }
    }


    public abstract class RxAppCompatActivity extends AppCompatActivity{
        lifecycleSubject.onNext(ActivityEvent.PAUSE);//关键
    }

2.3.2 从上面看很明显是利用到了subject的特性，发送一个ActivityEvent.PAUSE,
利用某种特性解除绑定:

    public class RxLifecycle{
            @Nonnull
    @CheckReturnValue
    public static <T, R> LifecycleTransformer<T> bindUntilEvent(@Nonnull final Observable<R> lifecycle,
                                                                @Nonnull final R event) {
        checkNotNull(lifecycle, "lifecycle == null");
        checkNotNull(event, "event == null");
        return bind(takeUntilEvent(lifecycle, event));//关注
    }

    //这里对相应event做了过滤,很明显ActivityEvent.PAUSE能通过
    private static <R> Observable<R> takeUntilEvent(final Observable<R> lifecycle, final R event) {
        return lifecycle.filter(new Predicate<R>() {
            @Override
            public boolean test(R lifecycleEvent) throws Exception {
                return lifecycleEvent.equals(event);
            }
        });
    }
    }

   //所以我们来看一下bind
    绑定source到lifecycle上面
    @Nonnull
    @CheckReturnValue
    public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }

    @ParametersAreNonnullByDefault
    public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,

        LifecycleTransformer(Observable<?> observable) {
        checkNotNull(observable, "observable == null");
        this.observable = observable; //这个observable实际上就是通过的ActivityEvent.pause.
    }

    @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);//takeUtils的作用是接收到特定对象就停止. 到这里我们的自己实现的Obserable->upstream上游就识别到啦
    }

    public abstract class RxActivity {
    @Override
    @CallSuper
    protected void onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE);//所以在onPause中发送了一个PAUSE,那我们对应的绑定了subject的流也就解除绑定了
    }
}
}

2.3.3总而言之,rxLife可以与生命周期绑定，做资源释放,因此也最具灵活性。就我个人而言，平时使用最多的还是第二种。因为使用rxLife需要对生命周期有一定的掌控力。不然就成了杀鸡用牛刀。