RxJava: best practice for composing async web requests that have dependecies - callback

Question

First, please forgive my poor English... I'll try to make the question clear...
I have an object a initially, use a to request b, then use b to request c and d, the relationship between these objects can be simplified as:
|-> c
a -> b -|
|-> d
I wrote code like:
B objB;
C objC;
D objD;
Observable.just(a)
.doOnNext((b) -> objB = b)
.map((a) -> getB(a))
.map((b) -> getC(b))
.subscribe((c) -> {
objC = c;
Observable.just(objB)
.map((b) -> getD(b))
.subscribe((d) -> objD = d);
});
How can I improve this?
Update
Thanks all for your answers.
In fact, the actual situation is more complicated. The data flow just like:
|-> e
|-> c -|-> f
a -> b -|-> d
And all the objects (b,c,d,e,f) I would like to use. I changed my code to:
class Zip {
B b;
C c;
D d;
E e;
F f;
}
Observable<B> obB = Observable.fromCallable(this::getB).cache();
Observable<C> obC = obB.map(this::getC).cache();
Observable<D> obD = obB.map(this::getD);
Observable<E> obE = obC.map(this::getE);
Observable<F> obF = obC.map(this::getF);
obB
.zipWith(obC, (b, c) -> {
// side effects
Zip zip = new Zip();
zip.b = b;
zip.c = c;
return zip;
})
.zipWith(obD, (zip, d) -> {
// side effects
zip.d = d;
return zip;
})
.zipWith(obE, (zip, e) -> {
// side effects
zip.e = e;
return zip;
})
.zipWith(obF, (zip, f) -> {
// side effects
zip.f = f;
return zip;
})
.subscribe((zip) -> { // update UI... });
Is it the right way to do this?

Answer 1

Suppose you have Observable definitions of a, b, c, and d:
A a = ...
Observable<B> b(A x) {...}
Observable<C> c(B x) {...}
Observable<D> d(B x) {...}
b(a)
.flatMap(x ->
c(x).zipWith(d(x), (x,y) -> combine(x,y)))
.subscribe(subscriber);

Answer 2

I think you could use merge operator after get B
#Test
public void dependencies(){
Observable.just("a")
.map(this::getB)
.flatMap(c-> Observable.merge(getC(c), getD(c)))
.subscribe(System.out::println);
}
String getB(String val){
return val.concat("-b");
}
Observable<String> getC(String val){
return Observable.just(val.concat("-c"));
}
Observable<String> getD(String val){
return Observable.just(val.concat("-d"));
}
If you want to learn more about RxJava here you have some examples https://github.com/politrons/reactive

Answer 3

How about something like this? Personally for me code is cleaner and more maintainable. This https://medium.com/#p.tournaris/rxjava-one-observable-multiple-subscribers-7bf497646675#.3apipnkx4 article might be useful.
public class SomeData {
final Observable<String> observableA;
final Observable<String> observableB;
final Observable<String> observableC;
final Observable<String> observableD;
public final BehaviorSubject<Throwable> error = BehaviorSubject.create();
public SomeData() {
observableA = Observable.fromCallable( // E.G. SOME API CALL
() -> {
// throw new RuntimeException("Some Error");
return "A";
})
.onErrorResumeNext(new handleError())
.cache();
observableB = observableA // SOME DATA MANIPULATION
.flatMap((s) -> Observable.just(s + " B"))
.onErrorResumeNext(new handleError())
.cache();
observableC = observableB // FURTHER DATA PROCESSING
.flatMap((s) -> Observable.just(s + " C"))
.onErrorResumeNext(new handleError());
observableD = observableB // FURTHER DATA PROCESSING
.flatMap((s) -> Observable.just(s + " D"))
.onErrorResumeNext(new handleError());
}
public Observable<Throwable> getError() {
return error;
}
private class handleError implements Func1<Throwable, Observable<? extends String>> {
#Override
public Observable<? extends String> call(Throwable throwable) {
return Observable.just(throwable).map(throwable1 -> {
error.onNext(throwable1);
return "some error handling here";
});
}
}
}

Answer 4

I think you can achieve what you want with combination of flatMap and zip operators. Here is some code:
public static void test() {
A a = new A();
a.getB()
.flatMap(b -> Observable.zip(b.getC(), b.getD(), (c, d) -> c))
.flatMap(c -> Observable.zip(c.getE(), c.getF(), (e, f) -> f))
.subscribe();
}
public static class A {
public Observable<B> getB() {
return Observable.just(new B());
}
}
public static class B {
public Observable<C> getC() {
return Observable.just(new C());
}
public Observable<D> getD() {
return Observable.just(new D())
}
}
public static class C {
public Observable<E> getE() {
return Observable.just(new E());
}
public Observable<F> getF() {
return Observable.just(new F())
}
}
public static class D {
}
public static class E {
}
public static class F {
}