Datenübertragung zwischen Anfragen mit Retrofit + RxJava

Question

Ich entschied mich, Retrofit 2.0 + RxJava in meinem Projekt zu verwenden. Das Hauptproblem ist, dass ich nicht vollständig verstehe, wie es sein sollte.

Zuerst alle Anfragen an meine Server-API, und jede Anfrage muss accessToken haben.

Zum Beispiel möchte ich alle Bücher bekommen mit meinem API:

1.Send Anfrage AccessToken Anfrage

2.Get Antwort mit AccessToken Wert

3.Insert diesen Wert zu erhalten

getBookRequest

4.Send getBookRequest und dann die Antwort mit JSONArray der Bücher erhalten

Frage ist, wie soll ich das machen?

Jetzt habe ich nur Verfahren mit accessTokenValue bekommen:

public void accessToken() { 
    ApiMethods methods = ApiFactory.connect(); 
    methods.getAccess(MAIN_URL + ACCESS_URL) 
      .timeout(15, TimeUnit.SECONDS) 
      .retry(3) 
      .subscribeOn(Schedulers.newThread()) 
      .map(new Func1<List<GetAccess>, AccessToken>() { 
       @NonNull 
       @Override 
       public AccessToken call(List<GetAccess> getAccesses) { 
        double xA = (double) getAccesses.get(0).A; 
        double xB = (double) getAccesses.get(0).B; 
        double xC = (double) getAccesses.get(0).C; 
        passDouble = //...SOME MANIPULATING WITH VALUES...// 
        id = getAccesses.get(0).ID; 
        AccessToken token = new AccessToken(); 
        token.setId(String.valueOf(id)); 
        token.setToken(String.valueOf(passDouble)); 
        token.setIsCompleted(true); 


        return token; 
       } 
      }) 
      .onErrorReturn(new Func1<Throwable, AccessToken>() { 
       @Override 
       public AccessToken call(Throwable throwable) { 
        return new AccessToken(String.valueOf(id), String.valueOf(passDouble), false); 
       } 
      }) 
      .observeOn(AndroidSchedulers.mainThread()) 
      .subscribe(new Action1<AccessToken>() { 
       @Override 
       public void call(AccessToken accessToken) { 
        //EventBus.getDefault().post(accessToken); 
       } 
      }); 
} 

Sollte ich Observable.zip oder etwas anderes? Was ist der bessere Weg, um eine zweite Anfrage an meinen Server mit Werten aus der ersten Anfrage zu implementieren?

Answer 1

Die Lösung für Ihr Problem ist es, 2 verschiedene Observablen zu ketten: Holen Sie sich das Access Token -> dann bekommen Sie die Liste der Bücher.

Ich würde vorschlagen, Ihre accessToken aussehen wie diese machen:

public Observable<AccessToken> accesstoken() { 
    ApiMethods methods = ApiFactory.connect(); 
    return methods.getAccess(MAIN_URL + ACCESS_URL) 
      .timeout(15, TimeUnit.SECONDS) 
      .retry(3) 
      .subscribeOn(Schedulers.newThread()) 
      .map(new Func1<List<GetAccess>, AccessToken>() { 
       @NonNull 
       @Override 
       public AccessToken call(List<GetAccess> getAccesses) { 
        double xA = (double) getAccesses.get(0).A; 
        double xB = (double) getAccesses.get(0).B; 
        double xC = (double) getAccesses.get(0).C; 
        passDouble = //...SOME MANIPULATING WITH VALUES...// 
          id = getAccesses.get(0).ID; 
        AccessToken token = new AccessToken(); 
        token.setId(String.valueOf(id)); 
        token.setToken(String.valueOf(passDouble)); 
        token.setIsCompleted(true); 


        return token; 
       } 
      }) 
      .onErrorReturn(new Func1<Throwable, AccessToken>() { 
       @Override 
       public AccessToken call(Throwable throwable) { 
        return new AccessToken(String.valueOf(id), String.valueOf(passDouble), false); 
       } 
      }); 
} 

Dann Sie es wie folgt verwenden können:

accessToken() 
     .flatMap(new Func1<AccessToken, Observable<List<Book>>>() { 
      @Override 
      public Observable<?> call(AccessToken accessToken) { 
       ApiMethods methods = ApiFactory.connect(); 
       return methods.getBookRequest(accessToken); 
      } 
     }) 
     .observeOn(AndroidSchedulers.mainThread()) 
     .subscribe(new Action1<List<Book>>() { 
      @Override 
      public void call(List<Book> books) { 
       // handle your list of books 
      } 
     }); 

Der Schlüssel hier ist die flatMap Operator, der Ketten, diese beiden Observablen.