RxJava - 组合多个 Singles 的结果并作为一个返回答案

【问题标题】：RxJava - Combining the results of multiple Singles and return as oneRxJava - 组合多个 Singles 的结果并作为一个返回
【发布时间】：2020-05-11 09:47:22
【问题描述】：

我遇到了以下问题：我有一个 Single 返回一个对象列表，在每个对象内部，有一个字段也是一个 Single，它返回一个项目列表（这是我需要的），但我也需要这个列表返回为一个结果，而不是作为每个单独的..

我有一个可以使用的 Observable，它包装了所有这些代码，所以我想在 onNext 中发出结果。

另外，我还需要将每个 Single 的单独结果添加到缓存中，键为父对象

代码：

object.getListOfObjects().doOnSuccess { objectList ->
                      objectList.map { singleItemInList ->
                          singleItemInList.listOfValues.subscribe({ valueList ->
                              cache[singleItemInList] = valueList
                              emitter.onNext(valueList)
                            // ^ this is the bit where i need to get all values instead of 
                            //   emitting on next for each item
                          },{
                              emitter.onError(it)
                          })
                      }
                  }.subscribe( {
                   /* no-op*/

                  }, {
                      emitter.onError(it)
                  })

任何帮助将不胜感激！

提前谢谢:)

编辑 - 额外细节：

fun getListOfObjects(): Single<List<Object>> =
        Single.zip(
            allObjects().map { it.objects() }
        ) { t: Array<Any> ->
            t.map { it as Object }
        }

Object {
    [...]
    val listOfValues: Single<ValueList>
    [...]
}

【问题讨论】：

标签： android rx-java rx-java2 rx-android

【解决方案1】：

在这种情况下使用 flatMap 运算符并在最后一步使用 toList

object.getListOfObjects()
    .flatMap { objectList -> objectList.listOfValues() }
    .toList()
    .subscribe({ result -> TODO() }, { error -> TODO() })

【讨论】：

我正在尝试这个，但我错过了我认为在您的解决方案中的一步。在我的问题中，singleItemInList 是包含listOfValues 的那个，而不是objectList.. 在singleItemList 工作中会有一个额外的平面地图吗？
您能否提供该方案的函数签名和类结构（简化）？
按要求为问题添加了更多信息:)

【解决方案2】：

我找到了一种方法，但它远非漂亮......任何关于如何更漂亮地实现它的建议将不胜感激！ :D

object.getListOfObjects().doOnSuccess { objectList ->
                    val list = objectList.map { singleItemInList ->
                              singleItemInList.listOfValues.subscribe({ valueList ->
                                  cache[singleItemInList] = valueList
                              },{
                                  emitter.onError(it)
                              })
                          }
                      }.flatten().map {
                        it.toObservable()
                      }
                    Observable.zip(list) { itemList ->
                      val compoundList = mutableListOf<Value>()
                      for (i in itemList.indices) {
                        val singleList = itemList[i] as? List<Value>
                        singleList?.map { item ->
                            compoundList.add(item)
                        }
                    }
                    emitter.onNext(compoundList) 
                    // ^ this now emits the entire list instead of 
                    // each sublist individually
                    emitter.onComplete()
                }.subscribe({
                   /* no-op */
                }, {
                   emitter.onError(it)
                })
            }.subscribe({
                /* no-op */
            }, {
               emitter.onError(it)
            })

【讨论】：

不，我很确定其他答案 (.flatMap().toList()) 应该足以解决最初概述的问题。