RxJava 學習筆記(1)

 

創建一個被觀察者，併發送事件，發送的事件不可以超過10個以上。指定被觀察者的線程，要注意的時，如果多次調用此方法，只有第一次有效。RxJava的Git地址

https://github.com/ReactiveX/RxAndroid

什麼是RxJava

響應式編程的一個實現

什麼是編程範式？

編程是爲了解決問題，而解決問題可以有多種視角和思路，其中具有普適性的模式被歸結爲範式。我們常說的：“面向對象”，“面向過程”都是編程範式。

什麼是響應式編程

專注於數據流和變化傳遞的異步編程範式，響應式編程，本質上是對數據流或某種變化所作出的反應，但是這個變化什麼時候發生是未知的，所以他是一種基於異步、回調的方式在處理問題。

什麼是同步和非同步、阻塞和非阻塞

同步：是指一個進程在執行某個請求的時候，若該請求需要一段時間才能返回信息，那麼這個進程將會一直等待下去，直到收到返回信息才繼續執行下去

異步：是指進程不需要一直等下去，而是繼續執行下面的操作，不管其他進程的狀態。當有消息返回時系統會通知進程進行處理，這樣可以提高執行的效率。

同步和異步關注的是消息通信機制

阻塞調用：是指調用結果返回之前，當前線程會被掛起。一直處於等待消息通知，不能夠執行其他業務，調用線程只有在得到結果之後纔會返回。

非阻塞調用：指在不能立刻得到結果之前，該調用不會阻塞當前線程，而會立刻返回。

阻塞和非阻塞關注的是程序在等待調用結果（消息，返回值）時的狀態

一般異步是配合非阻塞使用的，這樣才能發揮異步的效用。

RxJava基於觀察者模式實現的

假設場景：A是連載小說，B是讀者，讀者訂閱了連載小說，當小說出現了新的連載的時候，會推送給讀者。讀者不用時刻盯着小說連載，而小說有了新的連載會主動推送給讀者。

RxJava demo （基於RxJava2）

配置：

implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'io.reactivex.rxjava2:rxjava:2.2.11'

第一步：創建被觀察者（創建小說-，其中小說就是對應的事件流）

//被觀察者
        Observable novel=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("連載1");
                emitter.onNext("連載2");
                emitter.onNext("連載3");
                emitter.onComplete();
            }
        });

第二步：創建觀察者（）讀者

//觀察者
        Observer<String> reader=new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                mDisposable=d;
                Log.e(TAG,"onSubscribe");
            }

            @Override
            public void onNext(String value) {
                if ("2".equals(value)){
                    mDisposable.dispose();
                    return;
                }
                Log.e(TAG,"onNext:"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG,"onError="+e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e(TAG,"onComplete()");
            }
        };

第三步：建立訂閱關係

novel.subscribe(reader);//一行代碼搞定

RxJava進階

https://juejin.im/post/5b17560e6fb9a01e2862246f

對於一個事件流，可能需要對其進行一系列操作變換之後再發送給訂閱者，這個中間的處理過程就叫做變換，RxJava的操作符介紹如下

線程切換

指定被觀察者的線程，要注意的時，如果多次調用此方法，只有第一次有效。

public final Observable<T> subscribeOn(Scheduler scheduler)

指定觀察者的線程，每指定一次就會生效一次。 

public final Observable<T> observeOn(Scheduler scheduler)

線程類型說明如下：

創建操作符

create（）創建一個被觀察者

public static <T> Observable<T> create(ObservableOnSubscribe<T> source)

 just（）創建一個被觀察者，併發送事件，發送的事件不可以超過10個以上。

public static <T> Observable<T> just(T item) 
......
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)

 fromArray() 這個方法和 just() 類似，只不過 fromArray 可以傳入多於10個的變量，並且可以傳入一個數組。

public static <T> Observable<T> fromArray(T... items)

fromCallable() 這裏的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它會返回一個結果值，這個結果值就是發給觀察者的。

public static <T> Observable<T> fromCallable(Callable<? extends T> supplier)

fromFuture()參數中的 Future 是 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，它可以通過 get() 方法來獲取Callable 返回的值。

public static <T> Observable<T> fromFuture(Future<? extends T> future)

fromIterable()直接發送一個 List 集合數據給觀察者

public static <T> Observable<T> fromIterable(Iterable<? extends T> source)

defer()這個方法的作用就是直到被觀察者被訂閱後纔會創建被觀察者

public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier)

timer()當到指定時間後就會發送一個 0L 的值給觀察者

public static Observable<Long> timer(long delay, TimeUnit unit) 

interval()每隔一段時間就會發送一個事件，這個事件是從0開始，不斷增1的數字。

public static Observable<Long> interval(long period, TimeUnit unit)
public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit)

 intervalRange()可以指定發送事件的開始值和數量，其他與 interval() 的功能一樣。

public static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
public static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

range()同時發送一定範圍的事件序列。

public static Observable<Integer> range(final int start, final int count)

 rangeLong()作用與 range() 一樣，只是數據類型爲 Long

public static Observable<Long> rangeLong(long start, long count)

 empty() & never() & error()

empty() ： 直接發送 onComplete() 事件

never()：不發送任何事件

error()：發送 onError() 事件

public static <T> Observable<T> empty()
public static <T> Observable<T> never()
public static <T> Observable<T> error(final Throwable exception)

public static Observable<Long> timer(long delay, TimeUnit unit)