RXJava2: richtige pattern-chain-retrofit-Anforderungen

Ich bin relativ neu in RXJava im Allgemeinen (eigentlich nur begann, es zu benutzen mit RXJava2), und die meisten Unterlagen, die ich finden kann, neigt dazu, RXJava1; ich kann in der Regel übersetzen zwischen den beiden jetzt, aber der gesamte Reaktive Zeug ist so groß, dass es eine überwältigende API mit guter Dokumentation (wenn Sie es finden können). Ich bin versucht zu rationalisieren mein code, ich möchte es mit kleinen Schritten. Das erste problem, das ich lösen will, ist dieses gemeinsame Muster, das ich eine Menge in meinem aktuellen Projekt:

Haben Sie eine Anforderung, die, wenn Sie erfolgreich ist, verwenden Sie eine zweite Anfrage.

Entweder, wenn Sie fehlschlägt, müssen Sie in der Lage sein zu erkennen das man versagt. (meist für die Anzeige von benutzerdefinierten UI-Warnungen).

Dies ist, wie ich in der Regel tun Sie es jetzt:

(weggelassen .subscribeOn/observeOn für Einfachheit)

Single<FirstResponse> first = retrofitService.getSomething();

first
   .subscribeWith(
     new DisposableSingleObserver<FirstResponse>() {
         @Override
         public void onSuccess(final FirstResponse firstResponse) {

               //If FirstResponse is OK…
                Single<SecondResponse> second = 
                 retrofitService
                    .getSecondResponse(firstResponse.id) //value from 1st
                    .subscribeWith(
                      new DisposableSingleObserver<SecondResponse>() {

                           @Override
                           public void onSuccess(final SecondResponse secondResponse) {
                              //we're done with both!
                           }

                           @Override
                            public void onError(final Throwable error) {
                            //2nd request Failed, 
                            }                        
                     });

         }

         @Override
         public void onError(final Throwable error) {
              //firstRequest Failed, 
         }
      });

Gibt es eine bessere Möglichkeit, damit umzugehen, in RXJava2?

Ich habe versucht flatMap - und Varianten-und sogar ein Single.zip oder ähnliches, aber ich bin mir nicht sicher, was die einfachste und verbreitetste Muster ist die Auseinandersetzung mit dieser.

Falls Sie sich Fragen, FirstRequest holt eine tatsächliche Token ich brauche in der SecondRequest. Kann nicht zweite Anforderung ohne den token.

InformationsquelleAutor Martin Marconcini | 2017-04-11
  1. 12

    Ich würde vorschlagen, mit flachen Karte (Und retrolambda, wenn das ist eine option).
    Auch brauchen Sie nicht zu halten die Rückgabewert (e.g Single<FirstResponse> first), wenn Sie nicht etwas zu tun mit es.

    retrofitService.getSomething()
    .flatMap(firstResponse -> retrofitService.getSecondResponse(firstResponse.id)
    .subscribeWith(new DisposableSingleObserver<SecondResponse>() {
         @Override
         public void onSuccess(final SecondResponse secondResponse) {
            //we're done with both!
         }

         @Override
          public void onError(final Throwable error) {
             //a request request Failed, 
          }                        
   });

    Diese Artikel hat mir geholfen, denken Sie über Stile, wie ich Struktur RxJava im Allgemeinen. Sie wollen Ihre Kette, um eine Liste der high-level-Aktionen, wenn möglich, es kann also gelesen werden als eine Sequenz von Aktionen/Transformationen.

    BEARBEITEN
    Ohne lambdas können Sie einfach eine Func1 für Ihre flatMap. Macht das gleiche nur viel mehr-boiler-plate-code. 

    retrofitService.getSomething()
    .flatMap(new Func1<FirstResponse, Observable<SecondResponse> {
        public void Observable<SecondResponse> call(FirstResponse firstResponse) {
            return retrofitService.getSecondResponse(firstResponse.id)
        }
    })
    .subscribeWith(new DisposableSingleObserver<SecondResponse>() {
         @Override
         public void onSuccess(final SecondResponse secondResponse) {
            //we're done with both!
         }

         @Override
          public void onError(final Throwable error) {
             //a request request Failed, 
          }                        
   });
    • Danke für die Antwort, das ist es, was ich im Sinn hatte (leider habe ich nicht Retrolambda in diesem Projekt) würden Sie mir helfen, mich zu entwirren, die lambda-Vereinfachung?
    • Ich fügte hinzu, ein Beispiel ohne lambda.
    • Vielen Dank für die Probe, ich habe es funktioniert. Nur für das Protokoll, dies ist RXJava2, so Func1 ist Function.
    InformationsquelleAutor cyroxis
  2. 3

    Tut dies nicht für Sie arbeiten?

    retrofitService
.getSomething()
.flatMap(firstResponse -> retrofitService.getSecondResponse(firstResponse.id))
.doOnNext(secondResponse -> {/* both requests succeeded */})
/* do more stuff with the response, or just subscribe */
    • Kann es tun, aber wo sollte ich fangen ein Fehler mit firstResponse? (Auch, ich kann ' s retrolambda in diesem Projekt, leider).
    • Was würden Sie tun, mit der Fehlermeldung, sobald Sie es erwischt?
    • Insbesondere informieren die UI (die firstResponse ist ein token, Versagen, um es zu erhalten, erfordert die Benutzeroberfläche, um anders zu reagieren). Der Veranstalter verantwortlich für diese Daten-Interaktion) benötigen, um verschiedene Dinge tun, wenn das token fehlgeschlagen. Der 2. Anruf ist verwenden Sie das token, und, wieder, die am Ende in einer anderen UI-state. Macht es Sinn?
    • Sicher; ich würde es tun, über .onErrorResumeNext(e -> {updateUIState(e); return Observable.empty();}). Oder sogar .doOnError(e -> updateUIState(e)), wenn Sie OK mit dem sammeln alle Fehler, die sich in Ihrer Abonnenten.
    • Vielen Dank dafür, das ich nicht akzeptieren kann, dass beide Antworten und ich landete mit den anderen, aber das ist sehr praktisch. Ich weiß es zu schätzen 🙂
    InformationsquelleAutor Tassos Bassoukos
Schreibe einen Kommentar