Question

我正在尝试使用Rx和Room将一堆物品下载到我的android应用中，我必须提出很多请求才能下载下一个ID物品，然后使用该ID进行新的通话并获取物品，一遍又一遍。

首次致电以获取ITEM_ONE列表

-本地保存

*第二次调用以获取ITEM_TWO ID的列表（按ITEM_ONE ID）

***第三次调用以按ID（一对一）获取ITEM_TWO

***-本地保存-

****第四次呼叫以获取ITEM_THREE ID的列表（按ITEM_TWO ID）

*****第五次调用以按ID（一对一）获取ITEM_THREE

*****-保存在本地-

******第六次调用以获取ITEM_FOUR ID的列表（按ITEM_THREE ID）

*******第七次调用以按ID（一对一）获取ITEM_FOUR

*******-本地保存-

********第八次呼叫以获取ITEM_FIVE ID的列表（按ITEM_FOUR ID）

*********第九次调用以按ID（一对一）获取ITEM_FIVE

*********-保存在本地-

我正在尝试使用Rx进行调用，我（域和数据模块）有一个Api类，存储库，UseCase，还有DataManager，Interactor，Presenter，所以让Api带有改装请求，存储库以请求远程数据并保存返回可观察对象的本地数据，实现存储库方法的UseCases，DataManger调用UseCases获取可观察对象（调用以获取远程和本地数据返回Flowable，并调用插入本地数据返回Completables），Interactor使用DataManager（本地和远程）请求），然后由演示者完成所有逻辑。

作为一般演示，我有以下方法

存储库（获取远程数据）

override fun getRemoteItem(syncId: String, id: String): Flowable<Item> {
    return api.itemById(syncId, id)
        .map(fun(itemModel: ItemModel): Item {
            return itemModelObjectMapper.mapFrom(itemModel)
        }
}

用例

override fun createObservable(data: Map<String, Any>?): Observable<Item> {
    return itemRepository.getRemoteItem(
        data!!.["syncId"] as String,
        data.["id"] as String).toObservable()
}

DataManager

override fun getRemoteItem(data: Map<String, Any>?): Observable<Item>{
    return appUseCase.getRemoteItem(data)
}

交互器

override fun getItemById(syncId: String, id: String): Observable<Item>{
    val mapData = HashMap<String, Any>()
    mapData["syncId"] = synId
    mapData["id"] = id
    return dataManager.getRemoteItem(mapData)
}

我想下载所有数据，不需要花多长时间，所以我目前正在按照步骤进行操作

...
Observable.just(item_one_list)
    .flatMapIterable {list -> list}
    .flatMap(fun(item_one: ItemOne): Observable<List<ItemTwoIds>>{
        return interactor.getItemTwoIds(SyncId, item_one.id)
    })
    .onErrorResumeNext(fun(t: Throwable): ObservableSource<List<ItemTwoIds>>{
        return Observable.empty()
    })
    .flatMapIterable {list -> list}
    .flatMap(fun(item_two_id: ItemTwoIds): Observable<List<ItemTwoModel>>{
        return if (item_two_id.id == null){
            Observable.empty()
        } else {
            return interactor.getItemTwoById(SyncId, item_two_id.id)
        }
    })
    .toList()
    .flatMapCompletable(fun(item_two_model: ItemTwoModel): Completable{
        val mapData = HashMap<String, Any>
        mapData["item"] = item_two_model
        return interactor.insertAllItemTwo(mapData)
    })
    .andThen(interactor.getLocalItemTwoList())
    .flatMapCompletable(fun(items_two: List<ItemTwoEntity>): Completable{
        return Observable.just(items_two)
            .flatMapIterable {list -> list}
            .flatMap(fun(item_two: ItemTwo): Observable<List<ItemThreeIds>>{
                return interactor.getItemThreeIds(SyncId, item_two.id)
            })
            .onErrorResumeNext(fun(t: Throwable): ObservableSource<List<ItemThreeIds>>{
                return Observable.empty()
            })
            .flatMapIterable {list -> list}
            .flatMap(fun(item_three_id: ItemThreeIds): Observable<List<ItemThreeModel>>{
                return if (item_three_id.id == null){
                    Observable.empty()
                } else {
                    return interactor.getItemThreeById(SyncId, item_three_id.id)
                }
            })
            .toList()
            .flatMapCompletable(fun(item_three_model: ItemThreeModel): Completable{
                val mapData = HashMap<String, Any>
                mapData["item"] = item_three_model
                return interactor.insertAllItemThree(mapData)
            })
            .andThen(interactor.getLocalItemThreeList())
            .flatMapCompletable(fun(items_three: List<ItemThreeEntity>): Completable{
                return Observable.just(items_three)
                    .flatMapIterable {list -> list}
                    .... // same logic block to get ITEM_FOUR, and then ITEM_FIVE, etc, etc...
            })
...

完成所有这些工作后，我将在本地保存所有ITEM_ONE和所有ITEM_TWO，但是随后我的内存不足了。

ITEM_ONE_1

ITEM_ONE_2

ITEM_ONE_3

ITEM_ONE_4

ITEM_ONE_5

...

*** ITEM_TWO_item_one_1

*** ITEM_TWO_item_one_2

*** ITEM_TWO_item_one_3

*** ITEM_TWO_item_one_4

--------------------------------------------

我要下载

ITEM_ONE_1

*** ITEM_TWO_1_item_one_1

****** ITEM_THREE_1_item_two_1

********* ITEM_FOUR_item_three_1

****** ITEM_THREE_2_item_two_1

********* ITEM_FOUR_item_three_2

*** ITEM_TWO_2_item_one_1

****** ITEM_THREE_item_two_2

ITEM_ONE_2

*** ITEM_TWO_1_item_one_2

****** ITEM_THREE_item_two_1

*** ITEM_TWO_2_item_one_2