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);
    }