RxJava Async task Android

Je suis en train de mettre en œuvre une tâche asynchrone à l'aide de RxJava dans Android.
J'ai essayé le code suivant et ça ne fonctionne pas. Il s'exécute sur le thread de l'INTERFACE utilisateur. Je suis l'aide de la version suivante de RxAndroid 0.24.0.

try {
            Observable.just(someMethodWhichThrowsException())
                    .subscribeOn(Schedulers.newThread())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(s -> onMergeComplete());
        } catch (IOException e) {
            e.printStackTrace();
        }

Cependant, les œuvres suivantes de façon asynchrone pour moi.

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    someMethodWhichThrowsException();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                subscriber.onCompleted();
            }
        });
        observable.subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe();

Je suis en train d'essayer de comprendre les éléments suivants:
1. Quelle est la différence entre eux?
2. Quelles sont les bonnes pratiques lors de la création async tâches?

Merci d'avance.

OriginalL'auteur muneikh | 2015-04-16

  1. 20
    1. Quelle est la différence entre eux? 
    Observable.just(someMethodWhichThrowsException())
    .subscribeOn(Schedulers.newThread())

    C'est équivalente à la suivante:

    Object someResult = someMethodWhichThrowsException();
Observable.just(someResult)
    .subscribeOn(Schedulers.newThread())

    Comme vous pouvez le voir cela fait de l'appel de méthode synchrone d'abord, puis passe à Observable.just pour devenir un fait Observable.

    Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            ...
        }
    })
    .subscribeOn(Schedulers.newThread())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe();

    Cette méthode, cependant, va exécuter le code dans le call bloc sur abonnement. Vous avez dit que vous voulez vous inscrire sur un nouveau thread (subscribeOn(Schedulers.newThread())), de sorte que l'abonnement arrive sur un nouveau thread, et le code qui est exécuté sur l'abonnement (le call bloc) est exécuté sur ce thread. C'est un comportement similaire à l'appel de Observables.reporter.

    1. Quelles sont les bonnes pratiques lors de la création async tâches?

    Eh bien, c'est à vous et à votre comportement désiré. Parfois, vous voulez le code asynchrone à commencer à exécuter immédiatement (dans ce cas, vous pouvez mettre en cache en utilisant l'un des opérateurs dans ce but). Je serais certainement envisager d'utiliser la Async Utils bibliothèque pour cela.

    D'autres fois, vous aurez envie il ne s'exécuter que sur abonnement (qui est le comportement dans les exemples ici), si par exemple, il y a des effets secondaires, ou si vous n'avez pas de soins lorsqu'il est exécuté et vous voulez juste utiliser le haut-ins pour obtenir quelque chose sur le thread d'INTERFACE utilisateur. Dan Lew mentionne que Observable.defer est très pratique pour prendre de l'ancien code et de le faire sur le thread de l'INTERFACE utilisateur, lors d'une conversion à Rx.

    Merci... C'est vraiment utile.
    Pas de problème! Les autres réponses vous a donné une solution, mais n'a pas vraiment donner beaucoup d'explications. Je vous conseille d'aller avec le haut- defer plus de l'ajout de la bibliothèque, surtout que c'est pour Android - garder que APK de la taille vers le bas 🙂
    Merci, je n'avais pas réalisé qu'. Je pense que cela devrait être l'approche recommandée. 🙂
    Async Utils bibliothèque semble vraiment vieux, et pas mis à jour depuis près d'un an.
    C'est une petite bibliothèque et si c'est stable, il n'y a pas besoin de le mettre à jour, même si je comprends le sentiment. Ils sont actuellement en accepter les pull requests ce n'est définitivement pas mort!!! Tout ce que la bibliothèque n', vous pouvez construire vous-même, mais elle est surtout utile pour vous aider quand vous êtes débutant avec Rx.

    OriginalL'auteur Adam S

  2. 11

    Utiliser Asynchrone.start() de RxJava Async Utils de la bibliothèque. Ce qui fera appel à la fonction que vous fournissez sur un autre thread.

    Exemple:

    Observable<String> observable = Async.start(new Func0<String>() {
    @Override
    public String call() {
        try {
            return someMethodWhichThrowsException();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
});

    Comme vous le notez, vérifié les exceptions doivent être enveloppés dans des RuntimeExceptions.

    Voir aussi https://github.com/ReactiveX/RxJava/wiki/Async-Operators#start

    Merci... c'est vraiment utile. Ce serait génial, si vous avez des conseils sur la différence sur mon code d'origine?
    Je peux répondre. Observables.juste() permet de créer une observable à partir d'un résultat. Si vous écrivez des Observables.juste(myFunction()), myFunction() est exécutée et le résultat est transmis à la juste méthode (comme dans toute l'expression de Java). Donc ce n'est pas asynchrone à tous. D'autre part, lorsque vous appelez Asynchrone.start(), votre méthode de calcul n'est pas encore appelé. Il sera appelé plus tard dans un autre thread, lorsque Rx appellera la touche func.call() (où func est le paramètre fourni à Async.start()).
    Une note sur Async.start, il va immédiatement commencer le travail, avant même de s'abonner, ce qui parfois est exactement ce que vous voulez. Si vous voulez attendre jusqu'à vous abonner, utilisez Async.toAction(...).call() ou Observable.defer. Dans ce cas, defer serait en mesure de gérer l'exception nettoyant puisque vous pouvez return Observable.error(new MyException()); au lieu de la jeter là-dedans, bien que la levée d'une exception produirait le même résultat.
    RxJavaAsyncUtil fournit remplacer commencer signature qui obtient également un Scheduler qui est "un Planificateur de tâches pour l'exécution de la fonction". puis-je faire confiance que le détail?

    OriginalL'auteur clemp6r