Rxjava学习笔记(一)

RxJava 2.0

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

compile ‘io.reactivex.rxjava2:rxjava:2.0.1’
compile ‘io.reactivex.rxjava2:rxandroid:2.0.1’

简单使用姿势：

        //1.创建被观察者
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(11);
                e.onNext(8);
                e.onComplete();
            }

        });

        //2.创建观察者
        Observer<Integer> observer = new Observer<Integer>() {

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

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

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

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

        };

        //3.观察者 进入 被观察者的订阅
        observable.subscribe(observer);

链式调用：

        //链式调用
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(11);
                e.onNext(8);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
                         @Override
                         public void onSubscribe(Disposable d) {
                             Log.i(TAG, "onSubscribe: ");
                         }

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

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

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

执行结果：

12-29 22:05:25.654 8416-8416/tyl.rxjavap I/rxjavaTest: onSubscribe:

22:05:25.654 8416-8416/tyl.rxjavap I/rxjavaTest: onNext: 33 12-29

22:05:25.654 8416-8416/tyl.rxjavap I/rxjavaTest: onNext: 48 12-29

22:05:25.654 8416-8416/tyl.rxjavap I/rxjavaTest: onNext: 265 12-29

22:05:25.654 8416-8416/tyl.rxjavap I/rxjavaTest: onComplete:

执行顺序onSubscribe->onNext->onComplete/onError;

• 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之后下游不会继续接收事件）

---

• Disposable相当于RxJava1.x中的Subscription,用于解除订阅(可理解为切断水管，水依旧还在流，但是流不到下游)。

  如果在请求的过程中Activity已经退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了。我可以调用Disposable的dispose()方法切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.
  
  那如果有多个Disposable 该怎么办呢？ RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管.
  

---

线程控制

基本使用姿势

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.i(TAG, "subscribe:  currentThread is :" + Thread.currentThread().getName());
                e.onNext(1);

                e.onComplete();
            }
        })      // 指定上游线程
                .subscribeOn(Schedulers.newThread())//新线程
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept 1: "  + " currentThread is :" + Thread.currentThread().getName());
                    }
                })
                .subscribeOn(Schedulers.io())//io线程
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept 2: " + " currentThread is :" + Thread.currentThread().getName());
                    }
                })
                //指定下游线程
                .observeOn(AndroidSchedulers.mainThread())//主线程
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept 3: " + " currentThread is :" + Thread.currentThread().getName());
                    }
                })
                .observeOn(Schedulers.io())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept 4: " +  " currentThread is :" + Thread.currentThread().getName());
                    }
                })
                .subscribe(new Consumer<Integer>() {
                               @Override
                               public void accept(Integer integer) throws Exception {
                                   Log.i(TAG, "Consumer accept: " + " currentThread is :" + Thread.currentThread().getName());
                               }
                           }
                );
    }

控制台输出：

subscribe: currentThread is :RxNewThreadScheduler-1

accept 1: currentThread is :RxNewThreadScheduler-1

accept 2: currentThread is :RxNewThreadScheduler-1

accept 3: currentThread is :main accept 4: currentThread is
:RxCachedThreadScheduler-2

Consumer accept: currentThread is :RxCachedThreadScheduler-2

• subscribeOn（Scheduler scheduler）只能指定一次

• observeOn（Scheduler scheduler）可指定多次，每调用一次observeOn() 线程便会切换一次

  内置线程：

  • Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
  • Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
  • Schedulers.newThread() 代表一个常规的新线程
  • AndroidSchedulers.mainThread() 代表Android的主线程

---

Todo： DoOnNext（）方法里做数据比对和缓存处理？

---

参考资料（十分感谢大神们的博客）
@Season-给初学者的RxJava2.0教程
@扔物线 -给 Android 开发者的 RxJava 详解