Rx java Rxjava2-如何让观测者在第一个项目之后停止发射项目或使用zipWith？
下面的代码可以使网络调用正常。但它不断地发出同样的结果。我只想取得第一个结果并停止排放。有没有一个命令我可以说只是发出第一个。我尝试使用（1），但由于某种原因更改了结果大小Rx java Rxjava2-如何让观测者在第一个项目之后停止发射项目或使用zipWith？,rx-java,rx-java2,Rx Java,Rx Java2,下面的代码可以使网络调用正常。但它不断地发出同样的结果。我只想取得第一个结果并停止排放。有没有一个命令我可以说只是发出第一个。我尝试使用（1），但由于某种原因更改了结果大小 //class variables FeedsModel feedsModelResult; HashMap<Integer, ProductModel> productMap; //method @Override protected Observable buildUse
//class variables
FeedsModel feedsModelResult;
HashMap<Integer, ProductModel> productMap;
//method
@Override
protected Observable buildUseCaseObservable() {
/* gets feedModel then parses through each feed for product IDs. then does a network call to get each product. stores retrieved
product model in hashmap for quick retrieval. returns a pair.
*/
return feedRepository.fetchFeeds(shopId, langId, skip)
.concatMap(new Function<FeedsModel, ObservableSource<List<Feed>>>() {
@Override
public ObservableSource<List<Feed>> apply(@NonNull final FeedsModel feedsModel) throws Exception {
feedsModelResult = feedsModel;
return Observable.fromCallable(new Callable<List<Feed>>() {
@Override
public List<Feed> call() throws Exception {
return feedsModel.getFeed();
}
});
}
})
.concatMap(new Function<List<Feed>, ObservableSource<Feed>>() {
@Override
public ObservableSource<Feed> apply(@NonNull List<Feed> feeds) throws Exception {
return Observable.fromIterable(feeds);
}
}).filter(new Predicate<Feed>() {
@Override
public boolean test(@NonNull Feed feed) throws Exception {
return feed.getProducts() != null;
}
})
.concatMap(new Function<Feed, ObservableSource<Double>>() {
@Override
public ObservableSource<Double> apply(@NonNull Feed feed) throws Exception {
return Observable.fromIterable((ArrayList<Double>) feed.getProducts());
}
})
.concatMap(new Function<Double, ObservableSource<ProductModel>>() {
@Override
public ObservableSource<ProductModel> apply(@NonNull Double productId) throws Exception {
return productsRepository.fetchProduct(productId.intValue(), shopId, langId, currency);
}
}).concatMap(new Function<ProductModel, ObservableSource<Map<Integer, ProductModel>>>() {
@Override
public ObservableSource apply(@NonNull ProductModel productModel) throws Exception {
productMap.put(productModel.getIdProduct(), productModel);
return Observable.fromCallable(new Callable<Map<Integer, ProductModel>>() {
@Override
public Map<Integer, ProductModel> call() throws Exception {
return productMap;
}
});
}
}).concatMap(new Function<Map<Integer, ProductModel>, ObservableSource<Pair>>() {
@Override
public ObservableSource apply(@NonNull final Map<Integer, ProductModel> productModelMap) throws Exception {
return Observable.fromCallable(new Callable() {
@Override
public Object call() throws Exception {
return Pair.create(feedsModelResult, productMap);
}
});
}
});
}
//类变量
FeedsModel feedsModelResult；
HashMap-productMap；
//方法
@凌驾
受保护的可观察buildUseCaseObservable（）{
/*获取feedModel，然后解析每个提要中的产品ID。然后执行网络调用以获取每个产品。检索存储
hashmap中的产品模型，用于快速检索。返回一对。
*/
return feedRepository.fetchFeeds（shopId、langId、skip）
.concatMap（新函数（）{
@凌驾
公共ObserviceSource apply（@NonNull final FeedsModel FeedsModel）引发异常{
feedsModelResult=feedsModel；
返回Observable.fromCallable（newcallable（））{
@凌驾
公共列表调用（）引发异常{
返回feedsModel.getFeed（）；
}
});
}
})
.concatMap（新函数（）{
@凌驾
public observesource apply（@NonNull List feed）引发异常{
返回可观察。从可观察（馈送）；
}
}).filter（新谓词（）{
@凌驾
公共布尔测试（@NonNull Feed）引发异常{
return feed.getProducts（）！=null；
}
})
.concatMap（新函数（）{
@凌驾
公共ObserviceSource apply（@NonNull提要）引发异常{
返回Observable.fromIterable（（ArrayList）feed.getProducts（））；
}
})
.concatMap（新函数（）{
@凌驾
public observesource apply（@NonNull Double productId）引发异常{
return productsRepository.fetchProduct（productId.intValue（），shopId，langId，currency）；
}
}).concatMap（新函数（）{
@凌驾
公共ObserviceSource apply（@NonNull ProductModel ProductModel）引发异常{
productMap.put（productModel.getIdProduct（），productModel）；
返回Observable.fromCallable（newcallable（））{
@凌驾
公共映射调用（）引发异常{
返回productMap；
}
});
}
}).concatMap（新函数（）{
@凌驾
public observesource apply（@NonNull final Map productModelMap）引发异常{
返回Observable.fromCallable（newcallable（））{
@凌驾
公共对象调用（）引发异常{
返回Pair.create（feedsModelResult、productMap）；
}
});
}
});
}
在调用的最后是results Pair.create（feedsModelResult，productMap）；我想我应该使用zipWith运算符等待所有结果完成，但我不确定如何理解您的流程，但似乎您正在尝试查询一些
FeedsModelPairFeedsModel可观察的是平坦的，可能会乘以每个内部列表，并尝试在到达地图的过程中收集它们，而流仍会将这些项目发送给最终订户
您需要的是一个流，该流获取一个输入FeedsModel
，将所有项目收集到一个映射，并且只发出一个作为结果映射的项目，然后您可以将该映射与输入FeedsModel
以及刚刚收集的结果映射配对。
假设您的feedRepository.fetchFeeds
只能返回单个FeedsModel
项（您可以使用single
对其进行细化），那么您将在结束流中得到单个结果
建议使用包含结果选择器的flatMap变体：
feedRepository.fetchFeeds(shopId, langId, skip)
.flatMap(feedsModel ->
getProductsMapFromFeedsModelObservable(feedsModel, shopId, langId, currency)
,(feedsModel, productsMap) ->
Pair.create(feedsModel, productsMap)
);
而getProductsMapFromFeedsModelObservable（）
是一个可观察的
，它从输入FeedsModel收集产品到产品映射：
private Observable<HashMap<Integer, ProductModel>> getProductsMapFromFeedsModelObservable(
FeedsModel feedsModel, int shopId, int langId, int currency) {
return Observable.fromIterable(feedsModel.getFeed())
.filter(feed -> feed.getProducts() != null)
.flatMapIterable(feed -> feed.getProducts())
.flatMap(productId -> productsRepository.fetchProduct(productId.intValue(), shopId, langId, currency))
.reduce(new HashMap<Integer, ProductModel>(),
(productsMap, productModel) -> {
productsMap.put(productModel.getIdProduct(), productModel);
return productsMap;
})
.toObservable();
}
私有可观测getProductsMapFromFeedsModelObservable(
FeedsModel FeedsModel，int shopId，int langId，int currency）{
返回Observable.fromIterable（feedsModel.getFeed（））
.filter（提要->提要.getProducts（）！=null）
.flatMapIterable（提要->提要.getProducts（））
.flatMap（productId->productsRepository.fetchProduct（productId.intValue（），shopId，langId，currency））
.reduce（新的HashMap（），
（productsMap，productModel）->{
productsMap.put（productModel.GetIdro