RxJava基础使用

RxJava是什么

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.这是官方对于该库的描述，意思是RxJava是Java VM上一个灵活的，使用可观测序列组成的异步的、基于事件的库。 它的核心最主要在于它的“异步”， Observable（被观察者）与 Observer/Subscriber（观察者），Observable可发出一系列事件，事件执行完毕后回调被观察者，这里的事件可以有非常多种形式，例如：网络请求、文件操作、数据加载、循环、延时操作等等。

相关概念

同步/异步： 关注的是消息通信机制，同步是指 发出一个调用，在没有得到结果之前，该调用就不返回，但是一旦调用返回，就得到返回值了； 而异步是指 调用发出后，调用直接返回，但不会立刻得到调用的结果。而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用； 异步强调被动通知。

阻塞/非阻塞：关注的是程序在等待调用结果（消息，返回值）时的状态；阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。如java8 stream为阻塞式，Future为非阻塞式的； 非阻塞强调状态主动轮询。

并发(Concurrency)与并行(parallelism)： 并发是一个更通用的概念，两个并发线程被调度在一个单核处理上运行，这就是并发性，而非并行. 并行性更可能出现在多核，多CPU或分布式系统上。编写代码时一般不区分两者。

函数式编程Functional Programming)：函数式编程将程序描述为表达式和变换，以数学方程的形式建立模型，并尽量避免可变的状态。每个逻辑分类(filter,map，reduce等)都由不同函数所表示，这些实现底层次的变换，而用户定义的高阶函数作为参数来实现真正的业务。

函数响应式编程（Functional Reactive Programming)）：响应式编程是建立在观者者模式上的一种编程范式，对异步数据流进行编程，同时该事件流是按时间排序的序列（不同于java8中的stream）；虽然响应式编程框架不一定要求是函数式的，但是RxJava等响应式编程框架都是结合了函数式编程的。

背压（Backpressure）：背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略，简而言之，背压是流速控制的一种策略。

ReactiveX是什么

响应式扩展(Reactive Extensions, 简写为ReactiveX，Rx),最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源[1]；

ReactiveX = Observer Pattern + Iterator Pattern + Functional Programming。Rx 让开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序;

ReactiveX是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，ReactiveX的思想是跨平台的，学习其他语言的基本语法之后，可以做到 “learn once, write everywhere”;

Rx近几年越来越流行了，现在已经支持几乎全部的流行编程语言了，Rx的大部分语言库由ReactiveX这个组织负责维护，比较流行的有RxJava/RxJS/Rx.NET，社区网站是 reactivex.io。

RxJava 是 ReactiveX 规范的JVM平台实现

组织结构

RxJava核心由以下四个interface定义：

Publisher ： 消息发布者
Subscriber ： 消息订阅者
Subscription ： 一个订阅
Processor ： Publisher + Subscriber 的结合体

它有什么作用

1.使你的代码更加简洁，增强可读性
2.对事件的处理具有非常好的灵活性
3.非常方便的实现响应式编程
4.对线程与并发问题的处理变得简单
5.Flow Control（Backpressure、Throttling等）

基本使用

引入RxJava依赖，这里使用的2.x版本

repositories {
    maven { url 'https://oss.jfrog.org/libs-snapshot' }
}

dependencies {
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
}

最简单的开始

Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(@NonNull ObservableEmitter e) throws Exception {
                e.onNext("hello");
                e.onNext("rxjava");
                e.onNext("test");
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {
                System.out.println("MainActivity.onNext:" + s);
            }

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

            }

            @Override
            public void onComplete() {

            }
        });

Observable创建一个基于String类型的事件，然后被观察者调用subscribe方法订阅观察者。What？是不是搞反了。
ObservableEmitter为事件发射器，可调用onNext、onError、onComplete方法，Disposable用于解除订阅。
事件的执行内容是：依次输出“hello”，“rxjava”，“test”三个字符串。这里使用的方法链的方式，当然你也可以采用以下的方式

这里写图片描述

create方法是Observable的静态方法，用于构造一个Observable对象，如果说用于单纯的构造初始事件的话，除了create以外，还有许多方式可以构造观察者

interval & intervalRange & just & fromIterable & fromArray & timer

他们与create的差异主要在于，create创建的事件需要执行过程，而这些方法创建的事件显示是现成的，不需要额外操作，一旦与观察者关联后即可发送事件。

fromFuture & fromCallable 了解即可，Android中并不太适用

fromFuture, 事件从非主线程中产生； fromCallable, 事件从主线程中产生， 在需要消费时生产；

        ExecutorService executor = Executors.newFixedThreadPool(2);
        Callable callable = new Callable() {...};
        Future future = executor.submit(callable);
        Consumer onNext = new Consumer() {...};
        Flowable.fromCallable(callable).subscribe(onNext);
        Flowable.fromFuture(future).subscribe(onNext);

ObservableEmitter和Disposable

ObservableEmitter： ObservableEmitter可以理解为发射器，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

1．被观察者可以发送无限个onNext, 观察者也可以接收无限个onNext.
2．当Observable发送了一个onComplete后, Observable的onComplete之后的事件将会继续发送, 而Observer收到onComplete事件之后将不再继续接收事件.
3．当Observable发送了一个onError后, Observable中onError之后的事件将继续发送, 而Observer收到onError事件之后将不再继续接收事件.
4．Observable可以不发送onComplete或onError.
5．最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然。

Disposable 调用dispose()方法时, 它就会将观察者和被观察者的联系切断, 从而导致观察者收不到事件。但是并不能控制被观察者是否发射事件。

Observale & Flowable

当然我们也可以使用Flowable，而不用Observale

Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(@NonNull FlowableEmitter e) throws Exception {
                e.onNext("hello");
                e.onNext("rxjava");
                e.onNext("test");
            }
        }, BackpressureStrategy.BUFFER).subscribe();

Observable: 不支持背压
Flowable : Observable新的实现，支持背压，同时实现Reactive Streams 的 Publisher 接口

其他形式的被观察者

除了上述描述的两种观察者形式外，还有Single & Completable & Maybe

Single

可以发射一个单独onSuccess 或 onError消息。它现在按照Reactive-Streams规范被重新设计,并遵循协议 onSubscribe (onSuccess | onError)

Single.create(new SingleOnSubscribe