Java 如果Maybe完成，可以从另一个源转换为单个

我想构建一个

存储库

类，它返回一个

单个

类应该首先查看

缓存

，该缓存返回

Maybe

，如果

Maybe

完成，则转到我的

服务

，该服务返回

Single

接口缓存{
有趣的事：也许
}
接口服务{
fun getSomething（）：单身
}
类存储库(
私有val缓存：缓存，
私人增值税服务
) {
fun getSomething（）：单身{
返回cache.getSomething（）
.？？（feed.getSomething（））//onCompleteTransformToSingle（）或类似
}
}    

我已经搜索了JavaDoc，但似乎不存在用于此场景的转换器

---

有什么好办法处理这个问题吗

当需要使用元数据执行RxJava操作时（没有缓存结果），可能需要使用

materialize（）

将观察者链转换为元数据流

（对我在科特林语方面不够流利表示歉意）

fun getSomething（）：单身{
返回cache.getSomething（）
.TooObservable（）文件
.具体化
.采取（1）
.flatMap（it.hasValue（）？Single.just（it.getValue（））
：Single.fromCallable（apiCall（））
);
}

---

materialize（）

操作符将观察者流转换为

通知流。然后可以检查第一个通知，如果它有值，则使用该值。否则，请拨打网络电话。
这里有两个非常简单的选项，您可以使用。第一个我发现更明确。第二个好处是，当缓存中出现任何错误时，您都可以调用网络

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

这些假设可能是从缓存返回的。例如，如果在缓存中找不到值，则返回Maybe.empty（）

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

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

override fun getSomething（）：单个{
返回cache.getSomething（）
.switchIfEmpty(
也许吧，推迟{
feed.getSomething（）.toMaybe（）
}
)
.toSingle（）
}

2） 当强制转换为Single（）时，空值可能会返回错误，从而触发网络调用

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

override fun getSomething（）：单个{
返回cache.getSomething（）
.toSingle（）
.下一个{
feed.getSomething（）
}
}
使用以下带有3个参数的flatMap调用，以便

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)

公共最终平面图(
作用
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
                    }
                
    }
}