fromCallable和defer有什么区别？（涉及IT技术）

Question

fromCallable和defer有不同的实现。我听说defer可以帮助递归，但我无法编写任何显示它们之间差异的代码。

我尝试了无限数字实现：

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

但是当我订阅时仍然会遇到堆栈溢出异常

- piotrek

---

https://artemzin.com/blog/rxjava-defer-execution-of-function-via-fromcallable/ - Maksim Ostrovidov

fromCallable是一种比较方便的方法，用于将Observable.defer(() -> Observable.just(value))简化。 - Aaron He

Answer 1

fromCallable创建一个发出单个值然后完成的Observable。

defer推迟实际Observable的创建，直到它被订阅。因此，您可以基于订阅时的状态创建多值的Observable。例如：

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

使用 fromCallable 也可以实现相同的效果，如下所示：

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

附言：您的无限数字流代码会导致无限递归。可能需要尝试使用调度器来避免这种情况。

- Yaroslav Stavnichiy

---

为什么 defer 会发出多个值？ - Daksh Gargas

@Dennis 是因为作者写了这个。 - kemdo

Answer 2

我在考虑“Single”这个概念，相比于Observable而言，它较为简单，因为它只能包含一个值（即仅有一次发射）。同样适用于其他类型（Observable、Flowable和Completable）。

Single.fromCallable

Single.fromCallable实际上是从函数内部的值创建新的Single。这就是Aaron He所说的评论的原因：

fromCallable是一种对Observable.defer(() -> Observable.just(value))的方便方法

它执行了额外的步骤，通过使用“just”创建了一个Observable。如果你调用创建Single的函数时使用了“fromCallable”，你会得到一个嵌套的Single。

// 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从callable创建一个Single，因此得名。这个callable不必创建一个Single，它可以是任何东西。

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

- Ben Butterworth