RxJava Single.just () против Single.fromCallable ()?

Question

Интересно, может ли кто-нибудь пролить свет на этот вопрос, когда использовать

Single.fromcallable(()-> myObject)

вместо *1004*

Single.Just(myObject)

---

из документов Single.formcallable

 /**
 * Returns a {@link Single} that invokes passed function and emits its result for each new SingleObserver that subscribes.
 * <p>
 * Allows you to defer execution of passed function until SingleObserver subscribes to the {@link Single}.
 * It makes passed function "lazy".
 * Result of the function invocation will be emitted by the {@link Single}.
 * <dl>
 *   <dt><b>Scheduler:</b></dt>
 *   <dd>{@code fromCallable} does not operate by default on a particular {@link Scheduler}.</dd>
 * </dl>
 *
 * @param callable
 *         function which execution should be deferred, it will be invoked when SingleObserver will subscribe to the {@link Single}.
 * @param <T>
 *         the type of the item emitted by the {@link Single}.
 * @return a {@link Single} whose {@link SingleObserver}s' subscriptions trigger an invocation of the given function.
 */

и документы для Single.just

 /**
 * Returns a {@code Single} that emits a specified item.
 * <p>
 * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/Single.just.png" alt="">
 * <p>
 * To convert any object into a {@code Single} that emits that object, pass that object into the
 * {@code just} method.
 * <dl>
 * <dt><b>Scheduler:</b></dt>
 * <dd>{@code just} does not operate by default on a particular {@link Scheduler}.</dd>
 * </dl>
 *
 * @param item
 *            the item to emit
 * @param <T>
 *            the type of that item
 * @return a {@code Single} that emits {@code item}
 * @see <a href="http://reactivex.io/documentation/operators/just.html">ReactiveX operators documentation: Just</a>
 */

Answer 1

В случае использования, который вы упомянули, на самом деле нет существенной разницы.

Что если нам нужно, чтобы объект создавался динамически с помощью вызова функции?

fun getTimeObject() {
    val timeInMillis = System.currentTimeMillis()
    return TimeObject(timeInMillis)
}

Тогдас помощью Single.just(getTimeObject()) результирующий Single будет излучать то же самое Long, когда у него будет новый подписчик.

Однако при Single.fromcallable(()-> getTimeObject()) результирующий Single будет излучать другой Long, указываятекущее время в миллис, когда у него есть новый подписчик.

Это потому, что fromCallable выполняет свою лямбду каждый раз, когда у него новый подписчик Lazily .

Answer 2

Обычно вы заметите разницу, когда излучаемая вами вещь - это не просто объект, а фактически результат некоторых вызовов методов, которые включают в себя либо тяжелые вычисления, ввод-вывод, либо состояние.

Single.just(x) немедленно оценивает x в текущем потоке, а затем вы получаете то, что было результатом x для всех подписчиков.

Single.fromCallable(y) вызываетy вызывается в планировщике subscribeOn во время подписки и отдельно для каждого подписчика.

---

Так, например, если вы хотите перенести операцию ввода-вывода в фоновый поток, выбудет использовать

Single.fromCallable(() -> someIoOperation()).
    subscribeOn(Schedulers.io()).
    observeOn(AndroidSchedulers.mainThread()).
    subscribe(value -> updateUi(value), error -> handleError(error));

Наличие Single.just() здесь не будет работать, поскольку someIoOperation() будет выполнено в текущем потоке.

Answer 3

Вы должны использовать fromCallable () , когда у вас есть такая функция, как

MyObject myFunction() {
    // some login here
    return new MyObject();
}

Затем вы можете создать Single из этой функции, например:

Single.fromCallable(() -> myFunction());

Single.just (myObject) просто испускает ваш объект без какой-либо логики.

Поэтому нет необходимости использовать fromCallable () , когда выхотите выдать конкретный предмет.