Question

我遇到以下问题：我有一个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>
    [...]
}

Answer 1

在这种情况下，并在最后一步flatMap，使用toList

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

Answer 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)
            })

RxJava-组合多个单打的结果并作为一个返回

2 个答案: