RxJava: le chaînage des observables

Est-il possible de mettre en place quelque chose comme la prochaine chaîne via RxJava:

loginObservable()
   .then( (someData) -> {
      //returns another Observable<T> with some long operation
      return fetchUserDataObservable(someData);

   }).then( (userData) -> {
      //it should be called when fetching user data completed (with userData of type T)
      cacheUserData(userData);

   }).then( (userData) -> {
      //it should be called after all previous operations completed
      displayUserData()

   }).doOnError( (error) -> {
      //do something
   })

J'ai trouvé cette bibliothèque très intéressante, mais ne peuvent pas comprendre notre façon de la chaîne demande, où les uns des autres dépend de la précédente.

InformationsquelleAutor Mikhail | 2014-11-14

43

Sûr, RxJava prend en charge .map qui le fait. À partir de la RxJava Wiki:

Fondamentalement, ce serait:
```
loginObservable()
   .switchMap( someData -> fetchUserDataObservable(someData) )
   .map( userData -> cacheUserData(userData) )
   .subscribe(new Subscriber<YourResult>() {
        @Override
        public void onCompleted() {
           //observable stream has ended - no more logins possible
        }
        @Override
        public void onError(Throwable e) {
            //do something
        }
        @Override
        public void onNext(YourType yourType) {
            displayUserData();
        }
    });
```
- Comme je comprends la carte transforme une valeur à d'autres (par exemple, int -> String). Donc, même si je retourne Observables<T> à partir de la première carte, la deuxième carte sera appelé immédiatement avec userData de type Observables<T>, mais je veux qu'il soit appelé avec le type T lorsque fetchUserData complète
- Je pense que switchMap peut-être ce que vous voulez.
- Merci, semble switchMap ce que je veux. Je l'accepterais si vous mettez comme réponse
- désolé, mon mal - était afk et n'a pas lu le commentaire. switchMap est en effet ce qu'il vous faut si vous êtes à la consommation d'un observable.
- Aussi, "flatMap" vous donne la typique du comportement de chaînage, comparables à des Promesses enchaîné comme then.
- Puis-je utiliser la chaîne de multiples appels avec switchMap?
- Quelqu'un peut s'il vous plaît répondre à cette question: Plusieurs tâches dans un observables.
InformationsquelleAutor Benjamin Gruenbaum
8

C'est le poste le plus élevé lors de Googler RxJava de la chaîne d'observables donc je vais juste ajouter un autre cas courant où vous ne voulez pas transformer les données que vous recevez, mais une chaîne par une autre action (définition des données à une base de données, par exemple). Utilisation .flatmap(). Voici un exemple:
```
mDataManager
    .fetchQuotesFromApi(limit)
    .subscribeOn(mSchedulerProvider.io())
    .observeOn(mSchedulerProvider.ui())
    //OnErrorResumeNext and Observable.error() would propagate the error to
    //the next level. So, whatever error occurs here, would get passed to
    //onError() on the UI side.
    .onErrorResumeNext(Function { Observable.error<List<Quote>>(it) })
    .flatMap { t: List<Quote> ->
        //Chain observable as such
        mDataManager.setQuotesToDb(t).subscribe(
            {},
            { e { "setQuotesToDb() error occurred: ${it.localizedMessage}" } },
            { d { "Done server set" } }
        )
        Observable.just(t)
    }
    .subscribeBy(
        onNext = {},
        onError = { mvpView?.showError("No internet connection") },
        onComplete = { d { "onComplete(): done with fetching quotes from api" } }
    )
```
C'est RxKotlin2, mais l'idée est la même chose avec RxJava & RxJava2:

Explication rapide:
- nous essayons de récupérer certaines données (les citations dans cet exemple) à partir d'une api avec mDataManager.fetchQuotesFromApi()
- Nous vous abonner observables à faire des trucs sur .io() fil et de montrer les résultats sur .ui() fil.
- onErrorResumeNext() permet de s'assurer que, quelle que soit l'erreur de nous rencontrer à partir de l'extraction de données est pris dans cette méthode. Je veux mettre fin à l'ensemble de la chaîne quand il ya une erreur, alors je suis de retour d'un Observable.error()
- .flatmap() est le chaînage de la partie. Je veux être en mesure de définir toutes les données que je reçois de l'API à ma base de données. Je ne suis pas en transformant les données que j'ai reçu l'aide de .map(), je suis tout simplement faire autre chose avec les données sans le transformer.
- - Je m'abonner à la dernière chaîne de phénomènes observables. Si une erreur s'est produite avec de l'extraction de données (première observable), il serait géré (dans ce cas, propagées à l'abonné onError()) avec onErrorResumeNext()
- Je suis très consciente que je suis en vous abonnant à la base de données observables (à l'intérieur de flatmap()). Toute erreur qui se produit par le biais de cette observable sera PAS être propagées à la dernière subscribeBy() méthodes, car elle est gérée à l'intérieur de la subscribe() méthode à l'intérieur de la .flatmap() de la chaîne.
Le code provient de ce projet qui se trouve ici: https://github.com/Obaied/Sohan/blob/master/app/src/main/java/com/obaied/dingerquotes/ui/start/StartPresenter.kt
- Au lieu d'utiliser flatMap() et au retour d'une Observable.juste(t), vous pouvez utiliser une carte() et il suffit de retourner t. Sachez que les deux versions ne pas attendre le résultat de mDataManager.setQuotesToDb() et le retourner avant son achèvement.
InformationsquelleAutor Solidak
0

essayez d'utiliser scan()
```
Flowable.fromArray(array).scan(...).subscribe(...)
```
InformationsquelleAutor lingfliu

Vous devez vous connecter pour publier un commentaire.

Explication rapide: