简介

什么是RxJava？ GitHub给出的介绍是：RxJava是ReactiveX（Reactive Extensions）的Java VM实现：用于通过使用可观察序列来编写异步和基于事件的程序的库。

在我的理解中RxJava主要可以实现异步任务，和事件总线的功能，这也是RxJava的厉害之处。

RxJava的GitHub地址：

https://github.com/ReactiveX/RxJava/wiki

使用

关于RxJava的使用详解，该篇文章会介绍更加详细，而且主要偏向于对RxJava的使用。

创建

创建一个观察者，有两种方式实现：创建Observer和Subscriber。

Observer：

Observer<String> observer = new Observer<String>() {
            @Override
            public void onError(Throwable e) {
                Log.i("test", "onError");
            }

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

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

            @Override
            public void onNext(String s) {
                Log.i("test", "onNext----->" + s);
            }
        };

Subscriber：

Subscriber subscriber = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.i("test", "onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                Log.i("test", "onNext");
            }

            @Override
            public void onError(Throwable t) {
                Log.i("test", "onError");
            }

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

创建被观察者，并且需要和观察者订阅起来，在RxJava中的被观察者是Observable使用subscribe方法订阅。

创建被观察者有三种方式可以实现：

1）使用Observable.create创建

        Observable.create(new ObservableOnSubscribe<String>(){

            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("你好");
            }
        }).subscribe(observer);//订阅

在创建方式需要在subscribe方法里，手动调用Observer的onNext、onError、onComplete方法，而onSubscribe方法是自动调用的。

2）Observable.just 可以使用Observable.just方式来创建一个Observable

Observable.just("你好","hello world").subscribe(observer);

使用Observable.just创建，然后subscribe订阅，这种方式会自动调用onSubscribe、onNext、onError和onComplete方法。

3）Observable.fromArray

使用Observable.fromArray来创建一个Observable对象。

String[] quotations = {"热爱祖国", "热爱人民"};
Observable.fromArray(quotations).subscribe(observer);

使用Observable.fromArray创建，然后订阅，和Observable.just一样，会自动调用观察者的方法。

观察者的方法

在上面我们已经创建了一个观察，创建一个观察者，其中包括四个方法：onError、onComplete、onSubscribe和onNext。

那么这几个方法都表示什么呢？

onSubscribe：被观察者订阅观察者的时候，就会触发该方法。

onCompleted：事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext 发出时，需要触发 onCompleted方法作为标志。

onError：事件队列异常。在事件处理过程中出异常时，onError方法会被触发，同时队列自动终止，不允许再有事件发出。

onNext：表示普通事件，可以在该方法做一些业务逻辑处理。

操作符

操作符包括普通的操作符、变换操作符、过滤操作符、组合操作符、辅助操作符、错误处理操作符、条件操作符、布尔操作符和转换操作符。

普通操作符包括：interval、repeat和intervalRange等等。

使用，如：

        Observable.intervalRange(0,6,0,3,TimeUnit.SECONDS).create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("666");
            }
        }).subscribe(observer);

intervalRange该操作符是用于延迟执行、并且定期执行。

变换操作符包括：map、flatMap、cast和concatMap等等。

map：指定一个Function对象，将Observable转换为一个新的Observable并发射。

        Observable.just("你好","hello world").map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                return s;
            }
        }).subscribe(observer);

flatMap、cast：

        Observable.just("你好","hello world").flatMap(new Function<String, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(@NonNull String s) throws Exception {
                return Observable.just(s);
            }
        }).cast(String.class).subscribe(observer);

flatMap将Observable发射的数据集合变换为Observable集合，然后将这些Observable发射的数据平坦地放进一个单独的Observable，而cast则强制将Observable发射的所有数据转换为指定类型。

buffer操作符功能：

1、能一次性集齐多个结果到列表中，订阅后自动清空相应结果，直到完全清除

2、也可以周期性的集齐多个结果到列表中，订阅后自动清空相应结果，直到完全清除

        Observable
                .range(0,5)
                .buffer(2)
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {

                    }

                    @Override
                    public void onNext(@NonNull List<Integer> integers) {
                        Log.i("test","----------------->onNext:" + integers);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

Observable
                .just("你好","hello world","我爱我家")
                .buffer(3)
                .subscribe(new Observer<List<String>>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {

                    }

                    @Override
                    public void onNext(@NonNull List<String> strings) {
                        Log.i("test",""+strings);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

除了以上的变换操作符，还有groupBy操作符，进行分组操作。

过滤操作符

过滤操作符包括filter、skip、take、element等等。

filter：对Observable产生的结果自定义规则进行过滤，只有满足条件的结果才提交给订阅者。

Observable
                .just("你好","hello world","我爱我家")
                .filter(new Predicate<String>() {
                    @Override
                    public boolean test(@NonNull String s) throws Exception {
                        Log.i("test",""+s);
                        return s.equals("你好");
                    }
                }).subscribe(observer);

distinct：去重

        Observable
                .just("你好","hello world","我爱我家","我爱我家")
                .distinct()
                .subscribe(observer);

skip：过滤掉前n项

        Observable
                .just("你好","hello world","我爱我家","我爱我家")
                .skip(2)
                .subscribe(observer);

take：取前n项

        Observable
                .just("你好","hello world","我爱我家","我爱我家")
                .take(2)
                .subscribe(observer);

throttleWithTimeout：如果在限定的时间内，源Observable有新的数据发射出来，该数据就会被丢弃，同时throttleWithTimeout重新开始计时，如果每次都是在计时结束前发射数据，那么这个限流就会走向极端（只会发射最后一个数据）

Observable
                .just("你好","hello world","我爱我家","我爱我家")
                .throttleWithTimeout(200, TimeUnit.MILLISECONDS)
                .subscribe(observer);

组合操作符

组合操作符包括：merge、startWidth、concat、jion、switch和zip等等。

merge：将多个Observable合并到一个Observable中进行发射。

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.i("test", "onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.i("test", "onNext--->" + s);
            }

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

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

        Observable<String> observable1 = Observable.just("你好", "hello World");
        Observable<String> observable2 = Observable.just("new obj", "mergeobj");
        Observable.merge(observable1, observable2).subscribe(observer);

concat：将多个Observable发射的数据合并发射，其具有严格的顺序，发射顺序具有队列的特点。前一个数据没有发射完成不会发射后一个数据。

Observable<String> observable1 = Observable.just("你好", "hello World");
Observable<String> observable2 = Observable.just("new obj", "mergeobj");
Observable.concat(observable1, observable2).subscribe(observer);

除了以上的组合操作符，还有zip、combineLastest等。

zip：合并两个或者多个Obserable发射出的数据项，根据指定的函数变换它们，并发射一个新值。

辅助操作符

辅助操作符包括DO、delay、observeOn、timeout、timeInterval、timestamp、subscribeOn、meterialize和to等。

delay：延迟执行发射数据

Observable<String> observable1 = Observable.just("你好", "hello World");
Observable<String> observable2 = Observable.just("new obj", "mergeobj");
Observable.concat(observable1, observable2).delay(5, TimeUnit.SECONDS).subscribe(observer);

subscribeOn：指定Obserable自身在那个线程上运行。

observeOn：指定Obserable发射出的数据在那个线程运行。

其他的操作符读者可以自行实践。

错误操作符

在rxjava中，错误操作符包括catch和retry。

catch能够拦截原始Observable的onError通知，将它替换为其他数据项或者数据序列，让产生的Observable能够正常终止或者根本不终止。 catch实现分为三个不同的操作符：

1、onErrorReturn：返回原有Observable行为的备用Observable，备用的Observable忽略原有的Observable的onError调用，即不会将错误传递给观察者，而是发射一个特殊的项，以及调用观察者的onCompleted。

2、onErrorResumeNext：跟onErrorReturn一样返回备用的Observable，不会调用原有的Observable的onError，它会发射备用的Observable数据。

3、onExceptionResumeNext：如果onError收到的Throwable不是一个Exception，它会将错误传递给观察者的onError方法，不会使用备用的Observable。

retry：不会将原有的Observable的onError通知传递给观察者，这会订阅这个Observable，再给它一次机会无错误地完成其数据序列，而它总会传递onNext通知给观察者。该操作符有可能造成数据重复，因为重新订阅。如果超过了重新订阅的次数，就不会再次订阅了，而是把最新的一个onError通知传递给观察者。

条件操作符

条件操作符包括：defaultEmpty、skipUntil、amb、skipWhile、takeUtil、takeWhile

defaultEmpty：如果原有的Observable没有发射数据，就发射一个默认的数据。

skipUntil：订阅原始的Observable，但是忽略它的发射物，直到第二个Observable发射了一项数据那一刻，它开始发射原始Observable。

布尔操作符

布尔操作符包括：all、isEmpty、contains、exists和sequenceEqual。

关于条件操作符和布尔操作符，读者可以关注《RxJava操作符(08-条件和布尔操作) 》这篇文章，文章地址：

http://blog.csdn.net/xmxkf/article/details/51671826

转换操作符

转换操作符能够将Observable转换为另一个对象或者数据结构，其中转换操作符包括：toMap、toMultiMap、toList、toSortedList、nest和getIterator等。

toMap：将原始的Observable发射的所有数据项集合到一个Map中，然后发射该Map。

String s1 = "你好";
        String s2 = "hello world";
        String s3 = "lalala";

        Observable.just(s1,s2,s3).toMap(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                return s;
            }
        }).subscribe(new SingleObserver<Map<String, String>>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull Map<String, String> stringStringMap) {
                Log.i("test",""+stringStringMap);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }
        });

toMultiMap：类似于toMap，不同的地方在于map的value是一个集合。

toList：将发射的数据组成一个List。

String s1 = "你好";
        String s2 = "hello world";
        String s3 = "lalala";

        Observable.just(s1,s2,s3).toList().subscribe(new SingleObserver<List<String>>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull List<String> strings) {
                Log.i("test",""+strings);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }
        });

关于其他操作符，读者可以参考《RxJava操作符大全》这篇文章。

RxJava的线程控制

前面讲解辅助操作符的时候，我们知道使用subscribeOn可以指定Obserable自身在那个线程上运行。使用observeOn可以指定Obserable发射出的数据在那个线程运行。RxJava默认线程是在调用subcribe方法的线程上进行回调，但是如果想切换线程，就需要使用Scheduler。

在RxJava中内置了以下几个Scheduler：

1、Scheduler.immediate()：运行在当前线程，是timeout、timestamp和timeInterval操作符的默认调度器。

2、Scheduler.io()：I/O操作使用的Scheduler。

3、Scheduler.newThread()：开启一个新的线程执行操作。

2和3的区别就是：2的内部实现了一个无数量上限的线程池，重用空闲的线程，因此2具有更高的效率。

4、Scheduler.trampoline()：可以将任务通过trampoline方法加入队列，该调度器会按顺序处理队列的任务，是repeat和retry操作符的默认调度器。

5、Scheduler.computation()：计算所使用的调度器，它具有固定的线程池，大小为cpu核数，注意不要将io操作放到computation中，否则io操作的等待时间会浪费cpu。该调度器是buffer、delay、sample、debounce、interval和skip的默认调度器。

6、AndroidSchedulers.mainThread()：表示在主线程中运行，该调度器是RxAndroid提供的。

Observable.just("你好","hello world")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);

写到这里，关于RxJava的知识基本讲解完了，相信读者读完该文，也懂得使用RxJava了，接下来我更新RxJava结合Retrofix和OkHttp的使用，敬请关注，谢谢！