Android響應式編程之RxJava2.0

前言

優點：

1、鏈式操作
2、異步優化

實戰

先來個簡單的使用示例

        Observable
                .create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                        e.onNext("1");
                        e.onNext("2");
                        e.onComplete();
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "onNext: " + s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

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

輸出Log

onNext: 1
onNext: 2
onComplete:

項目依賴

dependencies {
    // RxJava
    compile 'io.reactivex.rxjava2:rxjava:2.0.8'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'com.trello.rxlifecycle2:rxlifecycle:2.0.1'
    compile 'com.trello.rxlifecycle2:rxlifecycle-android:2.0.1'
    compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
}

線程調度器，用於靈活的切換線程，RxJava內置主要提供了以下幾個，基本夠用了

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

操作符

變換操作

Map

簡單的說就是中間轉換層，把被觀察者發送的數據->進行轉換後->再發送給觀察者接收。

用實例來證明

        Observable
                .create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                        Log.d(TAG, "onNext: 1");
                        e.onNext(1);
                        Log.d(TAG, "onNext: 2");
                        e.onNext(2);
                    }
                })
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(@NonNull Integer integer) throws Exception {
                        Log.d(TAG, "apply: map");
                        return "format to string " + integer;
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: " + s);
                    }
                });

輸出Log

onNext: 1
apply: map
accept: format to string 1
onNext: 2
accept: format to string 2

FlagMap

將一個發送事件的Observable變換生成新的一個或多個發送事件的Observable，再發送。
注意：合併後發送順序是無序的。

用實踐來證明

        Observable
                .create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                        Log.d(TAG, "onNext: 1");
                        e.onNext(1);
                        Log.d(TAG, "onNext: 2");
                        e.onNext(2);
                    }
                })
                .flatMap(new Function<Integer, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
                        Log.d(TAG, "apply: flatMap");
                        List<String> list = new ArrayList<String>();
                        for (int i = 0; i < 3; i++) {
                            list.add("format to string " + integer);
                        }
                        return Observable.fromIterable(list);
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: " + s);
                    }
                });

輸出Log

onNext: 1
apply: flatMap
accept: format to string 1
format to string 1
accept: format to string 1
onNext: 2
apply: flatMap
accept: format to string 2
accept: format to string 2
accept: format to string 2

ConcatMap

根FlatMap基本一樣，唯一區別就是發送順序是有序的。

Zip

將多個發送事件的Observable，合併生成一個新的發送事件的Observable，再發送。
注意：合併順序是嚴格按照發送順序來的，並且生成的新的發送事件數量，取發送事件數量最少的那個，這個應該可以理解。

用實例來證明

        Observable obb1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                Log.d(TAG, "onNext: A");
                e.onNext("A");
                Log.d(TAG, "onNext: B");
                e.onNext("B");
                Log.d(TAG, "onNext: C");
                e.onNext("C");
                Log.d(TAG, "onNext: D");
                e.onNext("D");
            }
        }).subscribeOn(Schedulers.io());
        Observable obb2 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "onNext: 1");
                e.onNext(1);
                Log.d(TAG, "onNext: 2");
                e.onNext(2);
                Log.d(TAG, "onNext: 3");
                e.onNext(3);
            }
        }).subscribeOn(Schedulers.io());
        Observable
                .zip(obb1, obb2, new BiFunction<String, Integer, String>() {
                    @Override
                    public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
                        Log.d(TAG, "apply: zip");
                        return s + "+" + integer;
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.d(TAG, "accept: " + s);
                    }
                });

輸出Log

onNext: A
onNext: B
onNext: C
onNext: D
onNext: 1
apply: zip
accept: A+1
onNext: 2
apply: zip
accept: B+2
onNext: 3
apply: zip
accept: C+3

……
未完待續