Rxjava2(一)、基础概念及使用

时间 2019-12-31

原文原文链接

Android进阶系列之第三方库知识点整理。java

知识点总结，整理也是学习的过程，若有错误，欢迎批评指出。react

写这篇文章的时候，Rxjava3已经出来了，两者差异不是特别大，因此仍是基于Rxjava2进行总结，后续会花时间来总结Rxjava3的一些改变。android

基础概念

一、什么是Rx

ReactiveX是Reactive Extensions的缩写，通常简写为Rx，最初是LINQ的一个扩展，Rx是由由微软开发并开源的一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持不少语言，而 Rxjava 是Rx库基于Java语言提供的函数库。web

官网显示支持的语言列表：编程

二、观察者模式

观察者模式（Observer），又叫发布-订阅模式（Publish/Subscribe），定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则全部依赖于它的对象都会获得通知并自动更新,观察者模式属于行为型模式。多线程

我须要打电话跟小明说他被戴绿帽这事，可是我又怕打电话过去他可能在忙，因此我直接给他发信息，让他有时间了再给我回电话，这样，当小明有时间了可能就会给我回电话，他给我回电话，我再含着泪的告诉他要坚强。app

在上面这个例子中，小明就是被观察者，我是观察者，我发短信告诉他有时间回我电话这个操做就是订阅，这样我跟他有了依赖关系，当他有时间后，就会回我带电话，我这边响应式的执行后续的操做。异步

三、响应式(Reactive Programming)编程

通常来讲，编程就是为了处理问题，解决问题就能够有不一样的视角和思路，其中具备普适性的模式就会归结一种编程思想，咱们常说的面向对象，面向过程都是一种编程思想。ide

响应式编程是一种经过异步和数据流来构建事务关系的编程模式函数

这里面包含的两个核心概念：

异步：不须要等待处理完成便马上返回，经过回调将处理结果带回。能提升吞吐量，提升性能和效率。

数据流：就是按照时间线的事件序列，任何东西均可以看作是一个stream。在这个基础上经过函数来过滤(filter)、选择(select)、变换(transform)、结合(combine)这些stream。经过定义事件处理器，来异步捕获感兴趣的stream，即监听（订阅）stream，也叫就是注册观察者。

再对比咱们前面的观察者模式看，观察者模式中被观察者和观察者之间经过订阅产生依赖，订阅这层关系至关于在两者以前挖了一道水渠，被观察者是上游，观察者是下游，这样被观察者发生改变时候，会将数据流源源不断的发送到产生依赖关系的观察者，一般观察者和被观察者是处于同一个线程中，可是响应式编程重点在异步上，即上游和下游能够在不一样的线程中工做。

咱们能够看一下官网的动图：

四、Rxjava概念及简单使用

Rxjava采用了响应式编程模式，它在观察者模式基础上进行扩展，方便咱们的异步操做，观察者与被观察者产生订阅关系后，被观察者将数据流发送给观察者的时候，Rxjava提供了丰富的操做符来对数据流进行过滤(filter)、选择(select)、变换(transform)、结合(combine)等等操做，而后再将处理后的数据发送给观察者，又因为其特别棒的链式调用，让逻辑在很复杂的状况下，也能很清晰的经过代码表达出来。

咱们先引入rxjava

implementation "io.reactivex.rxjava2:rxjava:2.2.8"
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
复制代码

直接先来一个简单的例子：

  // 经过 Observable 建立一个被观察者
  Observable mObservable = Observable.create(new ObservableOnSubscribe() {
         @Override
         public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

        // 经过Observer建立一个观察者
        Observer mObserver = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        };
        // 产生订阅关系
        mObservable.subscribe(mObserver);
复制代码

再看看Rxjava强大的链式调用：

Observable.create(new ObservableOnSubscribe() {
       @Override
       public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
            // 这里直接经过subscribe将两者链式调用起来
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--Observer--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--Observer--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--Observer--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--Observer--onComplete");
            }
        });
复制代码

咱们前面说，RxJava是拓展于观察者模式的响应式编程，因此在Rxjava中，就有观察者、被观察者以及两者经过订阅产生的依赖关系。

经过上面代码，能够看到：

被观察者 ——————> Observable

观察者 ——————> Observer

订阅关系：Observable ————> subscribe <———— Observer

在上游的 Observable （被观察者）中经过 emitter（发射器）就能够不断地给下游的 Observer （观察者）传送数据流，咱们在上游发射了一、二、3还有发射了一个 onComplete 事件。

咱们经过日志能够看到，在下游的 Observer （观察者）成功的接收到了上游发送的数字一、二、3包括经过调用 onComplete()方法来接收上游发送的 onComplete 事件。

经过上面一个简单的例子，咱们能够总结出如下几点

4.一、解耦

咱们能够看到被观察者和观察者都是独立存在的。

Observable（被观察者）：

  // 经过 Observable 建立一个被观察者
  Observable mObservable = Observable.create(new ObservableOnSubscribe() {
         @Override
         public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });
复制代码

Observer（观察者）：

 // 经过Observer建立一个观察者
        Observer mObserver = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        };
复制代码

能够看到，两者各自独立存在，各干各的事，只是经过 subscribe 来创建依赖关系，这样的话，能够很好地实现代码的复用，好比咱们能够建立多个Observer（观察者），和Observable（被观察者）之间经过订阅创建依赖关系后，就能实现Observable（被观察者）发送的数据流被多个Observer（观察者）接收。

4.二、数据流转换（操做符的使用）

第2、Observable（被观察者）经过 emitter（发射器）将数据以流的形式发送给Observer（观察者），前面讲了，既然是以流的形式，那咱们是否是能够在观察者接收数据以前，对数据进行处理呢？答案是确定的，这也是Rxjava的强大之一，它能够经过各类操做符来对数据进行处理，咱们先讲一个简单的来。

这里只是简单的演示一些Rxjava对数据流的操做，后面会具体讲操做符，图片中能够看到，咱们被观察者明明发射的是一个int型的数值100，可是经过map操做符进行数据流进行转换后，下游的消费者接收到的居然是String的，这里只是一个小Demo,在Rxjava中，还有各类很强大的操做符来对数据进行各类变态式的处理。

上游被观察者Observable发射数据，下游除了使用Observer来接收数据外，还可使用消费者Consumer来接收数据，能够看Consumer只有一个accept方法。

先贴一下Rxjava强大的操做符列表，是否是不少？不要被吓到，越多因此咱们能够越方便的对数据流进行各类各样的操做，这个后面会单独再讲解。

4.三、线程切换

咱们前面说了，Rxjava能更好的异步操做，咱们先用上面的例子打印一下他们当前所在的线程状况。

结果：

能够到，统一战线的都在主线程，咱们来看看，怎么实现异步。

一样是那个例子，咱们添加了下面这两个代码

subscribeOn(Schedulers.io())
observeOn(AndroidSchedulers.mainThread())
复制代码

subscribeOn : 指定上游执行的线程

observeOn：指定观察者或者消费者执行线程

结果：

代码中，咱们指定上游在io线程，而下游在主线程执行，就这么简单的两行代码，就实现了线程切换，实现了异步操做，爽不爽？

固然，咱们不光能够指定io线程，Schedulers还提供了其余的线程供咱们选择。

咱们简单看一个Single线程的源码：

是否是很熟悉？就是经过线程池来建立了一个单线程，其余相似，都是经过线程池来建立，您能够简单去分析一下，固然，若是你对线程池还不熟悉的话，这篇多线程(三)、线程池 ThreadPoolExecutor 知识点总结可能适合你看看。

总结

Rxjava的东西还挺多的，这篇先简单的走了一遍Rxjava的基础概念还有简单的使用，关于Rxjava里面还有其余的观察者模式的建立，背压，各类操做符的使用、实战等等骚操做，下篇继续。