1. 程式人生 > >4章 RxJava基本響應型別

4章 RxJava基本響應型別

CSDN學院課程地址

4. RxJava基本響應型別

4.1 Observable

Observable是最基本的響應型別,但不支援背壓,基本上適用大多數的應用場景

有關背壓的概念等,都會在下一章介紹

public static void observable() {
    //建立被觀察者
    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        //預設在主執行緒裡執行該方法
        public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
            e.onNext("俊俊俊很帥");
            e.onNext("你值得擁有");
            e.onNext("取消關注");
            e.onNext("但還是要保持微笑");
            e.onComplete();
        }
    })
            //將被觀察者切換到子執行緒
            .subscribeOn(Schedulers.io())
            //將觀察者切換到主執行緒  需要在Android環境下執行
            //.observeOn(AndroidSchedulers.mainThread())
            //建立觀察者並訂閱
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {
                    System.out.println("onNext=" + s);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("onError=" + e.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("onComplete");
                }
            });
}

輸出

onNext=俊俊俊很帥
onNext=你值得擁有
onNext=取消關注
onNext=但還是要保持微笑
onComplete

4.2 Flowable

Flowable和Observable的使用基本相同,只不過Observable不支援背壓,而Flowable支援背壓。但需要注意的是,使用Flowable的時候,必須呼叫Subscription的requsest方法請求,不然上游是不會發射資料的

public static void flowable() {
    //建立被觀察者
    Flowable.create(new FlowableOnSubscribe<String>() {
        @Override
        public void subscribe(FlowableEmitter<String> e) throws Exception {
            e.onNext("俊俊俊很帥");
            e.onNext("你值得擁有");
            e.onNext("取消關注");
            e.onNext("但還是要保持微笑");
            e.onComplete();
        }
    }, BackpressureStrategy.DROP)
            //將被觀察者切換到子執行緒
            .subscribeOn(Schedulers.io())
            //將觀察者切換到主執行緒  需要在Android環境下執行
            //.observeOn(AndroidSchedulers.mainThread())
            //建立觀察者並訂閱
            .subscribe(new Subscriber<String>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(2);
                }

                @Override
                public void onNext(String s) {
                    System.out.println("onNext=" + s);
                }

                @Override
                public void onError(Throwable t) {
                    System.out.println("onError=" + t.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("onComplete");
                }
            });
}

輸出

onNext=俊俊俊很帥
onNext=你值得擁有

4.3 Single

Single只發射一個元素,發射onSuccessonError方法,所以沒有complete方法,不像Observable或者Flowable,資料發射完成之後,需要呼叫complete告訴下游已經完成

public static void single() {
    //建立被觀察者
    Single.create(new SingleOnSubscribe<String>() {
        @Override
        public void subscribe(SingleEmitter<String> e) throws Exception {
            e.onSuccess("success");
        }
    })
            //將被觀察者切換到子執行緒
            .subscribeOn(Schedulers.io())
            //將觀察者切換到主執行緒  需要在Android環境下執行
            //.observeOn(AndroidSchedulers.mainThread())
            //建立觀察者並訂閱
            .subscribe(new SingleObserver<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onSuccess(String s) {
                    System.out.println("onSuccess=" + s);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("onError=" + e.getMessage());
                }
            });
}

輸出

onSuccess=success

4.4 Completable

Completable不會發射資料,只會給下游傳送一個訊號。回撥onCompleteonError方法

public static void completable() {
    //建立被觀察者
    Completable.create(new CompletableOnSubscribe() {
        @Override
        public void subscribe(CompletableEmitter e) throws Exception {
            e.onComplete();
        }
    })
            //將被觀察者切換到子執行緒
            .subscribeOn(Schedulers.io())
            //將觀察者切換到主執行緒  需要在Android環境下執行
            //.observeOn(AndroidSchedulers.mainThread())
            //建立觀察者並訂閱
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onComplete() {
                    System.out.println("onComplete");

                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("onError=" + e.getMessage());
                }
            });
}

輸出

onComplete

4.5 Maybe

Maybe是Single和Completable的結合,需要注意的是onSuccess和onComplete方法只會執行其中一個,這不同於Observable和Flowable最後是以onComplete()結尾

public static void maybe() {
    //建立被觀察者
    Maybe.create(new MaybeOnSubscribe<String>() {
        @Override
        public void subscribe(MaybeEmitter<String> e) throws Exception {
            e.onSuccess("success");
            e.onComplete();
        }
    })
            //將被觀察者切換到子執行緒
            .subscribeOn(Schedulers.io())
            //將觀察者切換到主執行緒  需要在Android環境下執行
            //.observeOn(AndroidSchedulers.mainThread())
            //建立觀察者並訂閱
            .subscribe(new MaybeObserver<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onSuccess(String s) {
                    System.out.println("onSuccess=" + s);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("onError=" + e.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("onComplete");
                }
            });
}

輸出

onSuccess=success

4.6 小結

  1. Observable:最基本的響應型別,不支援背壓
  2. Flowable:最基本的響應型別,支援背壓
  3. Single:只發射一個數據的響應型別
  4. Completable:只發射一個訊號的響應型別
  5. Maybe:Single和Completable的結合體