How to chain two Completable in RxJava2
TL;DR: the other answers miss a subtlety. Use doThingA().andThen(doThingB())
if you want the equivalent of concat
, use doThingA().andThen(Completable.defer(() -> doThingB())
if you want the equivalent of flatMap
.
EDIT: a more complete reference
flatMap()
is the mapping version ofmerge()
concatMap()
is the mapping version ofconcat()
- For a
Completable
you needdefer()
to make function calls lazy like in the mapping functions forSingle
orObservable
(or preferably make it so that nothing happens until you hit subscribe - this is a good convention to follow and is used in the official Rx libraries as well as any Rx extensions I've encountered, for advanced users this refers to cold completables only but most people can ignore that). - the only difference between
concat(a, b)
anda.andThen(b)
is syntax
Some examples:
foo(a).andThen(bar(b))
will:- call
foo(a)
- immediately call
bar(b)
even if the completable returned by step1
returns an error - subscribe to whatever step
1
returns - Will then subscribe to the result of
bar(b)
only if the last step completed successfully
- call
foo(a).andThen(Completable.defer(() -> bar(b))
will:- call
foo(a)
- subscribe to the result of step
1
- only if the completable returned by by
foo(a)
succeeds then callsbar(b)
- call
I'm going to leave out the treatment of merge()
since it gets a bit more complicated, but long story short that's the one to call if you want "parallelism".
The above answers are sort of correct, but I found them misleading because they miss a subtlety about eager evaluation.
doThingA().andThen(doThingB())
will call doThingB()
immediately but only subscribe to the observable returned by doThingB()
when the observable returned by doThingA()
completes.
doThingA().andThen(Completable.defer(() -> doThingB())
will call doThingB()
only after thing A has completed.
This is important only if doThingB()
has side effects before a subscribe event. E.g. Single.just(sideEffect(1)).toCompletable()
An implementation that doesn't have side effects before the subscribe event (a true cold observable) might be Single.just(1).doOnSuccess(i -> sideEffect(i)).toCompletable()
.
In the case that's just bitten me thing A is some validation logic and doThingB()
kicks off an asynchronous database update immediately that completes a VertX ObservableFuture. This is bad. Arguably doThingB()
should be written to only update the database upon subscribe, and I'm going to try and design things that way in the future.
You are looking for andThen
operator.
Returns a Completable that first runs this Completable and then the other completable.
firstCompletable
.andThen(secondCompletable)
In general, this operator is a "replacement" for a flatMap
on Completable
:
Completable andThen(CompletableSource next)
<T> Maybe<T> andThen(MaybeSource<T> next)
<T> Observable<T> andThen(ObservableSource<T> next)
<T> Flowable<T> andThen(Publisher<T> next)
<T> Single<T> andThen(SingleSource<T> next)
Try
Completable.concat
Returns a Completable which completes only when all sources complete, one after another.
http://reactivex.io/RxJava/javadoc/io/reactivex/Completable.html#concat(java.lang.Iterable)