[英]RxJava flat map: what happens when one of the resulting observable complete?
I'm new to RxJava, I know flatmaps are for mapping an emitted item to observable. 我是RxJava的新手,我知道平面地图用于将发射的项目映射到可观察的项目。 I also know that based on the documentation the emitted observables all get combined (flatten) to a single observable stream. 我也知道,根据文档 ,所有发出的可观察变量都将合并(拼合)为单个可观察流。
I was wondering what happens if any of those inner observables get completed? 我想知道如果这些内在可观测值中的任何一个完成,会发生什么?
for example: I have an observable that emits a item data key. 例如:我有一个可观察到的发射项目数据键。 I have to make another async http call to get the item data from the server, so I call it by using another observable. 我必须进行另一个异步http调用才能从服务器获取项目数据,因此我通过使用另一个可观察的对象来调用它。 I use a flat map to connect these two and create one main observable. 我使用平面地图将这两者连接起来,并创建一个主要的可观察对象。
When does the run() method of following "SomeMethodThatWantsItems" get called? 以下“ SomeMethodThatWantsItems”的run()方法何时被调用?
public void someMethodThatWantsItems(MyHttpCaller httpCaller, SomeSearchEngine searchEngine)
{
Consumer<Item> onNextConsumer =
Observable<Item> searchObservable = getSearchResult(httpCaller, searchEngine, "The Search Word");
searchObservable
.subscribeOn(Schedulers.newThread())
.subscribe(new Consumer<Item>(){
@Override
public void accept(@NonNull Item item) throws Exception {
//Do stuff with the item
}
}
, new Consumer<Exception>() { //some implementation of onErrorConsumer
}
//OnComplete
, new Action(){
@Override
public void run() throws Exception {
//When does this get called??? after the search complete or when the first http call is successful?
}
});
}
private Observable<String> getSearchResultKeys(SomeSearchEngine searchEngine, String someSearchWord)
{
return Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull final ObservableEmitter<String> emitter) throws Exception {
//Assume that our search engine call onFind everytime it finds something
searchEngine.addSearchListener(new searchEngineResultListener(){
@Override
public void onFind(String foundItemKey){
emitter.onNext(foundItemKey);
}
@Override
public void onFinishedFindingResults(){
emitter.onComplete();
}
});
}
});
}
private Observable<Item> getItemByKey(MyHttpCaller httpCaller, String key)
{
return Observable.create(new ObservableOnSubscribe<Item>() {
@Override
public void subscribe(@NonNull final ObservableEmitter<Item> emitter) throws Exception {
//Call the server to get the item
httpCaller.call(key, new onCompleteListener(){
@Override
public void onCompletedCall(Item result)
{
emitter.onNext(result);
//The result is complete! end the stream
emitter.onComplete();
}
});
}
});
}
public Observable<Item> getSearchResult(MyHttpCaller httpCaller, SomeSearchEngine searchEngine, String someSearchWord){
//Where everything comes together
Observable<String> searchResultObservable = getSearchResultKeys(searchEngine, someSearchWord);
retuern searchResultObservable
.observeOn(Schedulers.newThread())
.flatMap(new Function<String, Observable<Item>>(){
@Override
public Observable<Item> apply(String key){
return getItemByKey(httpCaller, key);
}
});
}
The onComplete()
always get call once and then the streams stops. onComplete()
总是被调用一次,然后流停止。 (this is part of the Observable Contract ). (这是可观察合同的一部分)。
That means that in your case, your onComplete()
at SomeMethodThatWantsItems
will be called after all items were retrieved. 这意味着,在您的情况下,将在检索所有项目后调用SomeMethodThatWantsItems
onComplete()
。
In case of flatMap()
, completion of each inner Observable
, simply will signal the source Observable
to stop flatting item from the inner Observable
to the source Observable
, flatMap()
merges items from the inner Observable
as long as this stream sends items, so it's basically consume the entire inner Observable
stream into the source stream, the entire stream is until termination event3 like onComplete()
, so in case where inner Observable
can emit more than 1 item, that means that it will make more than 1 emission on the source stream. 对于flatMap()
,每个内部Observable
完成将仅向信号Observable
发出信号,以停止将内部Observable
项目展平到源Observable
, flatMap()
合并内部Observable
项目,只要此流发送项目,则它基本上是将整个内部Observable
流消耗到源流中,整个流直到onEventlet onComplete()
类的终止事件3为止,因此,如果内部Observable
可以发出多于1个项目,则意味着它将在源流。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.