Android之RxJava2

 

RxJava 以观察者模式为骨架，在 2.0 中依旧如此。

不过此次更新中，出现了两种观察者模式：

• Observable ( 被观察者 ) / Observer ( 观察者 )

• Flowable （被观察者）/ Subscriber （观察者）

导入项目：

// RxJava
implementation "io.reactivex.rxjava2:rxjava:2.2.7"
implementation "io.reactivex.rxjava2:rxandroid:2.1.1"

 

Observable

1.被观察者 （小说），开始连载，读者订阅小说（subscribe），那么小说更新后 就会推送消息给读者。

       // 步骤1：创建被观察者 Observable & 生产事件
//        // 即 连载小说，读者订阅小说，小说更新推送给读者
//
        //  1. 创建被观察者 Observable 对象  小说novel

        Observable<String> novel = Observable.create(new ObservableOnSubscribe<String>() {
            // 2. 在复写的subscribe（）里定义需要发送的事件
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                // 通过 ObservableEmitter类对象产生事件并通知观察者
                // ObservableEmitter类介绍
                // a. 定义：事件发射器
                // b. 作用：定义需要发送的事件 & 向观察者发送事件
                emitter.onNext("连载1"); //开始连载小说
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        });
//
//
        //步骤2：创建观察者 Observer 并 定义响应事件行为    读者 reader
        //读者订阅小说

        Observer<String> reader = new Observer<String>() {
            // 通过复写对应方法来 响应 被观察者
            @Override
            public void onSubscribe(Disposable d) {
                d.dispose();//    取消订阅 连载小说更新的时候就不会再推送给读者
                Log.e(TAG, "开始采用subscribe连接");
            }
            // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(String value) {
                Log.e(TAG, "对Next事件"+ value +"作出响应"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "对Complete事件作出响应");
            }
        };
        // 步骤3：通过订阅（subscribe）连接观察者和被观察者
        // 即 小说被读者订阅
        novel.subscribe(reader);

 2.异步

    //异步
        Observable.create(new ObservableOnSubscribe<List>() {
            @Override
            public void subscribe(ObservableEmitter<List> emitter) throws Exception {
                drawableRes = new ArrayList<>(); //.......从数据库中取出id资源数组操作
                emitter.onNext(drawableRes);
                emitter.onComplete();
            }
        }).flatMap(new Function<List, ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> apply(List list) throws Exception {
                return Observable.fromIterable(list);
            }
        }).subscribeOn(Schedulers.io())//在IO线程执行数据库处理操作
                .observeOn(AndroidSchedulers.mainThread())//在UI线程显示图片
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d("----","onSubscribe");
                    }

                    @Override
                    public void onNext(Integer integer) {
//                        imageView.setImageResource(integer);//拿到id,加载图片
//                        Log.d("----",integer+"");
                    }

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

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

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("rxjava");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread())  //事件产生的线程。  Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。

 //Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。


                .observeOn(AndroidSchedulers.mainThread())  // 事件消费的线程。 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
//                        d.dispose();//取消订阅
                        Log.d("----", "onSubscribe");
                    }

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

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

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

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

 

Flowable

Flowable是RxJava2.x中新增的类，专门用于应对背压（Backpressure）问题，但这并不是RxJava2.x中新引入的概念。所谓背压，即生产者的速度大于消费者的速度带来的问题，比如在Android中常见的点击事件，点击过快则会造成点击两次的效果。
我们知道，在RxJava1.x中背压控制是由Observable完成的，使用如下：

  Observable.range(1,10000)
            .onBackpressureDrop()
            .subscribe(integer -> Log.d("JG",integer.toString()));

而在RxJava2.x中将其独立了出来，取名为Flowable。因此，原先的Observable已经不具备背压处理能力。
通过Flowable我们可以自定义背压处理策略。

测试Flowable例子如下：

  Flowable.create(new FlowableOnSubscribe<Integer>() {

            @Override
            public void subscribe(FlowableEmitter<Integer> e) throws Exception {

                for(int i=0;i<10000;i++){
                    e.onNext(i);
                }
                e.onComplete();
            }
        }, FlowableEmitter.BackpressureMode.ERROR) //指定背压处理策略，抛出异常
                .subscribeOn(Schedulers.computation())
                .observeOn(Schedulers.newThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d("JG", integer.toString());
                        Thread.sleep(1000);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d("JG",throwable.toString());
                    }
                });

或者可以使用类似RxJava1.x的方式来控制。

 

  Flowable.range(1,10000)
                .onBackpressureDrop()
                .subscribe(integer -> Log.d("JG",integer.toString()));

其中还需要注意的一点在于，Flowable并不是订阅就开始发送数据，而是需等到执行Subscription#request才能开始发送数据。当然，使用简化subscribe订阅方法会默认指定Long.MAX_VALUE。手动指定的例子如下：

        Flowable.range(1,10).subscribe(new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);//设置请求数
            }

            @Override
            public void onNext(Integer integer) {

            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        });