Question

我想构建一个返回Repository的{{1}}类。

该课程应首先查看返回Single<Something>的{{1}}，如果Cache完成，请转到返回Maybe<Something>的{{1}}

Maybe

我已经搜索了JavaDoc，但似乎并不存在针对此场景的转换器。

有一种很好的处理方法吗？

Answer 1

以下是您可以使用的两个相当简单的选项。第一个我发现更明确。第二个好处是你可以在缓存中的任何错误上调用网络。

这些假设从缓存中返回了Maybe。例如，如果在缓存中找不到任何值，则返回Maybe.empty（）

1）如果流中有空，则switchIfEmpty（）将使用调用网络的备用observable。如果流中没有空，则永远不会调用网络。

override fun getSomething(): Single<Something> {
      return cache.getSomething()
        .switchIfEmpty(
          Maybe.defer {
            feed.getSomething().toMaybe()
          }
        )
        .toSingle()
  }

2）当转换为单个（）时，空的可能会返回错误，从而触发网络呼叫。

override fun getSomething(): Single<Something> {
      return cache.getSomething()
        .toSingle()
        .onErrorResumeNext {
           feed.getSomething()
        }
  }

Answer 2

当您需要使用元数据执行RxJava操作（没有缓存结果）时，您可能必须使用materialize()将观察者链转换为元数据流。

（对我在Kotlin缺乏流利感到道歉）

fun getSomething(): Single<Something> {
  return cache.getSomething()
    .toObservable()
    .materialize()
    .take(1)
    .flatMap( it.hasValue() ? Single.just( it.getValue() )
              : Single.fromCallable( apiCall() )
      );
}

materialize()运算符将观察者流转换为Notification s流。然后，您可以检查第一个通知，如果它有值，请使用它。否则，请拨打网络电话。

Answer 3

使用以下带有 3 个参数的 flatMap 调用用于 Maybe

public final <R> Maybe<R> flatMap(
        Function<? super T, ? extends MaybeSource<? extends R>> onSuccessMapper,
        Function<? super Throwable, ? extends MaybeSource<? extends R>> onErrorMapper,
        Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)

示例

class Repository (
    private val cache: Cache,
    private val service: Service
) {

    fun getSomething(): Single<Something> {
      return cache.getSomething()
                .flatMap(
                    Function {
                        Single.just(it) // onSuccess
                    },
                    Function {
                        Single.error(it) // onError
                    },
                    Callable {
                        feed.getSomething() // onComplete
                    }
                
    }

或

class Repository (
    private val cache: Cache,
    private val service: Service
) {

    fun getSomething(): Single<Something> {
      return cache.getSomething()
                .flatMap(
                    {
                        Single.just<Something>(it) // onSuccess
                    },
                    {
                        Single.error(it) // onError
                    },
                    {
                        feed.getSomething() // onComplete
                    }
                
    }
}

如果Maybe完成，则将Maybe从另一个源转换为Single

3 个答案: