在Rxjava2中从Single.onErrorResumeNext启动可观测链

loadSingle

返回单个对象，如果失败，我想调用

getObservable（rsList）

返回Observable。 我正在尝试使用

OneRorResumeNext

，但它需要单个对象。 如果

loadSingle（）

失败，如何调用

getObservable（rsList）

提前谢谢

                    repo.loadSingle()
                            .subscribeOn(Schedulers.io())
                            
                            .onErrorResumeNext {
                                repo.getObservable(rsList)
                            }
                            .flatMapObservable {
                                if (it != null && it.status == Status.SUCCESS) {
                                    upRsList(it.data)
                                }
                                repo.getObservable(rsList)
                            }
                          
                            ({ //observable success
                             }, {
                               //observable error 
                            })

Api接口

interface HomeApi{
    fun getSingel():Single<List<String>>
    fun getObservable():Observable<HomeResponse>
}

接口HomeApi{
fun getSingel（）：单身
fun getObservable（）：可观察
}

依赖项 必修课 Repo#loadSingle（）同步抛出异常

---

如果获取rsList失败，您希望如何获取rsList？您可能会使用种子/默认值。此外，您不需要使用it！=空测试，因为RxJava将为您完成它。不允许使用空值。rsList是emptyList，因此如果获取失败，请使用emptyList或上次更新的list。感谢您的测试指导。Repo#getObservable返回哪种类型？谢谢，但当我得到运行时异常时，它不会有帮助。您从哪里得到运行时异常？哪些方法引发RuntimeException？请给我看一些代码。@iamanbansal，用Single.defer{repo.loadSingle（）}包装您的代码。Ob subscribe异常将被捕获并作为onError传播。

testImplementation("org.junit.jupiter:junit-jupiter-api:5.6.2")
testRuntimeOnly("org.junit.platform:junit-platform-launcher:1.6.2")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.6.2")
testRuntimeOnly("org.junit.vintage:junit-vintage-engine:5.6.2")
implementation "io.reactivex.rxjava3:rxjava:3.0.4"
implementation "io.reactivex.rxjava3:rxkotlin:3.0.0"

internal interface Repo {
    fun loadSingle(): Single<Result<List<String>>>

    fun getObservable(list: List<String>): Observable<String>
}

internal class RepoImpl : Repo {
    override fun loadSingle(): Single<Result<List<String>>> {
        return Single.error(RuntimeException("fail"))
    }

    override fun getObservable(list: List<String>): Observable<String> {
        if (list === emptyList<String>()) {
            return Observable.just("42")
        }
        return Observable.just("success")
    }
}

internal sealed class Result<T> {
    data class Success<T>(val value: T) : Result<T>()

    data class Failure<T>(private val failure: Throwable) : Result<T>()
}

class So64751341 {
    @Test
    fun `64751341`() {
        val repo: Repo = RepoImpl()
        val testScheduler = TestScheduler()

        val flatMapObservable = repo.loadSingle()
            .subscribeOn(testScheduler)
            .onErrorReturn { failure -> Result.Failure(failure) }
            .flatMapObservable { result ->
                when (result) {
                    is Result.Success -> repo.getObservable(result.value)
                    is Result.Failure -> repo.getObservable(emptyList())
                }
            }


        val test = flatMapObservable.test()

        testScheduler.triggerActions()

        test // return default value 42 onError
            .assertValue("42")
    }
}

internal class RepoExceptionImpl : Repo {
    override fun loadSingle(): Single<Result<List<String>>> {
        throw java.lang.RuntimeException("whatever")
    }

    override fun getObservable(list: List<String>): Observable<String> {
        if (list === emptyList<String>()) {
            return Observable.just("42")
        }
        return Observable.just("success")
    }
}

@Test
fun `64751341_exception`() {
    val repo: Repo = RepoExceptionImpl()
    val testScheduler = TestScheduler()

    val flatMapObservable = Single.defer {
        repo.loadSingle()
    }
        .subscribeOn(testScheduler)
        .onErrorReturn { failure -> Result.Failure(failure) }
        .flatMapObservable { result ->
            when (result) {
                is Result.Success -> repo.getObservable(result.value)
                is Result.Failure -> repo.getObservable(emptyList())
            }
        }

    val test = flatMapObservable.test()

    testScheduler.triggerActions()

    test // return default value 42 onError
        .assertValue("42")
}