RxJava 2-在另一个Completable之后调用Completable

Question

我是RxJava的新手，面临以下问题：

我有两个可完成的对象来存储一些数据。我想触发第一个，然后在第一个成功完成后再启动第二个。应该阻止对第二个Completable的调用，直到第一个完成并成功为止。此外，如果第一个完成时出现错误，则还应跳过另一个。

通过查看留档和其他SO问题，concatTo或andAnd似乎对我有用。但是在手动测试和单元测试中，我可以看到第二个可完成项是与第一个并行触发的：/

首先完成

public Completable doA() {
  Log.d(TAG, "class call");

  return db.countRows()
    .doOnSuccess(integer -> {
      Log.d(TAG, "found rows: "+integer);
    })
    .doOnError(Throwable::printStackTrace)
    .flatMapCompletable(this::customAction);
}

private Completable customAction(final int count) {
  Log.d(TAG, "count: "+count);
  if (count > 0) {
    Log.d(TAG, "no rows, skip");
    return Completable.complete();
  }

  final User user = ...
  return db.save(user); // return Completable
}

第二个可完成

public Completable doB() {
  Log.d(TAG, "call to B");
  // ...
}

尝试在A之后调用B

public Completable someMethod() {
    Log.d(TAG, "someMethod");
    return doA()
        .andThen(doB());
        // this also doesn't work
        //.concatWith(doB());
}

订阅

someMethod()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .doOnComplete(() -> {
      Log.d(TAG, "complete");
      // ...
    })
    .doOnError(throwable -> {
      Log.d("Main", "error "+throwable.getMessage());
      // ...
    })
    .subscribe();

当我运行应用程序并查看日志时，我可以看到：

D/Some method: some method
D/DoA: class call
D/DoB: class call   // <- why here?
D/DoA: found rows: 0
D/DoA: count: 0

此外，以下单元测试失败：

@Test
public void test() {
  when(doa.doA()).thenReturn(Completable.error(new Exception("test")));

  observe(); // subscription with TestObserver

  verify(dob, never()).doB(); // fails with NeverWantedButInvoked
}

我错过了什么？

Answer 1

您可以使用andAnd（）或concatBy（）运算符。

返回一个Completable，该Completable首先运行此Completable，然后运行另一个Completable。

然后（）

firstCompletable
    .andThen(secondCompletable)

通常，此操作符是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)

连接方式：

firstCompletable
        .concatWith(secondCompletable)

Answer 2

因为您调用了doB（）。让我重写您的流程：

public Completable someMethod() {
    Log.d(TAG, "someMethod");

    // doA() inlined
    LOG.d("class call");
    Completable a = ...

    // doB() inlined
    Log.d("class call");
    Completable b = ...

    return a.andThen(b);
}