Android、改型、RxJava-将多个实体中的字段合并为一个

请看下面我的代码。从城市检索类别的我的代码：

mcityAPI.authDevice(req)
                    .subscribeOn(Schedulers.io())
                    .flatMap(token -> mcityAPI.getCategories("/city/599/category",prepareHeaders(token)))
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(categoryList->
                    {
                        HashMap<String, String> categoryNamesMap = new HashMap<>();
                        for (Category category : categoryList)
                        {
                            categoryNamesMap.put(category.getId(), category.getName());
                        }

                    }

                    , throwable ->
                    {
                        Throwable error = throwable;
                        String err = error.toString();
                    });

mcityAPI.authDevice（请求）
.subscribeOn（Schedulers.io（））
.flatMap（token->mcityAPI.getCategories（“/city/599/category”，prepareHeaders（token）））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（类别列表->
{
HashMap categoryNamesMap=新HashMap（）；
用于（类别：类别列表）
{
categoryNamesMap.put（category.getId（），category.getName（））；
}
}
，可丢弃->
{
可丢弃错误=可丢弃；
字符串err=error.toString（）；
});

因此，第一个设备需要授权-

authDevice

。然后，需要提供令牌来调用

getCategories

（实际上，令牌应该首先通过调用

prepareHeaders

）转换到头文件中

到目前为止，它是有效的。我能够成功加载类别。下一步是获取事件。在这种情况下，我应该调用

/city/599/event

，但我需要按以下步骤执行：

• 再次提供标题（如何访问以前检索到的令牌？）
• 我的事件pojo模型类包含一个额外字段，名为

  categoryName

  。每个返回的事件将包含名为

  categoryId

  的字段。我还添加了一个额外字段

  categoryName

  。对于每个返回的类别，我需要为

  categoryName

  额外字段分配适当的值。类别名称应通过

  categoryId

---

是否有任何优雅的方式（一些rxJava操作符等）允许我做我想做的事情

您可以复制第一部分，再次对其进行平面映射，并将两个观察值与

但就性能而言，它不会很好

您可以做的是使用相同的可观察令牌来触发这两个请求。因此，通过将第一个

可观察对象

转换为热可观察对象，您可以使用它，而无需启动两次请求：

Observable<Token> obsToken = mcityAPI.authDevice(req)
                                 .share();       // So the authDevice method is only invoqued once
// Assumming your Category's ID is an Integer
Observable<Map<Integer, Category>> obsCategories = obsToken
                                           .flatMap(token -> mcityAPI.getCategories("/city/599/category",prepareHeaders(token)))
                                           .toList()     // So we have all categories
                                           .map(categoryList -> {
                                               Map<Integer, Category> result = new HashMap<>();
                                               for (Category c : categories)
                                                   result.put(c.getId(), c);
                                               return result;
                                           })
                                           .subscribeOn(Schedulers.io());
Observable<List<Event>> obsEvents = obsToken
                                   .flatMap(token -> mcityAPI.getEvents("/city/599/eventprepareHeaders(token)))
                                   .toList()             // So we have all events
                                   .subscribeOn(Schedulers.io());
Observable<?> result = Observable.zip(obsCategories, obsEvents, (categories, events) -> {
    // now you have all categories and events
    // you can now fill category name by looking into the first map
    for (Event e : events)
        events.forEach(event -> 
            event.setCategoryName(
                categories.get(event.getCategoryId()).getName()
                )
        );
    // Do the rest of mapping and return something...
}

obbstoken=mcityAPI.authDevice（请求）
.share（）；//因此，authDevice方法只涉及一次
//假设类别的ID为整数
可观测的OBSContegories=obsToken
.flatMap（token->mcityAPI.getCategories（“/city/599/category”，prepareHeaders（token）））
.toList（）//所以我们有所有类别
.map（类别列表->{
映射结果=新的HashMap（）；
适用于（c类：类别）
result.put（c.getId（），c）；
返回结果；
})
.subscribeOn（Schedulers.io（））；
可观测的obsEvents=obsToken
.flatMap（token->mcityAPI.getEvents（“/city/599/eventprepareHeaders（token）））
.toList（）//所以我们有所有事件
.subscribeOn（Schedulers.io（））；
Observable result=Observable.zip（obsCategories，obsEvents，（categories，events）->{
//现在您拥有了所有类别和事件
//现在可以通过查看第一个地图来填充类别名称
对于（事件e：事件）
events.forEach（事件->
event.setCategoryName(
categories.get（event.getCategoryId（））.getName（）
)
);
//完成其余的映射并返回一些内容。。。
}

您可以复制第一部分，再次对其进行平面映射，并将两个观察值与

但就性能而言，它不会很好

您可以使用相同的token observable来触发两个请求。因此，通过将第一个

observable

转换为热observable，您可以使用它，而无需启动两次请求：

Observable<Token> obsToken = mcityAPI.authDevice(req)
                                 .share();       // So the authDevice method is only invoqued once
// Assumming your Category's ID is an Integer
Observable<Map<Integer, Category>> obsCategories = obsToken
                                           .flatMap(token -> mcityAPI.getCategories("/city/599/category",prepareHeaders(token)))
                                           .toList()     // So we have all categories
                                           .map(categoryList -> {
                                               Map<Integer, Category> result = new HashMap<>();
                                               for (Category c : categories)
                                                   result.put(c.getId(), c);
                                               return result;
                                           })
                                           .subscribeOn(Schedulers.io());
Observable<List<Event>> obsEvents = obsToken
                                   .flatMap(token -> mcityAPI.getEvents("/city/599/eventprepareHeaders(token)))
                                   .toList()             // So we have all events
                                   .subscribeOn(Schedulers.io());
Observable<?> result = Observable.zip(obsCategories, obsEvents, (categories, events) -> {
    // now you have all categories and events
    // you can now fill category name by looking into the first map
    for (Event e : events)
        events.forEach(event -> 
            event.setCategoryName(
                categories.get(event.getCategoryId()).getName()
                )
        );
    // Do the rest of mapping and return something...
}

obbstoken=mcityAPI.authDevice（请求）
.share（）；//因此authDevice方法只被调用一次
//假设类别的ID为整数
可观测的OBSContegories=obsToken
.flatMap（token->mcityAPI.getCategories（“/city/599/category”，prepareHeaders（token）））
.toList（）//所以我们有所有类别
.map（类别列表->{
映射结果=新的HashMap（）；
适用于（c类：类别）
result.put（c.getId（），c）；
返回结果；
})
.subscribeOn（Schedulers.io（））；
可观测的obsEvents=obsToken
.flatMap（token->mcityAPI.getEvents（“/city/599/eventprepareHeaders（token）））
.toList（）//所以我们有所有事件
.subscribeOn（Schedulers.io（））；
Observable result=Observable.zip（obsCategories，obsEvents，（categories，events）->{
//现在您拥有了所有类别和事件
//现在可以通过查看第一个地图来填充类别名称
对于（事件e：事件）
events.forEach（事件->
event.setCategoryName(
categories.get（event.getCategoryId（））.getName（）