Utilizzo di RxJava + Retrofit per effettuare richieste API per ciascun elemento in un elenco

Question

Sto tentando di creare un osservabile concatenando più chiamate di retrofit api. I passi sono:

1. ottenere un elenco di oggetti JSON utilizzando API chiamata
2. Per ogni oggetto nella lista, effettuare un'altra chiamata API per ulteriori dettagli sulla voce
3. dati Scrittura tratto da questo nuovo dettagliata oggetto in un file sul disco (questo si verifica per ogni elemento della lista)
4. Infine restituire un osservabile di un oggetto separato che richiede che un file è stato creato per ciascuno degli oggetti precedenti

questo è ciò che Ho finora:

public static Observable<DownloadedFiles> downloadFiles() { 
    DownloadedFiles downloadedFiles = new DownloadedFiles(); 
    Observable.create(subscriber -> { 
     return getRestService().getObjectList() 
     .flatMapIterable(objects -> objects) 
     .flatMap(objectLimited -> getRestService().getObject(objectLimited.getPath())) 
     .doOnNext(objectFull -> { 

      try { 
       File file = new File(); 
       // Extract data from objectFull and write new file to disk 
       // ... 
       } catch (IOException e) { 
       subscriber.onError(e); 
      } 

      downloadedFiles.putFile(file); 
     }) 
     .toList() 
     .map(objects -> downloadedFiles) 
     .finallyDo(() -> { 
      subscriber.onNext(downloadedFiles); 
      subscriber.onCompleted(); 
     }); 
    }); 
} 

@GET("/api/...") 
Observable<List<Object>> getObjectList(); 

@GET("/api/.../{path}") 
Observable<Object> getObject(@Path("path") String path); 

Qualcuno potrebbe confermare che ho utilizzato gli operatori corretti. Grazie .

Answer 1

Modifica: rimosso il file Observable.create, il retrofit è già visibile per te, devi solo trasformarlo.

Modifica 2: non è inoltre necessario fare nulla con subscriber.onError, se viene generato un errore esso chiamerà subscriber.onError da solo.

Abbastanza buono, non sono sicuro del motivo per cui è stata osservata la mappa piatta. Vorrei invece fare una mappa piatta per Observable :: from, anche raccogliere vale la pena aggiungere. Fondamentalmente ho intenzione di mappare 1 cosa a molti, quindi fare un po 'di azione, raccogliere i molti in uno e poi iscrivermi a quello una volta che ho raccolto tutti gli oggetti emessi.

public static Observable<DownloadedFiles> downloadFiles() {   
     return getRestService().getObjectList() 
     .flatMap(Observable::from) 
     .flatMap(objectLimited -> getRestService().getObject(objectLimited.getPath())) 
     .doOnNext(objectFull -> { 
      try { 
       File file = new File(); 
       // Extract data from objectFull and write new file to disk 
       // ... 
      } catch (IOException e) { 
       new IOException(e); 
      }}) 
     .collect(() -> new DownloadFiles<>(), (files, object) -> { files.add(object}); 

Answer 2

Penso che alcuni come questo dovrebbero funzionare per voi. Invece di tirare in una riserva di emettere così il DownloadedFile (s) a, si può semplicemente utilizzare osservabile dal servizio REST per mappare a ciascuno dei DownloadedFiles:

public static Observable<DownloadedFile> downloadFiles() { 
    final Observable<Observable<FullObject>> observable = getRestService().getObjectList() 
      .flatMapIterable(objects -> objects) 
      .map(objectLimited -> getRestService().getObject(objectLimited.getPath())); 

    return Observable.mergeDelayError(observable) 
      .map(fullObject -> { 
       try { 
        File file = new File("path"); 
        // Extract data from objectFull and write new file to disk 
        // ... 

        return new DownloadedFile(); 
       } catch (IOException e) { 
        throw OnErrorThrowable.from(OnErrorThrowable.addValueAsLastCause(e, fullObject)); 
       } 
      }); 
} 

Si consiglia di considerare l'utilizzo di mergeDelayError (Mappa()) invece di flatMap se si desidera emettere file salvati correttamente prima di propagare eventuali errori.