RxJava初體驗

倒序查看

/**
flatMap 處理一對多關係的轉換
*/
private void flatmap() {
        //嵌套的List，
        ArrayList<ArrayList<String>> list = new ArrayList<>();

        for (int i = 0; i < 5; i++) {
            ArrayList<String> l = new ArrayList<>();

            for (int j = 0; j < 3; j++) {
                l.add(i + "FLATMAP" + j);
            }

            list.add(l);
        }

        //flatMap將Observable轉換爲Observable，無嵌套結構，更加符合響應式
        //處理一對多的數據

        Observable.from(list).flatMap(new Func1<ArrayList<String>, Observable<String>>() {
            @Override
            public Observable<String> call(ArrayList<String> strings) {
                return Observable.from(strings);
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String o) {
                Log.d(TAG, "call: o = " + o);
            }
        });

        //這裏爲上述的方式的，基本實現過程
        //Subscriber決定獲取的參數類型，最終決定返回的參數類型
        Subscriber<String> subscriber = new Subscriber<String>() {
            //忽略之...

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

        Observable.from(list).flatMap(new Func1<ArrayList<String>, Observable<String>>() {
            @Override
            public Observable<String> call(ArrayList<String> strings) {
                return Observable.from(strings);
            }
        }).subscribe(subscriber);
    }


    /**
    map 處理一對一關係的轉換
    */
    private void map() {
        //處理一個運算，將int數組轉換爲字符串
        int[] arr = {1, 2, 3, 4, 5};
        Observable.just(arr)
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                //map操作，將輸入類型轉換爲所需類型，類似於Action，
                //Func1<T,R> extends Function 將T轉換爲R，做爲返回值
                .map(new Func1<int[], String>() {
                    @Override
                    public String call(int[] ints) {
                        StringBuilder sb = new StringBuilder();
                        //
                        for (int i : ints) {
                            sb.append(i);
                        }
                        return sb.toString();
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.d(TAG, "call: " + s);
                    }
                });
    }


    /**
    線程調度器，Schedulers是封裝了Scheduler的工廠方法
    Schedulers.io()在新線程處理任務，與Schedulers.newThread()類似，區別有2：
    1、用於阻塞式的IO處理 
    2、會維護線程池，根據需要增加線程數量，有着更好的性能
    */
    private void scheduler1() {
        Observable.just(1, 2, 3)
                .subscribeOn(Schedulers.io())//在新線程產生事件
                .observeOn(AndroidSchedulers.mainThread())//在MainThread消費事件
                .subscribe(new Subscriber<Integer>() {
                    //...
                    @Override
                    public void onNext(Integer integer) {
                        int i = integer.intValue();
                        Log.d(TAG, "onNext: " + i);
                    }
                });
    }


/**
練習。體會鏈式編程（響應式編程）
*/
private void chain_rx() {

        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                //被觀察者去請求數據，通過傳進來的subscriber對象，將數據傳過去
                subscriber.onNext(200);
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                Toast.makeText(MainActivity.this, "錯誤！", Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onNext(Integer integer) {
                int i = integer.intValue();
                Log.d(TAG, "onNext: "+i);
            }
        });
    }


    /**
    Action0-Action1接口，Subscriber的簡單實現替代
    */
    private void action1() {
        //Action1(Action0無參數) extends Action extends Function(空接口)
        //Action1或Action0爲Subscriber的簡寫形式，分別提供一個和沒有參數的方法，
        //可等價於onNext，onError或者onCompleted的使用

        String [] strings = {"hello","rx_java","! with action1"};
        Observable.from(strings).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "call: "+s);
            }
        });
    }

    /**
    一個典型的RxJava應用
    */
    private void rxjava() {
        //1、創建觀察者（Observer也可）
        //實現了Observer接口，實現了Subscription接口，增加了onStart方法
        Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

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

            //總是在事件產生的線程，不保證MainThread
            @Override
            public void onStart() {
                super.onStart();
            }
        };

        //2、創建被觀察者（回調）
        // 此處傳入OnSubscribe內部接口，Invoked when Observable.subscribe is called.
        // 簡便方法，傳入可變參數或者數組：Observable.just(T ...)或者Observable.from(T [] array)
        //此二者與create方法等價，封裝後的結果
        Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello");
                subscriber.onNext("rx_java");
                subscriber.onNext("!");
                subscriber.onCompleted();
            }
        });

        //3、訂閱
        observable.subscribe(subscriber);
    }