从呼叫和延迟有什么区别？

java reactive-programming rx-java

2022-09-02 13:29:44

fromCallable并有不同的实现。我听到有人说这有助于递归，但我无法生成任何显示它们之间差异的代码。deferdefer

我尝试了无限数实现：

private Observable<Integer> numbers(int start) {
         return Observable.just(start)
                .concatWith(Observable.defer(() -> numbers(start + 1)));
    }

但我在订阅时仍然得到堆栈溢出异常

答案 1

fromCallable创建发出单个值然后完成的可观察性。

defer推迟实际可观察对象的创建，直到订阅为止。因此，您可以根据订阅时的状态创建多值可观察性。例如：

Observable<Integer> daysOfWeekLeft =
    Observable.defer(() -> 
        Observable.range(currentDayOfWeek(), 7 - currentDayOfWeek()));

基本上你可以像这样实现相同的目标：fromCallable

Observable<Integer> daysOfWeekLeft =
    Observable.fromCallable(() -> currentDayOfWeek())
        .flatMap(day -> Observable.range(day, 7 - day));

PS. 您的无限数字流的代码会导致无限递归。可能需要使用调度程序来避免这种情况。

答案 2

我正在研究它的术语，它比可观察的要简单，因为它只能有1个值。（即具有1个发射的可观测值）。以下内容也适用于其他类型（可观察、可流动、可完成）Single

`Single.fromCallable`

Single.fromCallable实际上，从它调用的函数内的值创建一个新的 Single。这就是为什么亚伦何说是评论：

fromCallable是Observable.defer（（） -> Observable.just（value））的一种方便方法。

它执行使用创建可观察量的额外步骤。如果调用已创建 Single 的函数，则将获得嵌套的 Single。.justfromCallable

// Not very useful to get a Single<Single<*>>
val fromCallable: Single<Single<String>> = Single.fromCallable {
    Single.just("Example")
}

// Better in these cases, where the function inside doesn't create a Single already:
 fun heavyFunction(): String { return "Heavy" }
val fromCallable2: Single<String> = Single.fromCallable {heavyFunction()}

`Single.defer`

Single.defer调用其中的函数，如果它返回 Single，则可以稍后使用该 Single。如果没有，它将无法编译。

val defer: Single<String> = Single.defer {
    Single.just("Example")
}

// This line won't compile:
Single.defer {heavyFunction()}

// You need to wrap it in a Single:
val defer2: Single<String> = Single.defer {Single.just(heavyFunction())}

因此，Single.fromCallable 从可调用创建一个 Single，因此得名。这个可调用的不必创建单个，它可以是任何东西。

Defer不会创建一个新的单曲，它只是调用它应该创建一个单身的身体。这就是为什么它的函数名称中没有的原因。from