關於rxjava（一）

要在Android中使用RxJava2, 先添加Gradle配置:

   compile 'io.reactivex.rxjava2:rxjava:2.0.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

上面一根水管爲事件產生的水管，叫它上游吧，下面一根水管爲事件接收的水管叫它下游吧。

兩根水管通過一定的方式連接起來，使得上游每產生一個事件，下游就能收到該事件。注意這裏和官網的事件圖是反過來的, 這裏的事件發送的順序是先1,後2,後3這樣的順序, 事件接收的順序也是先1,後2,後3的順序, 我覺得這樣更符合我們普通人的思維, 簡單明瞭.

這裏的上游和下游就分別對應着RxJava中的Observable和Observer，它們之間的連接就對應着subscribe()，因此這個關係用RxJava來表示就是：

//創建一個上游 Observable：
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });
        //創建一個下游 Observer
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        };
        //建立連接
        observable.subscribe(observer);

這個運行的結果就是:

12-02 03:37:17.818 4166-4166/zlc.season.rxjava2demo D/TAG: subscribe
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 1
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 2
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 3
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: complete

注意: 只有當上遊和下游建立連接之後, 上游纔會開始發送事件. 也就是調用了subscribe() 方法之後纔開始發送事件.

把這段代碼連起來寫就成了RxJava引以爲傲的鏈式操作：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

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

ObservableEmitter： Emitter是發射器的意思，那就很好猜了，這個就是用來發出事件的，它可以發出三種類型的事件，通過調用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分別發出next事件、complete事件和error事件。

需要滿足一定的規則：

上游可以發送無限個onNext, 下游也可以接收無限個onNext.
當上遊發送了一個onComplete後, 上游onComplete之後的事件將會繼續發送, 而下游收到onComplete事件之後將不再繼續接收事件.
當上遊發送了一個onError後, 上游onError之後的事件將繼續發送, 而下游收到onError事件之後將不再繼續接收事件.
上游可以不發送onComplete或onError.
最爲關鍵的是onComplete和onError必須唯一併且互斥, 即不能發多個onComplete, 也不能發多個onError, 也不能先發一個onComplete, 然後再發一個onError, 反之亦然

發送多個onComplete是可以正常運行的, 依然是收到第一個onComplete就不再接收了, 但若是發送多個onError, 則收到第二個onError事件會導致程序會崩潰.

	示意圖
只發送onNext事件	next
發送onComplete事件	complete
發送onError事件	error

Disposable, 這個單詞的字面意思是一次性用品,用完即可丟棄的. 那麼在RxJava中怎麼去理解它呢, 對應於上面的水管的例子, 我們可以把它理解成兩根管道之間的一個機關, 當調用它的dispose()方法時, 它就會將兩根管道切斷, 從而導致下游收不到事件.

注意: 調用dispose()並不會導致上游不再繼續發送事件, 上游會繼續發送剩餘的事件.

來看個例子, 我們讓上游依次發送1,2,3,complete,4,在下游收到第二個事件之後, 切斷水管, 看看運行結果:

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

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

結果爲：

12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: subscribe
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: dispose
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: isDisposed : true
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 3
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit complete
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 4

從運行結果我們看到, 在收到onNext 2這個事件後, 切斷了水管, 但是上游仍然發送了3, complete, 4這幾個事件, 而且上游並沒有因爲發送了onComplete而停止. 同時可以看到下游的onSubscribe()方法是最先調用的.

Disposable的用處不止這些, 後面講解到了線程的調度之後, 我們會發現它的重要性. 隨着後續深入的講解, 我們會在更多的地方發現它的身影.

另外, subscribe()有多個重載的方法:

public final Disposable subscribe() {}
    public final Disposable subscribe(Consumer<? super T> onNext) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    public final void subscribe(Observer<? super T> observer) {}

不帶任何參數的subscribe() 表示下游不關心任何事件,你上游儘管發你的數據去吧, 老子可不管你發什麼.
帶有一個Consumer參數的方法表示下游只關心onNext事件, 其他的事件我假裝沒看見, 因此我們如果只需要onNext事件可以這麼寫:

當我們在主線程中去創建一個上游Observable來發送事件, 則這個上游默認就在主線程發送事件.

當我們在主線程去創建一個下游Observer來接收事件, 則這個下游默認就在主線程中接收事件,

@Override                                                                                       
protected void onCreate(Bundle savedInstanceState) {                                            
    super.onCreate(savedInstanceState);                                                         
    setContentView(R.layout.activity_main);                                                     
                                                                          
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {   
        @Override                                                                               
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {            
            Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());           
            Log.d(TAG, "emit 1");                                                               
            emitter.onNext(1);                                                                  
        }                                                                                       
    });                                                                                         
                                                                                                
    Consumer<Integer> consumer = new Consumer<Integer>() {                                      
        @Override                                                                               
        public void accept(Integer integer) throws Exception {                                  
            Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());              
            Log.d(TAG, "onNext: " + integer);                                                   
        }                                                                                       
    };                                                                                          
                                                                                                
    observable.subscribe(consumer);                                                             
}

在主線程中分別創建上游和下游, 然後將他們連接在一起, 同時分別打印出它們所在的線程, 運行結果爲:

我們更多想要的是這麼一種情況, 在子線程中做耗時的操作, 然後回到主線程中來操作UI, 用圖片來描述就是下面這個圖片:

thread.png

在這個圖中, 我們用黃色水管表示子線程, 深藍色水管表示主線程.

要達到這個目的, 我們需要先改變上游發送事件的線程, 讓它去子線程中發送事件, 然後再改變下游的線程, 讓它去主線程接收事件. 通過RxJava內置的線程調度器可以很輕鬆的做到這一點. 接下來看一段代碼:

Override                                                                                       
protected void onCreate(Bundle savedInstanceState) {                                            
    super.onCreate(savedInstanceState);                                                         
    setContentView(R.layout.activity_main);                                                     
                                                                                                
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {   
        @Override                                                                               
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {            
            Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());           
            Log.d(TAG, "emit 1");                                                               
            emitter.onNext(1);                                                                  
        }                                                                                       
    });                                                                                         
                                                                                                
    Consumer<Integer> consumer = new Consumer<Integer>() {                                      
        @Override                                                                               
        public void accept(Integer integer) throws Exception {                                  
            Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());              
            Log.d(TAG, "onNext: " + integer);                                                   
        }                                                                                       
    };                                                                                          
                                                                                                
    observable.subscribeOn(Schedulers.newThread())                                              
            .observeOn(AndroidSchedulers.mainThread())                                          
            .subscribe(consumer);                                                               
}

可以看到, 上游發送事件的線程的確改變了, 是在一個叫 RxNewThreadScheduler-2的線程中發送的事件, 而下游仍然在主線程中接收事件, 這說明我們的目的達成了, 接下來看看是如何做到的.

和上一段代碼相比,這段代碼只不過是增加了兩行代碼:

.subscribeOn(Schedulers.newThread())                                              
.observeOn(AndroidSchedulers.mainThread())

簡單的來說, subscribeOn() 指定的是上游發送事件的線程, observeOn() 指定的是下游接收事件的線程.

多次指定上游的線程只有第一次指定的有效, 也就是說多次調用subscribeOn() 只有第一次的有效, 其餘的會被忽略.

多次指定下游的線程是可以的, 也就是說每調用一次observeOn() , 下游的線程就會切換一次.

observable.subscribeOn(Schedulers.newThread())     
         .subscribeOn(Schedulers.io())              
         .observeOn(AndroidSchedulers.mainThread()) 
         .observeOn(Schedulers.io())                
         .subscribe(consumer);

這段代碼中指定了兩次上游發送事件的線程, 分別是newThread和IO線程, 下游也指定了兩次線程,分別是main和IO線程. 運行結果爲:

D/TAG: Observable thread is : RxNewThreadScheduler-3
D/TAG: emit 1                                       
D/TAG: Observer thread is :RxCachedThreadScheduler-1
D/TAG: onNext: 1

可以看到, 上游雖然指定了兩次線程, 但只有第一次指定的有效, 依然是在RxNewThreadScheduler 線程中, 而下游則跑到了RxCachedThreadScheduler 中, 這個CacheThread其實就是IO線程池中的一個.

爲了更清晰的看到下游的線程切換過程, 我們加點log:

observable.subscribeOn(Schedulers.newThread())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "After observeOn(mainThread), current thread is: " + Thread.currentThread().getName());
                    }
                })
                .observeOn(Schedulers.io())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "After observeOn(io), current thread is : " + Thread.currentThread().getName());
                    }
                })
                .subscribe(consumer);

我們在下游線程切換之後, 把當前的線程打印出來, 運行結果:

D/TAG: Observable thread is : RxNewThreadScheduler-1                                             
D/TAG: emit 1                                                                                    
D/TAG: After observeOn(mainThread), current thread is: main                                      
D/TAG: After observeOn(io), current thread is : RxCachedThreadScheduler-2                        
D/TAG: Observer thread is :RxCachedThreadScheduler-2                                             
D/TAG: onNext: 1

在RxJava中, 已經內置了很多線程選項供我們選擇, 例如有

Schedulers.io() 代表io操作的線程, 通常用於網絡,讀寫文件等io密集型的操作
Schedulers.computation() 代表CPU計算密集型的操作, 例如需要大量計算的操作
Schedulers.newThread() 代表一個常規的新線程
AndroidSchedulers.mainThread() 代表Android的主線程

這些內置的Scheduler已經足夠滿足我們開發的需求, 因此我們應該使用內置的這些選項, 在RxJava內部使用的是線程池來維護這些線程, 所有效率也比較高.

注：本文總結自Season_zlc的給初學者的RxJava2.0教程

關於rxjava（一）

dialog點擊外邊框不讓其消失

App通過瀏覽器下載更新的實現方法

android build不成功或者依賴包衝突問題的解決思路

recyclerView滑動停止後item對齊方式

Parcelable傳值崩潰問題

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結