SpringCloudRPC核心原理：RxJava响应式编程框架，创建型操作符

创建型操作符

创建型操作符用于创建一个可观察对象Observable主题对象并弹出数据。RxJava的创建型操作符比较多，大致如下：

（1）create（）：使用函数从头创建一个Observable主题对象。

（2）defer（）：只有当订阅者订阅才创建Observable主题对象，为每个订阅创建一个新的Observable主题对象。

（3）range（）：创建一个弹射指定范围的整数序列的Observable主题对象。

（4）interval（）：创建一个按照给定的时间间隔弹射整数序列的Observable主题对象。

（5）timer（）：创建一个在给定的延时之后弹射单个数据的Observable主题对象。

（6）empty（）：创建一个什么都不做直接通知完成的Observable主题对象。

（7）error（）：创建一个什么都不做直接通知错误的Observable主题对象。

（8）never（）：创建一个不弹射任何数据的Observable主题对象。

接下来以just、from、range、interval、defer五个操作符为例进行介绍。

 just操作符

Observable的just操作符用于创建一个Observable主题，并且会将实参数据弹射出来。just操作符可接收多个实参，所有实参都将被逐一弹射。

just操作符的演示代码如下：

package com.crazymaker.demo.rxJava.basic;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import rx.Observable;
@Slf4j
public class CreaterOperatorDemo {
 /**
 *演示just的基本使用
 */
 @Test
 public void justDemo() {
 //发送一个字符串"hello world"
 Observable.just("hello world")
 .subscribe(s -> log.info("just string->" + s));
 //逐一发送1,2,3,4四个整数
 Observable.just(1, 2, 3, 4)
 .subscribe(i -> log.info("just int->" + i));
 }
}

运行之后的结果大致如下：

20:53:17.653 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->hello world
20:53:17.658 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->1
20:53:17.659 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->2
20:53:17.659 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->3
20:53:17.659 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->4

说明just操作符只是简单的原样弹射，如果实参是数组或者Iterable迭代器对象，数组或Iterable就会被当作单个数据弹射。

虽然just操作符可以弹射多个数据，但是上限为9个。

from操作符

from操作符以数组、Iterable迭代器等对象作为输入，创建一个Observable主题对象，然后将实参（如数组、Iterable迭代器等）中的数据元素逐一弹射出去。

from操作符的演示代码如下：

...
@Slf4j
public class CreaterOperatorDemo {
 /***演示 from的基本使用 */
 @Test
 public void fromDemo() {
 //逐一发送一个数组中的每一个元素
 String[] items = {"a", "b", "c", "d", "e", "f"};
 Observable.from(items)
.subscribe(s -> log.info("just string->" + s));
 //逐一发送迭代器中的每一个元素
 Integer[] array = {1, 2, 3, 4};
 List<Integer> list = Arrays.asList(array);
 Observable.from(list)
.subscribe(i -> log.info("just int->" + i));
}
...
}

运行上述演示代码，结果如下：

21:10:18.537 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->a
21:10:18.540 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->b
21:10:18.540 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->c
21:10:18.540 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->d
21:10:18.540 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->e
21:10:18.541 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just string->f
21:10:18.543 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->1
21:10:18.544 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->2
21:10:18.544 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->3
21:10:18.545 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->4

从以上输出可以看出，from()操作将传入的数组或Iterable拆分成单个元素依次弹射出去。

 range操作符

range操作符以一组整数范围作为输入，创建一个Observable主题对象并弹射该整数范围内包含的所有整数。

range操作符的演示代码如下：

package com.crazymaker.demo.rxJava.basic;
...
@Slf4j
public class CreaterOperatorDemo {
 /**演示 range的基本使用 */
 @Test
 public void rangeDemo() {
 //逐一发一组范围内的整数序列
 Observable.range(1, 10)
 .subscribe(i -> log.info("just int->" + i));
 }
}

运行上述演示代码，输出的结果如下：

21:24:50.507 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->1
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->2
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->3
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->4
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->5
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->6
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->7
21:24:50.513 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->8
21:24:50.514 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->9
21:24:50.514 [main] INFO c.c.d.r.b.CreaterOperatorDemo - just int->10

Observable.range（1，10）表示弹射在区间[1，10]范围内的数据，其范围包含区间的上限和下限。

 interval操作符

interval操作符创建一个Observable主题对象（消息流），该消息流会按照固定时间间隔发射整数序列。interval操作符的演示代码如下：

package com.crazymaker.demo.rxJava.basic;
...
@Slf4j
public class OtherOperatorDemo
{
 /**
 *演示interval转换
 */
 @Test
 public void intervalDemo() throws InterruptedException
 {
 Observable
 .interval(100, TimeUnit.MILLISECONDS)
 .subscribe(aLong -> log.info(aLong.toString()));
 Thread.sleep(Integer.MAX_VALUE);
 }
...
}

演示代码中的interval操作符的弹射间隔时间为100毫秒。运行这个演示程序，输出的结果如下：

[RxComputationScheduler-1] INFO c.c.d.r.b.OtherOperatorDemo - 0
[RxComputationScheduler-1] INFO c.c.d.r.b.OtherOperatorDemo - 1
[RxComputationScheduler-1] INFO c.c.d.r.b.OtherOperatorDemo - 2
[RxComputationScheduler-1] INFO c.c.d.r.b.OtherOperatorDemo - 3
[RxComputationScheduler-1] INFO c.c.d.r.b.OtherOperatorDemo - 4
...

defer操作符

just、from、range以及其他创建操作符都是在创建主题时弹射数据，而不是在被订阅时弹射数据。而defer操作符在创建主题时并不弹射数据，它会一直等待，直到有观察者订阅才会弹射数据。

defer操作符的演示代码如下：

package com.crazymaker.demo.rxJava.defer;
...
@Slf4j
public class SimpleDeferDemo
{
 /**
 *演示defer延迟创建操作符
 */
 @Test
 public void deferDemo()
 {
 AtomicInteger foo = new AtomicInteger(100);
 Observable observable = Observable.just(foo.get());
 /**
 *延迟创建
 */
 Observable dObservable = Observable.defer(
() -> Observable.just(foo.get()));
 /**
 *修改对象的值
 */
 foo.set(200);
 /**
 *有观察者订阅
 */
 observable.subscribe(
integer -> log.info("just emit {}", String.valueOf(integer)));
 /**
 *有观察者订阅
 */
 dObservable.subscribe(
integer -> log.info("defer just emit {}", String.valueOf(integer)));
 }
}

运行这个演示程序，输出的结果如下：

[main] INFO c.c.d.r.defer.SimpleDeferDemo - just emit 100
[main] INFO c.c.d.r.defer.SimpleDeferDemo - defer just emit 200

实质上，通过defer创建的主题，在观察者订阅时会创建一个新的Observable主题。因此，尽管每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是独立的消息序列。