这里有两个相当简单的选项可以使用。第一个我觉得更明确。第二个有一个好处，你会调用网络上的任何错误该高速缓存。
这些假设从该高速缓存返回一个Maybe。例如，如果在缓存中没有找到值，则返回Maya.empty（）
1)如果流中有一个空的，switchIfEmpty（）将使用调用网络的可观察变量，如果流中没有空的，网络将永远不会被调用。

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

2)空的maybe将在强制转换为Single（）时返回错误，从而触发网络调用。

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

当您需要使用元数据执行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流。然后，您可以检查第一个通知，如果它有值，则使用该值。否则，进行网络调用。

使用以下flatMap调用，其中3个参数表示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
                    }
                
    }
}

defaultIfEmpty可用于在转换为Single时处理空的Maybe结果。

下面是一个如何实现的示例：

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