Java 如何调用observable，将附加内容加载到对象，并将其转换为另一个observable？

我有一个

myCollectionInteractitor

从firebase数据库加载所有

CollectionItemVO

：

public interface MyCollectionInteractor extends BaseInteractor{
    Single<List<CollectionItemVO>> load ();
}

所以我有了这个

收藏项目

：

public class CollectionItem {

    private final CollectionItemVO itemVOList;
    private final Beer beer;

    public CollectionItem(Beer beer, CollectionItemVO itemVOList) {
        this.beer = beer;
        this.itemVOList = itemVOList;
    }

}

有一个完整的啤酒对象。要加载该对象，我使用另一个交互器：

public interface LoadBeerInteractor extends BaseInteractor {
    Flowable<Beer> load(String beerId);
}

公共接口LoadBeerInteractor扩展BaseInteractor{
流动荷载（管柱荷载）；
}

我想将此

CollectionInteractor.load

调用转换为发出

CollectionItem

的

Observable

，我想使用

LoadBeerInteractor.load（beerId）

将CollectionItem与full beer对象一起交付

---

就我所研究的内容而言，我相信使用flatmap可以做到这一点，但我还没有达到预期的效果。

我认为您需要这样做：

MyCollectionInteractor collections = ...
LoadBeerInteractor beers = ...

Flowable<CollectionItem> items = collections.load()
    .toFlowable()
    .flatMapIterable(it -> it) // unpack from Flow<List<T>> to Flow<T>
    .flatMap(it ->
        beers
            .load(it.beerId)
            .map(beer -> new CollectionItem(beer, it))
    )

myCollectionInteractitor集合=。。。
LoadBeerInteractor啤酒=。。。
可流动项=集合。加载（）
.toFlowable（）
.flatMapIterable（it->it）//从一个流到另一个流解包
.flatMap（it->
啤酒
.load（it.beerId）
.map（啤酒->新收藏项目（啤酒，it））
)

这也可能起作用：

Flowable<CollectionItem> items = collections.load()
    .toFlowable()
    .flatMap(list ->
        Flowable
            .from(list)
            .flatMap(it -> 
                beers
                    .load(it.beerId)
                    .map(beer -> new CollectionItem(beer, it))
            )
    )

Flowable items=collections.load（）
.toFlowable（）
.flatMap（列表->
流动的
.来自（名单）
.flatMap（it->
啤酒
.load（it.beerId）
.map（啤酒->新收藏项目（啤酒，it））
)
)

我认为您需要这样做：

MyCollectionInteractor collections = ...
LoadBeerInteractor beers = ...

Flowable<CollectionItem> items = collections.load()
    .toFlowable()
    .flatMapIterable(it -> it) // unpack from Flow<List<T>> to Flow<T>
    .flatMap(it ->
        beers
            .load(it.beerId)
            .map(beer -> new CollectionItem(beer, it))
    )

myCollectionInteractitor集合=。。。
LoadBeerInteractor啤酒=。。。
可流动项=集合。加载（）
.toFlowable（）
.flatMapIterable（it->it）//从一个流到另一个流解包
.flatMap（it->
啤酒
.load（it.beerId）
.map（啤酒->新收藏项目（啤酒，it））
)

这也可能起作用：

Flowable<CollectionItem> items = collections.load()
    .toFlowable()
    .flatMap(list ->
        Flowable
            .from(list)
            .flatMap(it -> 
                beers
                    .load(it.beerId)
                    .map(beer -> new CollectionItem(beer, it))
            )
    )

Flowable items=collections.load（）
.toFlowable（）
.flatMap（列表->
流动的
.来自（名单）
.flatMap（it->
啤酒
.load（it.beerId）
.map（啤酒->新收藏项目（啤酒，it））
)
)