RxJava平面圖：當其中一個可觀測的完整對象完成時會發生什么？

Question

我是RxJava的新手，我知道平面地圖用於將發射的項目映射到可觀察的項目。 我也知道，根據文檔 ，所有發出的可觀察變量都將合並（拼合）為單個可觀察流。

我想知道如果這些內在可觀測值中的任何一個完成，會發生什么？

例如：我有一個可觀察到的發射項目數據鍵。 我必須進行另一個異步http調用才能從服務器獲取項目數據，因此我通過使用另一個可觀察的對象來調用它。 我使用平面地圖將這兩者連接起來，並創建一個主要的可觀察對象。

以下“ 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);
                }
            });
}

Answer 1

onComplete()總是被調用一次，然后流停止。 （這是可觀察合同的一部分）。
這意味着，在您的情況下，將在檢索所有項目后調用SomeMethodThatWantsItems onComplete() 。
對於flatMap() ，每個內部Observable完成將僅向信號Observable發出信號，以停止將內部Observable項目展平到源Observable ， flatMap()合並內部Observable項目，只要此流發送項目，則它基本上是將整個內部Observable流消耗到源流中，整個流直到onEventlet onComplete()類的終止事件3為止，因此，如果內部Observable可以發出多於1個項目，則意味着它將在源流。