In RxJava, come passare una variabile lungo quando si concatenano gli osservabili?

Question

sto concatenamento operazioni asincrone utilizzando RxJava, e mi piacerebbe passare un po 'variabile a valle:

Observable 
    .from(modifications) 
    .flatmap((data1) -> { return op1(data1); }) 
    ... 
    .flatmap((data2) -> { 
     // How to access data1 here ? 
     return op2(data2); 
    }) 

Sembra un modello comune, ma non sono riuscito a trovare informazioni su di esso.

Answer 1

Il consiglio che ho ricevuto dal forum Couchbase è quello di utilizzare osservabili nidificate:

Observable 
    .from(modifications) 
    .flatmap((data1) -> { 
     return op1(data1) 
      ... 
      .flatmap((data2) -> { 
       // I can access data1 here 
       return op2(data2); 
      }) 
    }); 

EDIT: Ho lo segnaliamo come la risposta accettata come sembra essere il più consigliato. Se l'elaborazione è troppo complessa per nidificare tutto, è anche possibile controllare la soluzione con le chiamate di funzione.

Answer 2

Una possibilità sarebbe quella di utilizzare una chiamata di funzione:

private static Observable<T> myFunc(final Object data1) { 
    return op1(data1) 
     ... 
     .flatmap((data2) -> { 
      // I can access data1 here 
      return op2(data2); 
     }); 
} 

Observable 
    .from(modifications) 
    .flatmap((data1) -> { return myFunc(data1); }) 

MA: correggetemi se sbaglio, ma non si sente come il modo reattivo-programmazione di farlo

Answer 3

altro possibilità è quella di mappare il risultato di op1 a un org.apache.commons.lang3.tuple.Pair che contiene la variabile e passare che lungo:

Observable 
    .from(modifications) 
    .flatmap((data1) -> { 
     return op1(data1).map(obj -> { return Pair.of(data1,obj); }); 
    }) 
    ... 
    .flatmap((dataPair) -> { 
     // data1 is dataPair.getLeft() 
     return op2(dataPair.getRight()); 
    }) 

funziona ma ci si sente un po 'uncomfortabl e per avere variabili nascoste all'interno di una coppia/triplo/... e diventa molto prolisso se si utilizza la notazione Java 6.

Mi chiedo se esiste una soluzione migliore, forse un operatore RxJava potrebbe essere d'aiuto?

Answer 4

soluzione su questo thread funziona, ma per catene complesse rende il codice difficile da leggere, ho dovuto passare più valori e quello che ho fatto è stato creare una classe privata con tutti i parametri, trovo il codice più leggibile in questo modo,

private class CommonData{ 
    private string data1; 
    private string data2; 

    *getters and setters* 
} 
... 
final CommonData data = new CommonData(); 
Observable 
    .from(modifications) 
    .flatmap((data1) -> { 
     data.setData1(data1); 
     return op1(data1); 
    }) 
    ... 
    .flatmap((data2) -> { 
     data2 = data.getData1() + "data 2... "; 
     data.setData2(data2); 
     return op2(data2); 
    }) 

speranza che aiuta