web-dev-qa-db-fra.com

RxJava Single.just () vs Single.fromCallable ()?

Je me demandais si quelqu'un pouvait faire la lumière sur cette question, quand utiliser

Single.fromcallable(()-> myObject)

au lieu de

Single.Just(myObject)

à partir de documents 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.
 */

et documents pour 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>
 */
javaandroidrx-java2
13
bastami82

Dans le cas d'utilisation que vous avez mentionné, il n'y a en fait aucune différence majeure.

Et si nous avons besoin que l'objet soit créé dynamiquement via un appel de fonction?

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

Puis avec, Single.just(getTimeObject()) le Single résultant émettra le même Long quand il aura un nouvel abonné.

Cependant, avec Single.fromcallable(()-> getTimeObject()), le Single résultant émettra un Long différent indiquant l'heure actuelle en millisecondes lorsqu'il a un nouvel abonné.

C'est parce que fromCallable exécute son lambda chaque fois qu'il a un nouvel abonné Lazily.

14
Ahmed Ashraf Gamal

Habituellement, vous remarquerez la différence lorsque la chose que vous émettez n'est pas seulement un objet mais en fait le résultat de certains appels de méthode qui impliquent un calcul lourd, des E/S ou un état.

Single.just(x) évalue le x immédiatement dans le thread courant et vous vous retrouvez avec le résultat de x, pour tous les abonnés.

Single.fromCallable(y) appelle le y appelable dans le planificateur subscribeOn au moment de l'abonnement et séparément pour chaque abonné.

Ainsi, par exemple, si vous souhaitez décharger une opération d'E/S sur un thread d'arrière-plan, vous devez utiliser

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

Avoir Single.just() ici ne fonctionnerait pas puisque someIoOperation() serait exécuté sur le thread courant.

21
laalto

Vous devez utiliser fromCallable () lorsque vous avez une fonction comme

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

Ensuite, vous pouvez créer Single à partir de cette fonction comme ceci:

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

Single.just (myObject) émet simplement votre objet sans aucune logique.

Il n'est donc pas nécessaire d'utiliser fromCallable () lorsque vous souhaitez émettre un élément spécifique.

1
DenZap

Dans les documents, ils ont distingué deux fois Assemblez le temps et Runtime;

Temps d'assemblage La préparation des flux de données en appliquant divers opérateurs intermédiaires

Runtime Ceci est l'état où les flux émettent activement des éléments

Simplement Single.just () est évalué dans le Temps d'assemblage pas après la fin du processus principal

Single.defer () et Single.fromcallable () évalue l'objet Single dans Runtime

Veuillez vérifier les exemples de code des documents officiels ici

0
aya salama