Le comportement de onNext et onComplete

J'ai une Observable qui fait quelque chose sans la nécessité d'émettre une valeur. Aussi, j'ai une liste d'objets, je veux que les Observables de travailler avec. Donc, pour tous les éléments dans cette liste: doSomething()

Observable.from(uris)
        .flatMap(new Func1<Uri, Observable<Void>>() {
            @Override
            public Observable<Void> call(Uri uri) {
                return createDoSomethingObservable(uri);
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeOn(Schedulers.io())
        .subscribe(new Observer<Void>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "completed");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Void aVoid) {
                Log.d(TAG, "next");
            }
        });

Et la méthode qui crée le Observables:

Observable<Void> createDoSomethingObservable(final Uri uri) {
    return Observable.create(new Observable.OnSubscribe<Void>() {
        @Override
        public void call(Subscriber<? super Void> subscriber) {
            //doSomething
            subscriber.onNext(null);
            subscriber.onCompleted();
        }
    });
}

Maintenant quand je lance ce une Liste avec les 3 éléments-je obtenir:

next
next
next
completed

qui est bon, parce que c'est ce que je voulais, mais je ne sais pas pourquoi ça fonctionne. J'ai d'abord commencé à l'appeler juste onComplete, parce que dans la fin de l'observable fait son travail et se termine. Mais bien sûr onNext n'est jamais appelée sur l'abonné. Il en va de même pour l'inverse.

Donc mes questions sont:

  1. Pourquoi est onComplete que le dernier élément de la liste?
  2. Est-il une meilleure façon de résoudre ce problème?

OriginalL'auteur Kuno | 2015-07-23

  1. 7

    onComplete est appelé pour le dernier élément parce que c'est quand les premiers à observer dans la chaîne (from(uris)) a fini.

    Il est prévu que votre observables émis à partir de flatMap appellera onComplete. Une fois que c'est fait (et call a retourné), alors la prochaine émission de from peut être travaillé sur. Une fois from a fini émettant des observables, il appelle onComplete et la chaîne est fini, effectivement.

    OriginalL'auteur Adam S

  2. 5

    Je pense, que petit code vous aide à comprendre le comportement de onNext( ) et onComplete().

    Imaginons que vous ayez un List<Uri>. Nous allons le transformer en Observable<Uri> manuellement.

    public static Observable<Uri> getUries(List<Uri> uriList){
    return Observable.create(new Observable.OnSubscribe<Uri>() {
        @Override
        public void call(Subscriber<? super Uri> subscriber) {
            for(Uri uri : uriList){
                subscriber.onNext(uri);
            }

            subscriber.onCompleted();
        }
    });
}

    Ou de l'utilisation des expressions Lambda:

    public static Observable<Uri> getUries(List<Uri> uriList){
    return Observable.create(subscriber -> {
        for(Uri uri : uriList){
            subscriber.onNext(uri);
        }

        subscriber.onCompleted();
    });
}

    Comme vous pouvez le voir, nous sommes une itération à l'entrée de la liste, et de les appeler onNext( ) pour chaque élément, et quand nous avons fini à la transformation de notre List à Observable, nous avons appelé onComplete()

    P. S.
    Ce code qu'une démonstration, s'il vous plaît, ne jamais l'utiliser à q List à Observable. L'utilisation de l'opérateur Observable.from().

    Mise à JOUR:

    Opérateur from( ) mise en œuvre:

    ...
while (true) {
    if (o.isUnsubscribed()) {
        return;
    } else if (it.hasNext()) {
        o.onNext(it.next());
    } else if (!o.isUnsubscribed()) {
        o.onCompleted();
        return;
    } else {
        //is unsubscribed
        return;
    }
}
...

    lien:https://github.com/ReactiveX/RxJava/blob/1.x/src/main/java/rx/internal/operators/OnSubscribeFromIterable.java#L75-L87

    OriginalL'auteur Alexander

  3. 1

    onComplete (le même que onError) est appelée une seule fois pendant observables de la chaîne, c'est la façon dont rxjava est mis en œuvre

    Je pense que votre approche est correcte, donc le meilleur moyen n'est pas nécessaire.

    OriginalL'auteur pjanecze