Completable # andThen() 源码:
先订阅Completable,
再订阅 ObservableSource 、 Publisher 、 SingleSource 、 MaybeSource 、 CompletableSource ,
并返回新的Observable、Flowable、Single、Maybe、Completable
来自此Completable的【错误事件】将传播到下游订阅者,
并且将导致跳过 ObservableSource 、 Publisher 、 SingleSource 、 MaybeSource 、 CompletableSource 的订阅。
/**
* 返回一个Observable,它将订阅此Completable,一旦完成,则将订阅{@code next}ObservableSource。
* 来自此Completable的错误事件将传播到下游订阅者,并且将导致跳过 Observable的订阅。
*/
public final <T> Observable<T> andThen(ObservableSource<T> next) {
ObjectHelper.requireNonNull(next, "next is null");
return RxJavaPlugins.onAssembly(new CompletableAndThenObservable<T>(this, next));
}
/**
* 返回一个Flowable,它将订阅此Completable,一旦完成,则将订阅{@code next} Flowable。
* 来自此Completable的错误事件将传播到下游订阅者,并且将导致跳过 Publisher的订阅。
*/
public final <T> Flowable<T> andThen(Publisher<T> next) {
ObjectHelper.requireNonNull(next, "next is null");
return RxJavaPlugins.onAssembly(new CompletableAndThenPublisher<T>(this, next));
}
/**
* 返回一个将订阅此Completable的Single,一旦完成,则将订阅{@code next} SingleSource。
* 来自此Completable的错误事件将传播到下游订阅者,并且将导致跳过 Single的订阅。
*/
public final <T> Single<T> andThen(SingleSource<T> next) {
ObjectHelper.requireNonNull(next, "next is null");
return RxJavaPlugins.onAssembly(new SingleDelayWithCompletable<T>(next, this));
}
/**
* 返回{@link Maybe},它将订阅此Completable,一旦完成,则将订阅{@code next} MaybeSource。
* 来自此Completable的错误事件将传播到下游订阅者,并导致跳过 Maybe的订阅。
*/
public final <T> Maybe<T> andThen(MaybeSource<T> next) {
ObjectHelper.requireNonNull(next, "next is null");
return RxJavaPlugins.onAssembly(new MaybeDelayWithCompletable<T>(next, this));
}
/**
* 返回一个Completable,它首先运行此Completable,然后再运行另一个Completable。
* 这是{@link #concatWith(CompletableSource)}的别名。
*/
public final Completable andThen(CompletableSource next) {
ObjectHelper.requireNonNull(next, "next is null");
return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, next));
}
/**
* 将此Completable与另一个Completable串联。
* 返回:新的Completable,该Completable订阅了此内容,然后订阅了另一个Completable
* @see #andThen(MaybeSource)
* @see #andThen(ObservableSource)
* @see #andThen(SingleSource)
* @see #andThen(Publisher)
*/
@CheckReturnValue
@NonNull
@SchedulerSupport(SchedulerSupport.NONE)
public final Completable concatWith(CompletableSource other) {
ObjectHelper.requireNonNull(other, "other is null");
return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, other));
}
示例:
private Completable getCompletableComplete() {
return Completable.create(new CompletableOnSubscribe() {
@Override
public void subscribe(CompletableEmitter emitter) throws Exception {
emitter.onComplete();//
}
});
}
private Completable getCompletableError() {
return Completable.create(new CompletableOnSubscribe() {
@Override
public void subscribe(CompletableEmitter emitter) throws Exception {
emitter.onError(new Error());//
}
});
}
@Test
public void andThen1() {
getCompletableComplete().andThen(Observable.range(0, 5))
.subscribe(getObserver());
}
//========onSubscribe=========
//========onNext=========0
//========onNext=========1
//========onNext=========2
//========onNext=========3
//========onNext=========4
//=========onComplete========
//返回一个Observable,它将订阅此Completable,
//一旦完成,则将订阅{@code next} ObservableSource。
// 来自此Completable的错误事件将传播到下游订阅者,并且将导致跳过 Observable的订阅。
@Test
public void andThen2() {
getCompletableError().andThen(Observable.range(0, 5))
.subscribe(getObserver());
}
//========onSubscribe=========
//========onError=========null
private Observer<Integer> getObserver() {
return new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
System.out.println("========onSubscribe=========");
}
@Override
public void onNext(Integer integer) {
System.out.println("========onNext=========" + integer);
}
@Override
public void onError(Throwable e) {
System.out.println("========onError=========" + e.getMessage());
}
@Override
public void onComplete() {
System.out.println("=========onComplete========");
}
};
}