Kotlin RxJava2 Flowable不使用create就发出多个网络调用的结果？

我有一个通用屏幕，订阅返回列表的RxJava2 flowable。然后显示列表中的内容

现在我有了一个用例，我需要从多个端点收集数据，在某些端点完成后发送数据，然后在其余端点完成后再次发送数据

我使用Flowable.create（）来实现这一点，但我看到很多帖子说，通常有比使用create更好、更安全的方法来实现这一点？我似乎认为是这样的，因为我需要在可观察的范围内订阅一个可观察的，理想情况下我不想这样做

因为我在内部订阅，我知道当其他网络调用完成时，发射器可能会在可观察范围内被取消，所以我添加了检查，以确保它在处理后不会抛出错误，这会起作用（至少在测试中…）[我还记得，如果我像这样保存内部订阅，那么在处理外部订阅时，我可以使用代码来处理内部订阅]

前2个呼叫可能非常快（或瞬间），这就是我希望立即发出第一个结果的原因，接下来4个依赖该数据的网络呼叫可能需要时间来处理

现在看起来大概是这样的

return Flowable.create<List<Object>>({ activeEmitter ->
        Single.zip(
                single1(),
                single2(),
                BiFunction { single1Result: Object, single2result: Object ->

                    if (single1result.something || single2Result.somethingElse) {
                        activeEmitter.onNext(function(single1result, single2result) //returns list
                    }

                    Single.zip(
                            single3(single1result),
                            single4(single2result),
                            single5(single1result),
                            single6(single2result),
                            Function4 { single3Result: Object,
                                        single4Result: Object,
                                        single5Result: Object,
                                        single6Result: Object ->
                                ObjectHolder(single1Result, single2Result, single3Result, single4Result, single5Result, single6Result)
                            }
                    )
                }
        ).flatMap { objectHolder ->
            objects.flatMap { objectHolder ->
                Single.just(parseObjects(objectHolder))
            }
        }.subscribeBy(
                onError = { error ->
                    if (!activeEmitter.isCancelled) {
                        activeEmitter.onError(error)
                    }
                },
                onSuccess = { results ->
                    if (!activeEmitter.isCancelled) {
                        activeEmitter.onNext(results)
                        activeEmitter.onComplete()
                    }
                }
        )
    }, BackpressureStrategy.BUFFER)

返回可流动的。创建（{activeEmitter->
Single.zip(
single1（），
single2（），
双函数{single1Result:Object，single2result:Object->
if（single1result.something | | single2Result.somethingElse）{
onNext（函数（single1result，single2result）//返回列表
}
Single.zip(
single3（single1result），
single4（single2result），
single5（single1result），
single6（single2result），
函数4{single3Result:Object，
single4Result:Object，
single5Result:Object，
single6Result:对象->
对象持有者（single1Result、single2Result、single3Result、single4Result、single5Result、single6Result）
}
)
}
).flatMap{objectHolder->
objects.flatMap{objectHolder->
Single.just（parseObjects（objectHolder））
}
}.订阅人(
onError={错误->
如果（！activeEmitter.isCancelled）{
activeEmitter.onError（错误）
}
},
onSuccess={results->
如果（！activeEmitter.isCancelled）{
activeEmitter.onNext（结果）
activeEmitter.onComplete（）
}
}
)
}，背压等级。缓冲器）

如果不这样做，我想不出另一种方法来返回一个Flowable，它会发出多个不同网络调用的结果

有没有其他/更好的方法我找不到

---

我根据ctranxuan的回复解决了这个问题。发布帖子是为了让他能够调整/优化，然后我接受他的回答

 return Single.zip(single1(), single2(),
            BiFunction { single1result: Object, single2result: Object ->
                Pair(single1result, single2result)
            }
    ).toFlowable()
            .flatMap { single1AndSingle2 ->
                if (isFirstLoad) {
                    createItemOrNull(single1AndSingle2.first, single1AndSingle2.second)?.let { result ->
                        Single.just(listOf(result)).mergeWith(proceedWithFinalNetworkCalls(single1AndSingle2))
                    }.orElse {
                        proceedWithFinalNetworkCalls(single1AndSingle2).toFlowable()
                    }
                } else {
                    proceedWithFinalNetworkCalls(single1AndSingle2).toFlowable()
                }
            }.doOnComplete {
                isFirstLoad = false
            }

fun proceedWithFinalNetworkCalls(): Flowable<List> {
          return Single.zip(
                            single3(single1result),
                            single4(single2result),
                            single5(single1result),
                            single6(single2result),
                            Function4 { single3Result: Object,
                                        single4Result: Object,
                                        single5Result: Object,
                                        single6Result: Object ->
                                ObjectHolder(single1Result, single2Result, single3Result, single4Result, single5Result, single6Result)
                            }
)

返回Single.zip（single1（），single2（），
双函数{single1result:Object，single2result:Object->
配对（single1result，single2result）
}
).toFlowable（）
.flatMap{single1和single2->
if（isFirstLoad）{
createItemOrNull（Single1和Single2.first，Single1和Single2.second）？.let{result->
Single.just（listOf（result））.mergeWith（proceedWithFinalNetworkCalls（single1和single2））
}奥里斯先生{
proceedWithFinalNetworkCalls（Single1和Single2）.toFlowable（）的过程
}
}否则{
proceedWithFinalNetworkCalls（Single1和Single2）.toFlowable（）的过程
}
}doOnComplete先生{
isFirstLoad=false
}
fun proceedWithFinalNetworkCalls（）：可流动{
返回Single.zip(
single3（single1result），
single4（single2result），
single5（single1result），
single6（single2result），
函数4{single3Result:Object，
single4Result:Object，
single5Result:Object，
single6Result:对象->
对象持有者（single1Result、single2Result、single3Result、single4Result、single5Result、single6Result）
}
)

很抱歉，它是用Java编写的，但据我所知，这样的解决方案可能是可行的

publicstaticvoidmain（字符串[]args）{
final single1=single1（）.cache（）；
single1.map（列表：：of）
.mergeWith（single1.zipWith（single2（），Map:：entry）
.flatMap（条目->Single.zip(
single3（entry.getKey（）），
single4（entry.getValue（）），
single5（entry.getKey（）），
single6（entry.getValue（）），
（el3，el4，el5，el6）->objectHolder（entry.getKey（），entry.getValue（），el3，el4，el5，el6）））
.subscribe（System.out:：println，
System.err:：println）；
Flowable.timer（1，分钟）//只是暂时阻塞主线程
.阻止订阅（）；
}
私有静态列表o
[s1]
[s1, s2, s3_s1, s4_s2, s5_s1, s6_s2]