1.    定义 

  • RxJava 在 GitHub 的介绍:
RxJava:a library for composing asynchronous and event-based programs using observable sequences for the Java VM
// 翻译:RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库
  • 总结:RxJava 是一个 基于事件流、实现异步操作的库。

     2.    原理

  • RxJava: 基于 一种扩展的观察者模式

  • RxJava的扩展观察者模式中有4个角色:
角色作用
被观察者(Observable) 产生事件
观察者(Observer) 接收事件,并给出响应动作
订阅(Subscribe) 连接 被观察者 & 观察者, 相当于注册监听
事件(Event) 被观察者 & 观察者 沟通的载体
  • 这里用两根水管代替观察者和被观察者, 用通俗易懂的话把它们的关系解释清楚, 在这里我将从事件流这个角度来说明RxJava的基本工作原理。

          先假设有两根水管:上面一根水管为事件产生的水管,叫它上游吧,下面一根水管为事件接收的水管叫它下游吧。

                     

          两根水管通过一定的方式连接起来,使得上游每产生一个事件,下游就能收到该事件。

          这里的上游下游就分别对应着RxJava中的ObservableObserver,它们之间的连接就对应着subscribe(),因此这个关系用RxJava来表示就是:

ChapterOne:

    public static void case1() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }

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

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

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

   打印结果如下:

08-05 17:00:05.072 24086 24086 D ChapterOne: onSubscribe
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 1
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 2
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 3
08-05 17:00:05.073 24086 24086 D ChapterOne: onComplete

           注意: 只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后才开始发送事件.

 

  • 接下来解释一下其中两个陌生的玩意:ObservableEmitterDisposable.
          ObservableEmitter: Emitter是发射器的意思,那就很好猜了,这个就是用来发出事件的,它可以发出三种类型的事件,通过调用emitter的onNext(T value)onComplete()onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

           但是,请注意,并不意味着你可以随意乱七八糟发射事件,需要满足一定的规则

              (1)  上游可以发送无限个onNext, 下游也可以接收无限个onNext.

              (2)  当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.

              (3)  当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.

              (4)  上游可以不发送onComplete或onError.

              (5)  最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

   注: 关于onComplete和onError唯一并且互斥这一点,  是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, **并不一定会导致程序崩溃. 
** 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.

 

只发送onNext事件
 
 
发送onComplete事件
  
              
 
发送onError事件
 
 

 

  • 介绍了ObservableEmitter, 接下来介绍Disposable, 这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件. 相当于我们平时注册监听后,用完了,要反注册监听。

          注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.

ChapterOne:

    public static void case2() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit onComplete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int mCount = 0;

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

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: value = " + value);
                mCount++;
                if (mCount == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

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

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

          打印结果如下:

08-05 17:06:53.809 24399 24399 D ChapterOne: onSubscribe
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 1
08-05 17:06:53.809 24399 24399 D ChapterOne: onNext: value = 1
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 2
08-05 17:06:53.809 24399 24399 D ChapterOne: onNext: value = 2
08-05 17:06:53.809 24399 24399 D ChapterOne: dispose
08-05 17:06:53.809 24399 24399 D ChapterOne: isDisposed : true
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 3
08-05 17:06:53.809 24399 24399 D ChapterOne: emit onComplete
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 4

 

  • 另外, subscribe()有多个重载的方法:
    public final Disposable subscribe() {}
    public final Disposable subscribe(Consumer<? super T> onNext) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    public final void subscribe(Observer<? super T> observer) {}

 

     3.    线程调度

  •  正常情况下, 上游和下游是工作在同一个线程中的, 也就是说上游在哪个线程发事件, 下游就在哪个线程接收事件. 
ChapterOne:

    public static void case3() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: thread = " + Thread.currentThread());
            }
        });
    }

          打印结果如下:

08-05 19:27:09.926 29640 29640 D ChapterOne: subscribe: thread = Thread[main,5,main]
08-05 19:27:09.926 29640 29640 D ChapterOne: accept: thread = Thread[main,5,main]
  • 对于一般的需求场景,需要在子线程中实现耗时的操作;然后回到主线程实现 UI操作。怎么办?

           解决方案:采用 RxJava内置的线程调度器( Scheduler ),即通过 功能性操作符subscribeOn() & observeOn()实现。

           作用:线程控制,即指定 被观察者 (Observable) / 观察者(Observer) 的工作线程类型

           线程类型:

类型含义应用场景
Schedulers.immediate() 当前线程 = 不指定线程 默认
AndroidSchedulers.mainThread() Android主线程 操作UI
Schedulers.newThread() 常规新线程 耗时等操作
Schedulers.io() io操作线程 网络请求、读写文件等io密集型操作
Schedulers.computation() CPU计算操作线程 大量计算操作


  • 具体使用
    public static void case4() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
                emitter.onNext(1);
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "accept: thread = " + Thread.currentThread());
                    }
                });
    }

           特殊注意:(1) 若Observable.subscribeOn()多次指定被观察者 生产事件的线程,则只有第一次指定有效,其余的指定线程无效。

                             (2) 若Observable.observeOn()多次指定观察者 接收 & 响应事件的线程,则每次指定均有效,即每指定一次,就会进行一次线程的切换。

ChapterOne:

    public static void case5() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
                emitter.onNext(1);
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.io())
                .subscribeOn(Schedulers.newThread())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "doOnNext accept: thread = " + Thread.currentThread());
                    }
                })
                .observeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "onNext: accept: thread = " + Thread.currentThread());
                    }
                });
    }
  • 实例:读写数据库
        public Observable<List<Record>> readAllRecords() {
            return Observable.create(new ObservableOnSubscribe<List<Record>>() {
                @Override
                public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
                    Cursor cursor = null;
                    try {
                        cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
                        List<Record> result = new ArrayList<>();
                        while (cursor.moveToNext()) {
                            result.add(Db.Record.read(cursor));
                        }
                        emitter.onNext(result);
                        emitter.onComplete();
                    } finally {
                        if (cursor != null) {
                            cursor.close();
                        }
                    }
                }
            }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
        }


            readAllRecords().subscribe(new Consumer<List<Record>>() {
                @Override
                public void accept(List<Record> recordList) throws Exception {

                }
            })

 

     4.    RxJava相关的库

 

本系列文章参考:

1、RxJava操作符(一)Creating Observables

2、RxJava文档中文版

3、Android RxJava:这是一份全面 & 详细 的RxJava操作符 使用攻略

4、收集了RxJava常见的使用场景,例子简洁、经典、易懂...