I am new to reactive programming and confused about composing observables that have dependencies. Here is the scenario: There are two observables A, B. Observable A depends on a value emitted by B. (Therefore A needs to observe B). Is there a way to create an Observable C that composes A and B, and emits V? I am just looking for pointers in the RxJava documentation.
Asked
Active
Viewed 2,920 times
4 Answers
1
You question is a bit vague on how A depends on B so I'll try to give a several examples of how to combine observables.
Example - A cannot be created without B - Use map()
public class B {
public final int value;
public B(int value) {
this.value = value;
}
}
public class A {
public final B b;
public A(B b) {
this.b = b;
}
}
public Observable<B> createObservableB() {
return Observable.from(new B(0), new B(1), new B(2), new B(3));
}
public Observable<A> createObservableA() {
return createObservableB()
.map(new Func1<B, A>() {
@Override
public A call(B b) {
return new A(b);
}
});
}
Example - Each occurrence of B can create zero or more A - Use flatMap()
public class B {
public final int value;
public B(int value) {
this.value = value;
}
}
public class A {
public final int value;
public A(int value) {
this.value = value;
}
}
public Observable<B> createObservableB() {
return Observable.from(new B(0), new B(1), new B(2), new B(3));
}
public Observable<A> createObservableA() {
return createObservableB()
.flatMap(new Func1<B, Observable<? extends A>>() {
@Override
public Observable<? extends A> call(final B b) {
return Observable.create(new Observable.OnSubscribe<A>() {
@Override
public void call(Subscriber<? super A> subscriber) {
for (int i = 0; i < b.value; i++) {
subscriber.onNext(new A(i));
}
subscriber.onCompleted();
}
});
}
});
}
I'm not exactly sure what you are asking with Observables C and V so let's look at a few more ways to combine observables.
Example - Combine each pair of items emitted by two observables - Use zip()
public class A {
public final int value;
public A(int value) {
this.value = value;
}
}
public class B {
public final int value;
public B(int value) {
this.value = value;
}
}
public class C {
private final A a;
private final B b;
public C(A a, B b) {
this.a = a;
this.b = b;
}
}
public Observable<B> createObservableB() {
return Observable.from(new B(0), new B(1), new B(2), new B(3));
}
public Observable<A> createObservableA() {
return Observable.from(new A(0), new A(1), new A(2), new A(3));
}
public Observable<C> createObservableC() {
return Observable.zip(createObservableA(), createObservableB(),
new Func2<A, B, C>() {
@Override
public C call(A a, B b) {
return new C(a, b);
}
}
);
}
Example - Combine the last item of two Observables - Use combineLatest()
// Use the same class definitions from previous example.
public Observable<C> createObservableC1() {
return Observable.combineLatest(createObservableA(), createObservableB(),
new Func2<A, B, C>() {
@Override
public C call(A a, B b) {
return new C(a, b);
}
}
);
}
kjones
- 5,783
- 2
- 27
- 27
0
I am also new to reactive programming, and just put together some code that may be interesting for your case
A needs to observe B
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.annotations.Test;
import rx.Observable;
import rx.Subscriber;
import rx.functions.Func1;
import java.util.concurrent.atomic.AtomicBoolean;
import static org.testng.Assert.assertTrue;
public class Q22284380TestCase {
private static final Logger LOGGER = LoggerFactory.getLogger(
Q22284380TestCase.class);
private AtomicBoolean completed = new AtomicBoolean(false);
@Test
public void testName() throws Exception {
final Observable.OnSubscribe<Integer> onSubProduceTwoValues = new Observable.OnSubscribe<Integer>() {
@Override
public void call(final Subscriber<? super Integer> subscriber) {
final Thread thread = new Thread(new Runnable() {
public Integer i = 0;
@Override
public void run() {
final Integer max = 2;
while (i < max) {
subscriber.onNext(i);
i++;
}
subscriber.onCompleted();
}
});
thread.start();
}
};
final Observable<Integer> values = Observable.create(onSubProduceTwoValues);
final Observable<Integer> byTwoMultiplier = values
.flatMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer aValue) {
return doubleIt(aValue);
}
});
byTwoMultiplier.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer a) {
LOGGER.info("" + a);
}
@Override
public void onCompleted() {
completed.set(true);
}
@Override
public void onError(Throwable e) {
LOGGER.error(e.getMessage());
}
});
Thread.sleep(1000L);
assertTrue(completed.get());
}
private Observable<Integer> doubleIt(final Integer value) {
return Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(final Subscriber<? super Integer> subscriber) {
final Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
subscriber.onNext(value * 2);
subscriber.onCompleted();
} catch (Throwable e) {
subscriber.onError(e);
}
}
});
thread.start();
}
});
}
}
Having a producer of values, it just uses flatMap to apply a doubleIt function to the output. To do something different, you can maybe read zip if you want to have a V that is a combination of A and B.
mox601
- 422
- 2
- 7
- 23
0
I think it depends on the kind of composition between A and B that you need to do and also on how A depends on B.
Does C compose A and B pair after pair (A1 combined with B1, A2 combined with B2, etc.) - then zip would be the function you want. But, in that case I wonder if you could not just do that work when you transform B to A in the first place - after all I assume that you transform B to A element by element (in which case map would be the way to go).
If instead you want to create a new A for each value emitted by B (but want to combine all those As into one Observable), then flatMap is what you need.
If you really first need B to create A and then need it again to combine A and B, then you might want to cache B to save you the trouble of calculating everything again.
There are other functions that could be of interest here (like reduce or combineLatest). Maybe you could give some more details on what you want to do?
david.mihola
- 12,062
- 8
- 49
- 73
0
If you are looking for making async observables work I suggest have a quick look at this question RxJava Fetching Observables In Parallel.
Ben (author of RxJava) helped clarify my doubts on the topic.
Hope this helps
anand
