Android rxjava2 學習筆記

____tz_zs

一、hello world

創建 Observable 被觀察者
創建 Observer 觀察者
使用 subscribe 訂閱

public void tzzs_rxjava2_demo() {
   
   
        /*
         * hello world
         * */
        Observable.create(new ObservableOnSubscribe<Object>() {
   
   
            @Override
            public void subscribe(@NonNull ObservableEmitter<Object> emitter) throws Exception {
   
   
                emitter.onNext("tzzs");
            }
        }).subscribe(new Consumer<Object>() {
   
   
            @Override
            public void accept(Object o) throws Exception {
   
   
                System.out.println("接收到: " + o);
            }
        });
    }

二、五種觀察者模式

• Observable 和 Observer
  被觀察者 Observable 能夠發射 0 或 n 個數據，並以成功或錯誤事件終止
  
• Flowable 和 Subscriber
  被觀察者 Flowable 能夠發射 0 或n個數據，並以成功或錯誤事件終止。支持背壓，可以控制數據源發射的速度
  
• Single 和 SingleObserver
  被觀察者 Single 只發射單個數據或錯誤事件
  
• Completable 和 CompletableObserver
  被觀察者 Completable 從來不發射數據，只處理 onComplete 和 onError 事件。可以看成 Rx 的 Runnable
  
• Maybe 和 MaybeObserver
  被觀察者 Maybe 能夠發射 0 或者 1 個數據，要麼成功，要麼失敗。有點類似於 Optional
  

三、do 操作符

do 操作符可以給 Observable 的生命週期的各個階段加上一系列的回調監聽，當 Observable 執行到這個階段時，這些回調就會被觸發。

• doOnSubscribe
  一旦觀察者訂閱了 Observable，它就會被調用
  
• doOnLifecycle
  可以在觀察者訂閱之後，設置是否取消訂閱
  
• doOnNext
  它產生的 Observable 每發射一項數據就會調用它一次，它的 Consumer 接受發射的數據項。一般用於在 subscribe 之前對數據進行處理
  
• doOnEach
  它產生的 Observable 每發射一項數據就會調用它一次，不僅包括 onNext ，還包括 onError 和 onCompleted
  
• doAfterNext
  在 onNext 之後執行，而 doOnNext() 是在 onNext 之前執行
  
• doOnComplete
  當它產生的 Observable 在正常終止調用 onComplete 時會被調用
  
• doFinally
  在當它產生的 Observable 終止之後會被調用，無論是正常終止還是異常終止。doFinally 優先於 doAfterTerminate 的調用
  
• doAfterTerminate
  註冊一個 Action，當 Observable 調用 onComplete 或 onError 時觸發
  

四、創建操作符

1. create

create() 使用一個函數從頭創建一個 Observable。

public void tzzs_rxjava2_create() {
   
   
        /*
         * create()
         * 使用一個函數從頭創建一個 Observable。
         * */
        Observable.create(new ObservableOnSubscribe<Integer>() {
   
   
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
   
   
                try {
   
   
                    if (!emitter.isDisposed()) {
   
    // 檢查觀察者的 isDisposed 狀態，沒有觀察者時，停止發送數據。
                        for (int i = 0; i < 10; i++) {
   
   
                            System.out.println("emitter.onNext:" + i);
                            emitter.onNext(i);
                        }
                        System.out.println("emitter.onComplete");
                        emitter.onComplete();
                    }
                } catch (Exception e) {
   
   
                    emitter.onError(e);
                }
            }
        }).subscribe(new Consumer<Integer>() {
   
   
            @Override
            public void accept(Integer integer) throws Exception {
   
   
                System.out.println("接收到: " + integer);
            }
        }, new Consumer<Throwable>() {
   
   
            @Override
            public void accept(Throwable throwable) throws Exception {
   
   
                System.out.println("報錯: " + throwable.getMessage());
            }
        }, new Action() {
   
   
            @Override
            public void run() throws Exception {
   
   
                System.out.println("結束");
            }
        });

        /*
        emitter.onNext:0
        接收到: 0
        emitter.onNext:1
        接收到: 1
        emitter.onNext:2
        接收到: 2
        emitter.onNext:3
        接收到: 3
        emitter.onNext:4
        接收到: 4
        emitter.onNext:5
        接收到: 5
        emitter.onNext:6
        接收到: 6
        emitter.onNext:7
        接收到: 7
        emitter.onNext:8
        接收到: 8
        emitter.onNext:9
        接收到: 9
        emitter.onComplete
        結束
        * */
    }

2. just

just() 將一個或多個對象轉換爲發射這個或這些對象的一個 Observable。

public void tzzs_rxjava2_just() {
   
   
        /*
         * just()
         * 將一個或多個對象轉換爲發射這個或這些對象的一個 Observable。
         */
        Observable.just("just發送的字符串")
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到：" + s);
                    }
                });
        Observable.just("1", "2", "3", "4")// 可以接受一到十個參數，返回一個按照參數列表順序發射這些數據的 Observable。
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到：" + s);
                    }
                }, new Consumer<Throwable>() {
   
   
                    @Override
                    public void accept(Throwable throwable) throws Exception {
   
   
                        System.out.println("報錯: " + throwable.getMessage());
                    }
                }, new Action() {
   
   
                    @Override
                    public void run() throws Exception {
   
   
                        System.out.println("結束");
                    }
                });
        /*
        接收到：just發送的字符串
        接收到：1
        接收到：2
        接收到：3
        接收到：4
        結束
        * */

        Observable.just("1", "2", "3", "4", "", null)//rxjava2 中 just() 不能傳入 null。 java.lang.NullPointerException: The sixth item is null
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到：" + s);

                    }
                });
    }

3. from

from() 將一個 Iterable、一個 Future 或者一個數組轉換成一個 Observable。

public void tzzs_rxjava2_from() {
   
   
        /*
         * from()
         * 將一個 Iterable、一個 Future 或者一個數組轉換成一個 Observable。
         * */
        Observable.fromArray("1", "2")
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到：" + s);
                    }
                });
        /*
        接收到：1
        接收到：2
        * */

        ArrayList<Integer> items = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
   
   
            items.add(i);
        }

        Observable.fromArray(items)
                .subscribe(new Consumer<ArrayList<Integer>>() {
   
   
                    @Override
                    public void accept(ArrayList<Integer> integers) throws Exception {
   
   
                        System.out.println("接收到：" + integers);
                    }
                });
        /*
        接收到：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        * */

        Observable.fromIterable(items)
                .subscribe(new Consumer<Integer>() {
   
   
                    @Override
                    public void accept(Integer integer) throws Exception {
   
   
                        System.out.println("接收到：" + integer);
                    }
                });
        /*
        接收到：0
        接收到：1
        接收到：2
        接收到：3
        接收到：4
        接收到：5
        接收到：6
        接收到：7
        接收到：8
        接收到：9
        * */
    }

4. timer

timer() 創建一個在給定的延時之後發射單個數據的 Observable。

public void tzzs_rxjava2_timer() {
   
   
        /*
         * timer()
         * 創建一個在給定的延時之後發射單個數據的 Observable。
         * */
        Observable.timer(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
   
   
                    @Override
                    public void accept(Long aLong) throws Exception {
   
   
                        System.out.println("延遲接收到消息：" + aLong);
                    }
                });

        try {
   
   
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }
    }

五、變換操作符和過濾操作符

1. map

map() 對 Observable 發射的每一項數據都應用一個你選擇的函數，執行變換操作，然後返回一個發射這些結果的 Observable。

public void tzzs_rxjava2_map() {
   
   
        /*
         * map()
         * 對 Observable 發射的每一項數據都應用一個你選擇的函數，執行變換操作，然後返回一個發射這些結果的 Observable。。
         * */
        Observable.just("just message")
                .map(new Function<String, String>() {
   
   
                    @Override
                    public String apply(@NonNull String s) throws Exception {
   
   
                        return s + "｜map 操作｜";
                    }
                })
                .map(new Function<String, String>() {
   
   
                    @Override
                    public String apply(@NonNull String s) throws Exception {
   
   
                        return s + "｜map2 操作｜";
                    }
                })
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到：" + s);
                    }
                });
        /*
        接收到：just message｜map 操作｜｜map2 操作｜
        * */
	}

2. flatMap

flatMap() 將一個發射數據的 Observable 變換爲多個 Observables，然後將他們發射的數據合併後放進一個單獨的 Observable。
具體的，使用一個指定的函數對原始 Observable 發射的每一項數據執行變換操作，這個函數返回一個本身也發射數據的 Observable，然後 flatMap 合併這些 Observables 發射的數據，最後將合併後的結果當作自己的數據序列發射。

public void tzzs_rxjava2_flatmap() {
   
   
        /*
         * flatMap()
         * 將一個發射數據的 Observable 變換爲多個 Observables，然後將他們發射的數據合併後放進一個單獨的 Observable。
         *
         * 使用一個指定的函數對原始 Observable 發射的每一項數據執行變換操作，這個函數返回一個本身也發射數據的 Observable，然後合併這些 Observables 發射的數據，最後將合併後的結果當作自己的數據序列發射。
         * */
        Observable.just("1", "2", "3").delay(1, TimeUnit.SECONDS)
                .flatMap(new Function<String, ObservableSource<Integer>>() {
   
   
                    @Override
                    public ObservableSource<Integer> apply(@NonNull String s) throws Exception {
   
   
                        // 對原始 Observable 發射的一項數據執行變換
                        List<Integer> list = new ArrayList<>();
                        for (int i = 5; i < 7; i++) {
   
   
                            list.add(Integer.parseInt(s) * 10 + i);
                        }
                        return Observable.fromIterable(list).delay(1, TimeUnit.SECONDS); // 對這項變換後的數據，創建一個新 Observable 返回。
                    }
                })
                .flatMap(new Function<Integer, ObservableSource<String>>() {
   
   
                    @Override
                    public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
   
   
                        return Observable.just("flatMap just1: " + integer, "flatMap just2: " + integer).delay(1, TimeUnit.SECONDS);
                    }
                })
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到消息：" + s);
                    }
                });
        try {
   
   
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }
        /*
        接收到消息：flatMap just1: 25
        接收到消息：flatMap just1: 26
        接收到消息：flatMap just2: 26
        接收到消息：flatMap just2: 25
        接收到消息：flatMap just1: 36
        接收到消息：flatMap just1: 15
        接收到消息：flatMap just2: 15
        接收到消息：flatMap just1: 35
        接收到消息：flatMap just2: 35
        接收到消息：flatMap just1: 16
        接收到消息：flatMap just2: 16
        接收到消息：flatMap just2: 36
        * */
	}

3. concatMap

flatMap 不能保證發射的順序，使用 concatMap 則會嚴格按照順序發射這些數據。

public void tzzs_rxjava2_concatmap() {
   
   
        Observable.just("1", "2", "3").delay(1, TimeUnit.SECONDS)
                .concatMap(new Function<String, ObservableSource<Integer>>() {
   
   
                    @Override
                    public ObservableSource<Integer> apply(@NonNull String s) throws Exception {
   
   
                        // 對原始 Observable 發射的一項數據執行變換
                        List<Integer> list = new ArrayList<>();
                        for (int i = 5; i < 7; i++) {
   
   
                            list.add(Integer.parseInt(s) * 10 + i);
                        }
                        return Observable.fromIterable(list).delay(1, TimeUnit.SECONDS); // 對這項變換後的數據，創建一個新 Observable 返回。
                    }
                })
                .concatMap(new Function<Integer, ObservableSource<String>>() {
   
   
                    @Override
                    public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
   
   
                        return Observable.just("concatMap just1: " + integer, "concatMap just2: " + integer).delay(1, TimeUnit.SECONDS);
                    }
                })
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到消息：" + s);
                    }
                });
        try {
   
   
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }
        /*
        接收到消息：concatMap just1: 15
        接收到消息：concatMap just2: 15
        接收到消息：concatMap just1: 16
        接收到消息：concatMap just2: 16
        接收到消息：concatMap just1: 25
        接收到消息：concatMap just2: 25
        接收到消息：concatMap just1: 26
        接收到消息：concatMap just2: 26
        接收到消息：concatMap just1: 35
        接收到消息：concatMap just2: 35
        接收到消息：concatMap just1: 36
        接收到消息：concatMap just2: 36
        * */
    }

4. filter

filter() 指定一個斷言函數測試數據項，通過來測試的數據（返回爲true）纔會被髮射。

public void tzzs_rxjava2_filter() {
   
   
        /*
         * filter()
         * 指定一個斷言函數測試數據項，通過來測試的數據（返回爲true）纔會被髮射。
         * */
        Observable.just("1", "2", "3", "4", "5", "6").delay(1, TimeUnit.SECONDS)
                .filter(new Predicate<String>() {
   
   
                    @Override
                    public boolean test(@NonNull String s) throws Exception {
   
   
                        return Integer.parseInt(s) > 2;
                    }
                })
                .subscribe(new Consumer<String>() {
   
   
                    @Override
                    public void accept(String s) throws Exception {
   
   
                        System.out.println("接收到消息：" + s);
                    }
                });
        try {
   
   
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }
        /*
        接收到消息：3
        接收到消息：4
        接收到消息：5
        接收到消息：6
        * */
    }

六、合併操作符和連接操作符

1. merge

merge() 將多個 Observable 合併爲一個。merge 是按照時間線並行。merge 最多隻能合併 4 個被觀察者，多餘 4 個則需使用 mergeArray。

public void tzzs_rxjava2_merge() {
   
   
        /*
         * merge()
         * 將多個 Observable 合併爲一個。merge 是按照時間線並行。merge 最多隻能合併 4 個被觀察者，多餘 4 個則需使用 mergeArray。
         * */
        Observable<String> observable_tzzs_1 = Observable.just("tzzs_1_1", "tzzs_1_2").delay(2, TimeUnit.SECONDS);
        Observable<String> observable_tzzs_2 = Observable.just("tzzs_2_1", "tzzs_2_2").delay(2, TimeUnit.SECONDS);
        Observable<String> observable_tzzs_3 = Observable.just("tzzs_3_1", "tzzs_3_2").delay(1, TimeUnit.SECONDS);

        Observable
                .merge(observable_tzzs_1, observable_tzzs_2, observable_tzzs_3)
                .subscribe(new DisposableObserver<String>() {
   
   
                    @Override
                    public void onNext(@NonNull String s) {
   
   
                        System.out.println("接收到消息：" + s);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
   
   
                        System.out.println("報錯: " + e.getMessage());
                    }

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

        try {
   
   
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }

        /*
        接收到消息：tzzs_3_1
        接收到消息：tzzs_3_2
        接收到消息：tzzs_1_1
        接收到消息：tzzs_1_2
        接收到消息：tzzs_2_1
        接收到消息：tzzs_2_2
        結束
        * */
    }

2. concat

concat() 將多個 Observable 合併爲一個。與 merge 的不同在於，concat 是按發送順序串行執行。

public void tzzs_rxjava2_concat() {
   
   
        /*
         * concat()
         * 將多個 Observable 合併爲一個。與 merge 的不同在於，concat 是按發送順序串行執行。
         * */
        Observable<String> observable_tzzs_1 = Observable.just("tzzs_1_1", "tzzs_1_2").delay(2, TimeUnit.SECONDS);
        Observable<String> observable_tzzs_2 = Observable.just("tzzs_2_1", "tzzs_2_2").delay(2, TimeUnit.SECONDS);
        Observable<String> observable_tzzs_3 = Observable.just("tzzs_3_1", "tzzs_3_2").delay(1, TimeUnit.SECONDS);

        Observable
                .concat(observable_tzzs_1, observable_tzzs_2, observable_tzzs_3)
                .subscribe(new DisposableObserver<String>() {
   
   
                    @Override
                    public void onNext(@NonNull String s) {
   
   
                        System.out.println("接收到消息：" + s);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
   
   
                        System.out.println("報錯: " + e.getMessage());
                    }

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

        try {
   
   
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }

        /*
        接收到消息：tzzs_1_1
        接收到消息：tzzs_1_2
        接收到消息：tzzs_2_1
        接收到消息：tzzs_2_2
        接收到消息：tzzs_3_1
        接收到消息：tzzs_3_2
        結束
        * */
    }