RxJava 3.0 中Observable 种类简介

RxJava 3.0 中Observable 种类简介

在RX中,一个Observer(观察者) 可以订阅(subscribe)了一个Observable(可观察者)后,观察者可以对被观察发出的任何项或者序列做出反应.这种模式使并发操作变得容易,观察者无需去等待被观察者发射数据,而是以观察者形式创意一个观察哨兵,随时准备在Observable在任何时候发出一个对象时做出适当的反应.

类型介绍

RxJava 中,被观察者类型有以下几类:

• Observable<R> :可以发射0个或多个item,并在onComplete()或onError() 后结束.

• Single<T> :只能发出 一个onSuccess()或者onError后就结束的可观察者.(没有onComplete() 一个success后就会结束)

• Maybe<T>:可以发射0个或1个item,并可发出onComplete()与onError().只要发出就会结束

• Completable:不发出任何item,只可发出onComplete()与onError(),只关注结束与出错.

• Flowable<@NonNull T>: 支持背压的可观察者,背压是一种处理策略,当上游Observable 发射数据过快,而下游Observer处理能力不足,处理不过来时,可使用其处理.(具体就不做过多介绍了,需要了解可自行查询资料)

RxJava中也对这些被观察类型一一定义了对应观察者类型:

• Observer<T> : 关注上游Observable 所有事件 onNext,onComplete()及onError()
• SingleObserver<T>:仅关注一条数据 或者onError()
• MaybeObserver<T>:关注一条数据 或者 onComplete() 或者 onError()
• CompletableObserver:不关心任何数据,仅关注onComplete() 或者 onError()
• FlowableSubscriber<T>:支持背压处理，可控性一次处理事件数量

简单使用

Observable<R>

被观察者Observable可发出onNext(),onComplete(),onError(),在Complete/Error前,可发射任意个数的onNext,都会被发射出去.

private void observableCreate() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                    emitter.onNext("a");
                    emitter.onNext("b");
                    emitter.onNext("c");
                    emitter.onComplete();
            }
        }).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() {

            }
        });
    }

输出:
	25008-25008/com.sky.rxjava I/sky>>: onNext: a
    25008-25008/com.sky.rxjava I/sky>>: onNext: b
    25008-25008/com.sky.rxjava I/sky>>: onNext: c

Single<T>

只能发射一条onSuccess(),或者一条onError(),onSuccess()重复发射无效,仅会发射第一条,并自动结束.

注意: 只可发射一次,多次无效

    private void singeObservable() {
        Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull SingleEmitter<String> emitter) throws Throwable {
                emitter.onSuccess("Single 发出 onSuccess");
                emitter.onSuccess("Single 发出 onSuccess2");

//                emitter.onError(new Throwable("Single 发出错误通知"));
            }
        }).subscribe(new SingleObserver<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull String s) {
                Log.i("sky>>>", "Single Observable onSuccess: " + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.i("sky>>>", "Single Observable onError: " + e.getMessage());
            }
        });
    }

输出 :
	25577-25577/com.sky.rxjava I/sky>>>: Single Observable onSuccess: Single 发出 onSuccess

Maybe<T>

可发射0或1条onSuccess(),发射1条时,会自动结束,后续onSuccess,onComplete事件无效,也可只单独发送onComplete 或onError

注意:只可发射一次,多次无效

 private void maybeObservable() {
        Maybe.create(new MaybeOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull MaybeEmitter<String> emitter) throws Throwable {
//                    emitter.onSuccess("a");
//                    emitter.onSuccess("b");
                    emitter.onComplete();
//                emitter.onError(new Throwable("Maybe Observable 发出错误通知"));
            }
        }).subscribe(new MaybeObserver<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull String s) {
                Log.i("sky>>>", "Maybe onSuccess: "+ s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.i("sky>>>", "Maybe onError: "+ e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.i("sky>>>", "Maybe onComplete: ");
            }
        });
    }

Completable

仅关注结束与出错,与数据无关,所以其他Observable 都有自己被观察的数据类型泛型,而Completable没有

只能发射一次 onComplete 或onError

    private void completeObservable() {
        Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(@NonNull CompletableEmitter emitter) throws Throwable {
                    emitter.onComplete();;
            }
        }).subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onComplete() {
                Log.i("sky>>>", "Maybe onComplete: ");
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.i("sky>>>", "Maybe onComplete: ");
            }
        });
    }

Flowable<T>

支持背压控制上游数据发射.订阅时返回Subscription,可通过Subscription设置一次消费多少条数据,也可通过它直接取消数据订阅

private  Subscription subscription = null;
    private void flowableObservable() {
        FlowableCreate.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull FlowableEmitter<String> emitter) throws Throwable {
                for (int i = 0; i < 10; i++) {
                    emitter.onNext("" + i);
                    Log.i("sky>>>", "发射: "+i);
                }
                emitter.onComplete();
            }
        }, BackpressureStrategy.MISSING)
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())

                .subscribe(new FlowableSubscriber<String>() {
            @Override
            public void onSubscribe(@NonNull Subscription s) {
                subscription = s;
            }

            @Override
            public void onNext(String s) {
                Log.e("sky>>>>", "flow onNext : " + s);
            }

            @Override
            public void onError(Throwable t) {
                Log.e("sky>>>>", "flow onError : " + t.getMessage());
                subscription = null;
            }

            @Override
            public void onComplete() {
                Log.e("sky>>>>", "flow onComplete" );
                subscription = null;
            }
        });
    }

    /**
     * 点击按钮 同过 subscription 控制每次取几条数据
     */
    public void getData(View view) {
        if(subscription!=null){
            subscription.request(3);
        }

    }

    /**
     * 点击按钮,取消订阅,后续数据丢弃
     */
    public void cancel(View view) {
        if(subscription!=null){
            subscription.cancel();
        }
    }