[关闭]
@cxm-2016 2016-12-01T22:10:03.000000Z 字数 10690 阅读 3625

RxJava学习指南(四)——创建操作符

RxJava学习指南

版本:5
整理:陈小默


五、创建操作符

5.1 Create

使用一个函数从头开始创建一个Observable

create

你可以使用Create操作符从头开始创建一个Observable。

其中的onComplete或onError只能被执行一个并且只能被执行一次。

create

RxJava将这个操作符实现为 create 方法。

建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态,以便在没有观察者的时候,让你的Observable停止发射数据或者做复杂的运算。

示例代码:

  1. Observable.create<Int> {
  2. with(it) {
  3. if (!isUnsubscribed) {
  4. try {
  5. for (i in 1 until 5) onNext(i)
  6. onCompleted()
  7. } catch (e: Exception) {
  8. onError(e)
  9. }
  10. }
  11. }
  12. }.subscribe(
  13. { println("Next: $it") },
  14. { println("Error: ${it.message}") },
  15. { println("Sequence complete") })

输出:

Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

create方法默认不在任何特定的调度器上执行。

5.2 Defer

直到有观察者订阅时才创建Observable,并且为每个观察者创建一个新的Observable

defer

Defer操作符会一直等待直到有观察者订阅它,然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做,因此尽管每个订阅者都以为自己订阅的是同一个Observable,事实上每个订阅者获取的是它们自己的单独的数据序列。

在某些情况下,等待直到最后一分钟(就是知道订阅发生时)才生成Observable可以确保Observable包含最新的数据。

defer

RxJava将这个操作符实现为 defer 方法。这个操作符接受一个你选择的Observable工厂函数作为单个参数。这个函数没有参数,返回一个Observable。

defer方法默认不在任何特定的调度器上执行。

示例程序:

  1. val key = "暴走"
  2. val defer = Observable.defer {
  3. Observable.create<List<News>> {
  4. with(it) {
  5. if (!isUnsubscribed) {
  6. try {
  7. onNext(query(key))
  8. onCompleted()
  9. } catch (e: Exception) {
  10. onError(e)
  11. }
  12. }
  13. }
  14. }
  15. }
  16. defer.subscribe(
  17. { println("List size: ${it.size}") },
  18. { println("Error: ${it.message}") },
  19. { println("Sequence complete") })

5.2.1 switchCase

switchCase

可选包 rxjava-computation-expressions 中有一个类似的操作符。switchCase操作符有条件的创建并返回一个可能的Observables集合中的一个。

  1. val statement = mapOf<Int, Observable<Int>>(
  2. 0 to Observable.from(arrayOf(1, 2, 3)),
  3. 1 to Observable.from(arrayOf(7, 8, 9)))
  4. Statement.switchCase({ param }, statement).subscribe(
  5. { println("Item: $it") },
  6. { println("Error: ${it.message}") },
  7. { println("Sequence complete") })

运行结果
param = 0时:

Item: 1
Item: 2
Item: 3
Sequence complete

param = 1时:

Item: 7
Item: 8
Item: 9
Sequence complete

ifThen

可选包 rxjava-computation-expressions 中还有一个更简单的操作符叫ifThen。这个操作符检查某个条件,然后根据结果,返回原始Observable的镜像,或者返回一个空Observable。

  1. Statement.ifThen({ param }, Observable.from(arrayOf(1, 2, 3)))
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

输出结果
param = true时

Item: 1
Item: 2
Item: 3
Sequence complete

param = false时

Sequence complete

5.3 Empty

创建一个不发射任何数据但是正常终止的Observable

示例程序

  1. Observable.empty<Int>().subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") }
  5. )

输出结果

equence complete

5.4 Never

创建一个不发射数据也不终止的Observable

示例程序

  1. Observable.never<Int>().subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") }
  5. )

该程序不会有任何输出

5.4 Throw

创建一个不发射数据以一个错误终止的Observable

示例代码

  1. Observable.error<Int>(RuntimeException()).subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") }
  5. )

5.5 From

将其它种类的对象和数据类型转换为Observable

from

当你使用Observable时,如果你要处理的数据都可以转换成展现为Observables,而不是需要混合使用Observables和其它类型的数据,会非常方便。这让你在数据流的整个生命周期中,可以使用一组统一的操作符来管理它们。

例如,Iterable可以看成是同步的Observable;Future,可以看成是总是只发射单个数据的Observable。通过显式地将那些数据转换为Observables,你可以像使用Observable一样与它们交互。

因此,大部分ReactiveX实现都提供了将语言特定的对象和数据结构转换为Observables的方法。

from

在RxJava中,from操作符可以转换Future、Iterable和数组。对于Iterable和数组,产生的Observable会发射Iterable或数组的每一项数据。

示例代码

  1. Observable.from(arrayOf(1, 2, 3)).subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") })

输出

Item: 1
Item: 2
Item: 3
Sequence complete

对于Future,它会发射Future.get()方法返回的单个数据。from方法有一个可接受两个可选参数的版本,分别指定超时时长和时间单位。如果过了指定的时长Future还没有返回一个值,这个Observable会发射错误通知并终止。

from默认不在任何特定的调度器上执行。然而你可以将Scheduler作为可选的第二个参数传递给Observable,它会在那个调度器上管理这个Future。

5.5.1 RxJavaAsyncUtil

from func)

此外,在可选包 RxJavaAsyncUtil 中,你还可以用下面这些操作符将actions,callables,functions和runnables转换为发射这些动作的执行结果的Observable:

在这个页面 Start 查看关于这些操作符的更多信息。

from

注意:还有一个可选的StringObservable类中也有一个from方法,它将一个字符流或者一个REader转换为一个发射字节数组或字符串的Observable。

5.5.2 runAsync2

注意:这里与后面start操作符里的runAsync说明重复了

在单独的RxJavaAsyncUtil包中(默认不包含在RxJava中),还有一个runAsync函数。传递一个Action和一个SchedulerrunAsync,它会返回一个StoppableObservable,这个Observable使用Action产生发射的数据项。

传递一个Action和一个SchedulerrunAsync,它返回一个使用这个Action产生数据的StoppableObservable。这个Action接受一个Observable和一个Subscription作为参数,它使用Subscription检查unsubscribed条件,一旦发现条件为真就立即停止发射数据。在任何时候你都可以使用unsubscribe方法手动停止一个StoppableObservable(这会同时取消订阅与这个StoppableObservable关联的Subscription)。

由于runAsync会立即调用Action并开始发射数据,在你创建StoppableObservable之后到你的观察者准备好接受数据之前这段时间里,可能会有一部分数据会丢失。如果这不符合你的要求,可以使用runAsync的一个变体,它也接受一个Subject参数,传递一个ReplaySubject给它,你可以获取其它丢失的数据了。

5.5.3 decode

decode

StringObservable类不是默认RxJava的一部分,包含一个decode操作符,这个操作符将一个多字节字符流转换为一个发射字节数组的Observable,这些字节数组按照字符的边界划分。

5.6 Interval

Interval操作符创建的Observable每隔固定时间发射一个从0起递增的Long型整数。

interval

interval

timer

以下重载增加了一个延时属性。

Javadoc: interval(long,long,TimeUnit)
Javadoc: interval(long,long,TimeUnit,Scheduler)

interval默认在computation调度器上执行

5.7 Just

创建一个发射指定值的Observable

just

与From不同,Just将每个数据都转换为一个只发射一个数据的Observable。

RxJava将这个操作符实现为just函数,它接受一至九个参数,返回一个按参数列表顺序发射这些数据的Observable。

示例代码:

  1. Observable.just(1, 2, 3).subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") })

输出

Item: 1
Item: 2
Item: 3
Sequence complete

5.8 Range

创建一个发射特定整数序列的Observable

range

创建一个Observable,这个Observable会从n开始发射递增的m个数据。如果m为负数,会抛出异常。

range默认不在任何特定的调度器上执行

示例代码:

  1. Observable.range(1,3).subscribe(
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") })

运行结果

Item: 1
Item: 2
Item: 3
Sequence complete

5.9 Repeat

创建一个发射特定数据重复多次的Observable

repeat

Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列,还有一些允许你限制重复的次数。

repeat

RxJava将这个操作符实现为repeat方法。它不是创建一个Observable,而是重复发射原始Observable的数据序列,这个序列或者是无限的,或者通过repeat(n)指定重复次数。

repeat操作符默认在trampoline调度器上执行。有一个变体可以通过可选参数指定Scheduler。

Javadoc: repeat()
Javadoc: repeat(long)

示例代码:

  1. Observable.from(arrayOf(1, 2, 3)).repeat(2)
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

结果

Item: 1
Item: 2
Item: 3
Item: 1
Item: 2
Item: 3
Sequence complete

Javadoc: repeat(Scheduler)
Javadoc: repeat(long,Scheduler)

5.9.1 repeatWhen

repeatWhen

还有一个叫做repeatWhen的操作符,它不是缓存和重放原始Observable的数据序列,而是有条件的重新订阅和发射原来的Observable。

将原始Observable的终止通知(完成或错误)当做一个void数据传递给一个通知处理器,它以此来决定是否要重新订阅和发射原来的Observable。这个通知处理器就像一个Observable操作符,接受一个发射void通知的Observable为输入,返回一个发射void数据(意思是,重新订阅和发射原始Observable)或者直接终止(意思是,使用repeatWhen终止发射数据)的Observable。

repeatWhen操作符默认在trampoline调度器上执行。有一个变体可以通过可选参数指定Scheduler。

5.9.2 doWhile

doWhile

doWhile 属于可选包rxjava-computation-expressions,不是RxJava标准操作符的一部分。doWhile在原始序列的每次重复后检查某个条件,如果满足条件才重复发射。

  1. Statement.doWhile(Observable.just(1, 2, 3), { param })
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

先循环后判断param

5.9.3 whileDo

whileDo

whileDo 属于可选包rxjava-computation-expressions,不是RxJava标准操作符的一部分。whileDo在原始序列的每次重复前检查某个条件,如果满足条件才重复发射。

  1. Statement.whileDo(Observable.just(1, 2, 3), { param })
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

先判断param再循环

5.10 Start

返回一个Observable,它发射一个类似于函数声明的值

Start

编程语言有很多种方法可以从运算结果中获取值,它们的名字一般叫functions, futures, actions, callables, runnables等等。在Start目录下的这组操作符可以让它们表现得像Observable,因此它们可以在Observables调用链中与其它Observable搭配使用。

Start操作符的多种RxJava实现都属于可选的rxjava-async模块。

rxjava-async模块包含start操作符,它接受一个函数作为参数,调用这个函数获取一个值,然后返回一个会发射这个值给后续观察者的Observable。

注意:这个函数只会被执行一次,即使多个观察者订阅这个返回的Observable。

  1. fun func(x: Int, y: Int) = x + y
  2. Async.start { func(a, b) }
  3. .subscribe(
  4. { println("Item: $it") },
  5. { println("Error: ${it.message}") },
  6. { println("Sequence complete") })

当a=1,b=2时,返回结果如下

Item: 3
Sequence complete

5.10.1 toAsync

toAsync

rxjava-async模块还包含这几个操作符:toAsync, asyncAction, 和asyncFunc。它们接受一个函数或一个Action作为参数。

对于函数(functions),这个操作符调用这个函数获取一个值,然后返回一个会发射这个值给后续观察者的Observable(和start一样)。对于动作(Action),过程类似,但是没有返回值,在这种情况下,这个操作符在终止前会发射一个null值。

注意:这个函数或动作只会被执行一次,即使多个观察者订阅这个返回的Observable。

5.10.2 startFuture

startFuture

rxjava-async模块还包含一个startFuture操作符,传递给它一个返回Future的函数,startFuture会立即调用这个函数获取Future对象,然后调用Futureget()方法尝试获取它的值。它返回一个发射这个值给后续观察者的Observable。

  1. val future : Future<Int>
  2. Async.startFuture { future }.subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

5.10.3 deferFuture

deferFuture

rxjava-async模块还包含一个deferFuture操作符,传递给它一个返回Future的函数(这个Future返回一个Observable),deferFuture返回一个Observable,但是不会调用你提供的函数,直到有观察者订阅它返回的Observable。这时,它立即调用Futureget()方法,然后镜像发射get()方法返回的Observable发射的数据。

用这种方法,你可以在Observables调用链中包含一个返回Observable的Future对象。

  1. val future : Future<Observable<Int>>
  2. Async.deferFuture { future }.subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

5.10.4 fromAction

fromAction

rxjava-async模块还包含一个fromAction操作符,它接受一个Action作为参数,返回一个Observable,一旦Action终止,它发射这个你传递给fromAction的数据。

  1. Async.fromAction({
  2. println("action")
  3. }, 1)
  4. .subscribe(
  5. { println("Item: $it") },
  6. { println("Error: ${it.message}") },
  7. { println("Sequence complete") })

5.10.5 fromCallable

fromCallable

rxjava-async模块还包含一个fromCallable操作符,它接受一个Callable作为参数,返回一个发射这个Callable的结果的Observable。

  1. Async.fromCallable { 1 }
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })

5.10.6 fromRunnable

fromRunnable

rxjava-async模块还包含一个fromRunnable操作符,它接受一个Runnable作为参数,返回一个Observable,一旦Runnable终止,它发射这个你传递给fromRunnable的数据。

  1. Async.fromRunnable({
  2. for (i in 0 until 10) println(i)
  3. }, 1)
  4. .subscribe(
  5. { println("Item: $it") },
  6. { println("Error: ${it.message}") },
  7. { println("Sequence complete") })

上述程序会在循环结束后发射数据

5.10.7 forEachFuture

forEachFuture

rxjava-async模块还包含一个forEachFuture操作符。它其实不算Start操作符的一个变体,而是有一些自己的特点。你传递一些典型的观察者方法(如onNext, onError和onCompleted)给它,Observable会以通常的方式调用它。但是forEachFuture自己返回一个Future并且在get()方法处阻塞,直到原始Observable执行完成,然后它返回,完成还是错误依赖于原始Observable是完成还是错误。

如果你想要一个函数阻塞直到Observable执行完成,可以使用这个操作符。

  1. Async.forEachFuture(Observable.just(1,2,3),
  2. { println("Item: $it") },
  3. { println("Error: ${it.message}") },
  4. { println("Sequence complete") })

5.10.8 runAsync

rxjava-async模块还包含一个runAsync操作符。它很特殊,返回一个叫做StoppableObservable的特殊Observable。

传递一个Action和一个SchedulerrunAsync,它返回一个使用这个Action产生数据的StoppableObservable。这个Action接受一个Observable和一个Subscription作为参数,它使用Subscription检查unsubscribed条件,一旦发现条件为真就立即停止发射数据。在任何时候你都可以使用unsubscribe方法手动停止一个StoppableObservable(这会同时取消订阅与这个StoppableObservable关联的Subscription)。

由于runAsync会立即调用Action并开始发射数据,在你创建StoppableObservable之后到你的观察者准备好接受数据之前这段时间里,可能会有一部分数据会丢失。如果这不符合你的要求,可以使用runAsync的一个变体,它也接受一个Subject参数,传递一个ReplaySubject给它,你可以获取其它丢失的数据了。

在RxJava中还有一个版本的From操作符可以将Future转换为Observable,与start相似。

5.11 Timer

创建一个Observable,它在一个给定的延迟后发射一个0。

timer

timer返回一个Observable,它在延迟一段给定的时间后发射一个简单的数字0。

timer操作符默认在computation调度器上执行。有一个变体可以通过可选参数指定Scheduler。

  1. Observable.timer(1000L, TimeUnit.MILLISECONDS, Schedulers.immediate())
  2. .subscribe(
  3. { println("Item: $it") },
  4. { println("Error: ${it.message}") },
  5. { println("Sequence complete") })
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注