【0197】Rxjava

1.概念

【响应式编程】是一种面向数据流和变化传播的编程范式。其中包含3个关键词，解析如下：

【数据流】只能以事先规定好的顺序被读取一次的数据的一个序列。

在计算机中指的就是传递的数据，在现实生活中可以是任意对象组成的有顺序的队列，例如排队取票时一位位的取票。

【变化传播】类似观察者模式，变化了要通知被观察者。

例如在饭店吃饭，点的菜不同，导致后厨做的菜不同。类似于多米诺骨牌效应。将变化得到了传播。

【编程范式】计算机编程的基本风格或者典范模式，例如：常见的面向对象编程和面向过程编程。

举一个可以串起来的实例，工厂的流水线：不同的车间穿梭的被加工的物品类似于数据流，不同车间对物品具有不同的加工工序，不停地传播，类比于变化的传播。

一个加工成可能有多条生产线，每条生产线加工的物品不一样，不同的生产线类似于不同的编程范式。

【Rxjava】Rxjava库的地址：https://github.com/ReactiveX/RxJava，引用官方的描述：

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.

【asynchronous】Rxjava是基于异步的，具有回调属性的一个库。

【event-based】Rxjava是具有事件分发功能和消息消息传递功能。

2.Rxjava1中的元素及关系

RxJava1代码示例

 1  Subscription tSubscription = Observable.create(new Observable.OnSubscribe<String>() {
 2      @Override
 3      public void call(Subscriber<? super String> subscriber) {
 4          if (!subscriber.isUnsubscribed()) {
 5              subscriber.onNext("test");
 6              subscriber.onCompleted();
 7          }
 8      }
 9  }).subscribe(new Observer<String>() {
10      @Override
11      public void onCompleted() {
12          System.out.println("onCompleted");
13      }
14 
15      @Override
16      public void onError(Throwable e) {
17 
18      }
19 
20      @Override
21      public void onNext(String s) {
22          System.out.println("onNext:" + s);
23      }
24  });

具有5个元素：

【1】【Observable】被观察者，通过Observable创建onCreate一个可观察的序列，通过subscrible注册一个观察者

【2】【Observer】观察者，用于接收数据，作为Observable的subscribe方法的参数

【3】【Subscription】订阅，用于描述被观察者和观察者之间的关系，具有两个方法，用于取消订阅和或者当前的订阅的状态

【4】【OnSubscribe】当订阅动作产生时会触发此接口的调用，在Observable源码中是向订阅者发射数据

【5】【Subscriber】实现了Observer和Subscription，只有自己才能阻止自己

3.Rxjava2

3.1 背压问题的认识

背压问题是产生的背景是异步环境，由于发送数据的速度和处理数据的速度不一样而导致的问题。背压的策略是流速控制的解决策略。

可以使用生产者和消费者问题解释：产生过快，产能过剩，消费者产生压力。

3.2 Rxjava2示例及组成元素

Rxjava2将背压问题的处理进行了拆分，Observable完全不会处理背压问题，交给了Flowable处理，Flowable具有背压策略。

Rxjava2的示例：

 1  Observable.create(new ObservableOnSubscribe<String>() {
 2                     //ObservableEmitter是Rxjava2新增加的类
 3                     @Override
 4                     public void subscribe(ObservableEmitter<String> e) throws Exception {
 5                         if (!e.isDisposed()) {
 6                             e.onNext("1");
 7                             e.onNext("2");
 8                             e.onNext("3");
 9                             e.onNext("4");
10                             e.onNext("5");
11                             e.onNext("6");
12                             e.onNext("7");
13                             e.onNext("8");
14                             e.onNext("9");
15                             e.onNext("10");
16                             e.onComplete();
17                         }
18                     }
19                 }).subscribe(new Observer<String>() {
20                     //Rxjava2新增加的方法onSubscribe()
21                     @Override
22                     public void onSubscribe(Disposable d) {
23                         System.out.println("onSubscribe");
24                     }
25 
26                     @Override
27                     public void onNext(String value) {
28                         System.out.println("onNext:" + value);
29                     }
30 
31                     @Override
32                     public void onError(Throwable e) {
33 
34                     }
35 
36                     @Override
37                     public void onComplete() {
38                         System.out.println("onCompleted");
39                     }
40                 });
41 
42                 Flowable.create(new FlowableOnSubscribe<String>() {
43                     @Override
44                     public void subscribe(FlowableEmitter<String> e) throws Exception {
45                         if (!e.isCancelled()) {
46                             e.onNext("test");
47                             e.onComplete();
48                         }
49                     }
50                     //此处设置了背压策略：BackpressureStrategy.DROP
51                 }, BackpressureStrategy.DROP).subscribe(new Subscriber<String>() {
52                     //同样多了一个方法
53                     @Override
54                     public void onSubscribe(Subscription s) {
55                         s.request(Long.MAX_VALUE);  //需要做响应式的拉取
56                         System.out.println("onSubscribe");
57                     }
58 
59                     @Override
60                     public void onNext(String s) {
61                         System.out.println("onNext:" + s);
62                     }
63 
64                     @Override
65                     public void onError(Throwable t) {
66 
67                     }
68 
69                     @Override
70                     public void onComplete() {
71                         System.out.println("onCompleted");
72                     }
73                 });
74             }
75         });
76     }

具有5个元素：

【1】【Observable和Flowable】【2】【Observer和Subscriber】【3】【Disposable和Subscription】【4】【Observable的OnSubscribe和Flowable的OnSubscribe】【5】【Emitter】

3.3 无背压Rxjava2

无背压Rxjava2实质和Rxjava1区别甚微，只是封装了新的类

无背压Rxjava2的元素

【1】【Observable】不支持背压，被观察者，通过Observable创建onCreate一个可观察的序列，通过subscrible注册一个观察者

【2】【Observer】观察者，用于接收数据，作为Observable的subscribe方法的参数

【3】【Disposable】与Rxjava1中的Subscription的作用一致，用于取消订阅和或者当前的订阅的状态

【4】【Observable的OnSubscribe】当订阅动作产生时会触发此接口的调用，在Observable源码中是向订阅者发射数据

【5】【Emitter】发射数据的接口，与Observer的方法类似，本质是对Observer和Subscriber的包装

3.4 有背压Rxjava2

【1】【Flowable】支持背压，被观察者，通过Observable创建onCreate一个可观察的序列，通过subscrible注册一个观察者

【2】【Subscriber】是一个单独的接口，与Observer的方法类似，作为Flowable的subscribe方法的参数

【3】【Subscription】订阅，与RxJava1有所不同，支持背压，存在用于背压的request方法

【4】【FlowableOnSubscribe】当订阅动作产生时会触发此接口的调用，在Flowable源码中是向订阅者/观察者发射数据