创建型操作符

创建型操作符用于创建一个可观察对象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 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，事实上每个订阅者获取的是独立的消息序列。

本文给大家讲解的内容是SpringCloudRPC远程调用核心原理：RxJava响应式编程框架，创建型操作符

下篇文章给大家讲解的是SpringCloudRPC远程调用核心原理：RxJava响应式编程框架，过滤型操作符；
觉得文章不错的朋友可以转发此文关注小编；
感谢大家的支持！

在腾讯课堂每晚八点都有公开课的您也可以看看要是有感兴趣的您再联系我我再给您找对应的资料

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