在 RxJava2 中正确使用带有控制流的 Single

Question

我的代码中有以下 Rx 链：

public Single<List<Items>> dispatchStuff(){
    return mRepository.getList()
        .filter(list -> list.size() != 0)
        .flatMapSingle(mRepository::operateOnList())
        .doOnSuccess(mRepository::deleteList())
        .subscribeOn(mSchedulerProvider.io())
        .observeOn(mSchedulerProvider.ui());
}

但是，我不确定我在这里是否正确使用了过滤。 getList() 方法总是 return 一个值或错误，因此我认为使用 Single 是可以接受的。但是，只有当列表 returned 中有元素时，我才想执行其他操作。如果我过滤 Single 并且我的列表大小为 0，它将通过异常：

java.util.NoSuchElementException                                                                                                  
   at io.reactivex.internal.operators.maybe.MaybeFlatMapSingle$FlatMapMaybeObserver.onComplete(MaybeFlatMapSingle.java:106)                                                                                                  
   at io.reactivex.internal.operators.maybe.MaybeFilterSingle$FilterMaybeObserver.onSuccess(MaybeFilterSingle.java:92)                                                                                                  
   at io.reactivex.internal.operators.single.SingleFromCallable.subscribeActual(SingleFromCallable.java:37)                                                                                                  
   at io.reactivex.Single.subscribe(Single.java:2692)                                                                                                  
   at io.reactivex.internal.operators.maybe.MaybeFilterSingle.subscribeActual(MaybeFilterSingle.java:40)                                                                                                  
   at io.reactivex.Maybe.subscribe(Maybe.java:3707)                                                                                                  
   at io.reactivex.internal.operators.maybe.MaybeFlatMapSingle.subscribeActual(MaybeFlatMapSingle.java:47)                                                                                                  
   at io.reactivex.Single.subscribe(Single.java:2692)                                                                                                  
   at io.reactivex.internal.operators.single.SingleDoOnSuccess.subscribeActual(SingleDoOnSuccess.java:35)                                                                                                  
   at io.reactivex.Single.subscribe(Single.java:2692)                                                                                                  
   at io.reactivex.internal.operators.single.SingleSubscribeOn$SubscribeOnObserver.run(SingleSubscribeOn.java:89)                                                                                                  
   at io.reactivex.Scheduler.run(Scheduler.java:138)                                                                                                  
   at io.reactivex.internal.schedulers.ScheduledRunnable.run(ScheduledRunnable.java:59)                                                                                                  
   at io.reactivex.internal.schedulers.ScheduledRunnable.call(ScheduledRunnable.java:51)                                                                                                  
   at java.util.concurrent.FutureTask.run(FutureTask.java:237)                                                                                                  
   at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:269)                                                                                                  
   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1113)                                                                                                  
   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:588)                                                                                                  
   at java.lang.Thread.run(Thread.java:818)

我在使用 Single 时应该如何正确实施此控制流程？

Answer 1

好吧，它不再是 Single，而是 Maybe。但是，如果您不想切换到 Maybe，也许这会有所帮助：

public Single<List<Items>> dispatchStuff(){
  return mRepository.getList()
    .flatMapSingle(list ->
        list.size() > 0
        ? mRepository.operateOnList(list)
          .doOnSuccess(mRepository::deleteList)
        : Single.just(list)
    )
    .subscribeOn(mSchedulerProvider.io())
    .observeOn(mSchedulerProvider.ui());
}

但是，也许您实际上应该使用 Flowable<Items> 而不是 Single<List<Items>>？

在 RxJava2 中正确使用带有控制流的 Single

Correct use of Single with control flow in RxJava2

java

rx-java

rx-java2