RxJava的基礎知識

1、Observable

一、使用RxJava的三步驟

（1）、創建Observable

             被觀察者，使用RxJava需要一個被觀察者，決定什麼時候觸發事件以及觸發怎麼樣的事件，決定異步操作模塊的順序和異步操作模塊的次數

（2）、創建Observer

             創建一個處於待命狀態的觀察者哨兵，可以在未來某個時刻響應Observable的通知，不需要阻塞等待Observable發射數據

（3）、使用subscribe()訂閱

             將Observable和Observer連接起來

 Observable
                .just("Hello World")
                .doOnNext((s) -> System.out.println(s + " kruaser"))
                .doOnNext((s) -> System.out.println(s + " kruaser2"))
                .doAfterNext(s -> System.out.println(s + " kruaser3"))
                .doAfterNext(s -> System.out.println(s + " kruaser4"))
                .doOnComplete(() ->
                        System.out.println("done2!")
                )
                .doOnSubscribe((disposable1) ->
                        System.out.println("begin2!")
                )
                .doOnEach((n) -> System.out.println("=>"+n.isOnNext()))
                .subscribe(
                        System.out::println,
                        System.out::println,
                        () -> System.out.println("done!"),
                        (disposable1) ->
                                System.out.println("begin!"));

 

2、5種觀察者模式

類型	描述
Observable	能夠發射0或n個數據，並以成功或錯誤事件終止
Flowable	能夠發射0或n個數據，並以成功或錯誤事件終止，可以控制數據源發射速度
Single	只能發射單個數據或錯誤事件
Completable	從來不發射數據，只處理onComplete和OnError事件
Maybe	能夠發射0或者個數據，要麼成功，要麼失敗

 

   // Single 只有onSuccess和onError
        Single.create(emitter -> {
                    // 發射
                    emitter.onSuccess("test");
                    // 不發射
                    emitter.onSuccess("test1");
                }
        ).subscribe(
                // success
                System.out::println,
                // error
                System.err::println);

        // Completable不會發射任何數據
        Disposable subscribe = Completable.create(completableEmitter -> {
            try {
                // 不會發射任何數據
                completableEmitter.onComplete();
            } catch (Exception e) {
                completableEmitter.onError(e);
            }
        })
                // 完成之後的操作
                .andThen(Observable.range(0, 10))
                .subscribe(System.out::println);

        // Maybe
        Maybe.create(completableEmitter -> {
            try {
                // 不會發射任何數據
                completableEmitter.onComplete();
                completableEmitter.onSuccess("test");
                completableEmitter.onSuccess("test1");
            } catch (Exception e) {
                completableEmitter.onError(e);
            }
        }).subscribe(System.out::println);

 

3、Hot和Cold Observable

Hot Observable無論有沒有觀察者進行訂閱，事件始終都會發生,與訂閱者麼是一對多的關係
Cold Observable是隻有觀察者訂閱了，纔開始執行發射數據流的代碼,與訂閱者是一對一的關係

  /**
     * Cold Observable是隻有觀察者訂閱了，纔開始執行發射數據流的代碼,與訂閱者是一對一的關係
     */
    public void codeObservableDemo() {
        Observable<String> observable = Observable.create(emitter ->
                emitter.onNext("Hello world")
        );

        observable.subscribe((s1) ->
                System.out.println("s1:" + s1)
        );
        observable.subscribe((s2) ->
                System.out.println("s2:" + s2)
        );

    }

    /**
     * Hot Observable無論有沒有觀察者進行訂閱，事件始終都會發生,與訂閱者麼是一對多的關係
     */
    public void hotObservableDemo() {
        ConnectableObservable<StringBuffer> publish = ConnectableObservable
                .just(new StringBuffer("test"))
                .publish();

        // 線程安全的，共享變量
        publish.subscribe((s) -> System.out.println(s.append("k1").toString()));
        publish.subscribe((s) -> System.out.println(s + " krauser2"));

        // 只有調用了connect才能真正的執行
        publish.connect();
    }

Hot Observable轉化成Cold Observable

ConnectableObservable的refCount

Observable的share

Cold Observable轉化成Hot Observable

Observable的publish

使用subject/processor（支持back pressure）

   PublishSubject<String> subject = PublishSubject.create();

        // subject作爲觀察者,訂閱目標的Code Observable
        subject.subscribe(s1 ->
                System.out.println("s1:" + s1)
        );
        subject.subscribe(s2 ->
                System.out.println("s2:" + s2)
        );


        Observable<String> observable = Observable.create(emitter ->
                emitter.onNext("Hello world")
        );

        // subject作爲被觀察者，轉發或者發送新的事件
        observable.subscribe(subject);