Java Observable merge（）检测触发哪个可观察对象

我正在使用一个值列表创建一个

可观察的

列表，每个值都是一个自定义的

可观察的

。我使用merge运行它们，但我无法检测哪一个触发了

onNext（）

或

onError（）

如下面的代码所示：

 List<Observable<MyHttpRsObj>> observables = new ArrayList<>();

    for (String param : paramsList) {
        Observable<MyHttpRsObj> objObservable = MyRestClient.get().doHttpRequest(param);
        observables.add(fileUploadObservable);
    }

    Observable<BaseRs> combinedObservables = Observable.merge(observables);

    combinedObservables.observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe(new Subscriber<MyHttpRsObj>() {
                @Override
                public void onCompleted() {
                    //called only once when all Observables finished
                }

                @Override
                public void onError(Throwable throwable) {
                    //how to know which Observable has error (which param)
                }


                @Override
                public void onNext(MyHttpRsObj myHttpRsObj) {
                    //how to know which Observable has sccess  (which param)
                }
            });

List observates=new ArrayList（）；
for（字符串参数：paramsList）{
obobjobservable=MyRestClient.get（）.doHttpRequest（param）；
添加（fileUploadObservable）；
}
可观测组合可观测=可观测。合并（可观测）；
组合的observables.observeOn（AndroidSchedulers.mainThread（））
.subscribeOn（Schedulers.io（））
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
//仅在所有可观察对象完成时调用一次
}
@凌驾
公共作废登记员（可丢弃）{
//如何知道哪个可观察对象有错误（哪个参数）
}
@凌驾
公共void onNext（MyHttpSobj MyHttpSobj）{
//如何知道哪个可观察对象有SCESS（哪个参数）
}
});

不可能知道是哪个obsevable触发了错误，因为您将所有obsevable合并到一个obsevable中

最好的办法是对每个可观察对象使用一个观察者。最后一个是合并的可观察的

像这样：

 List<Observable<MyHttpRsObj>> observables = new ArrayList<>();

    for (String param : paramsList) {
        //change to connectable Observable
        ConnectableObservable<MyHttpRsObj> objObservable = MyRestClient.get()
                 .doHttpRequest(param)
                 .publish();

       //don't forget to connect
        observable.connect();
        observables.add(fileUploadObservable);

        //subscribe for each observable
        objObservable.observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Subscriber<MyHttpRsObj>() {
                    @Override
                    public void onCompleted() {
                        //just partial completed
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        //you can access param from here

                    }


                    @Override
                    public void onNext(MyHttpRsObj myHttpRsObj) {
                        //access onNext here
                        //you can access param from here
                    }
                });
    }

    Observable<BaseRs> combinedObservables = Observable.merge(observables);

    combinedObservables.observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe(new Subscriber<MyHttpRsObj>() {
                @Override
                public void onCompleted() {
                    //called only once when all Observables finished
                }

                @Override
                public void onError(Throwable throwable) {
                    //don't handle error here
                }


                @Override
                public void onNext(MyHttpRsObj myHttpRsObj) {

                }
            });

List observates=new ArrayList（）；
for（字符串参数：paramsList）{
//更改为可连接可观察
ConnectableObservable objObservable=MyRestClient.get（）
.doHttpRequest（参数）
.publish（）；
//别忘了联系
连接（）；
添加（fileUploadObservable）；
//订阅每个可观察到的
objObservable.observeOn（AndroidSchedulers.mainThread（））
.subscribeOn（Schedulers.io（））
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
//刚刚部分完成
}
@凌驾
公共作废登记员（可丢弃）{
//您可以从这里访问param
}
@凌驾
公共void onNext（MyHttpSobj MyHttpSobj）{
//进入下一页
//您可以从这里访问param
}
});
}
可观测组合可观测=可观测。合并（可观测）；
组合的observables.observeOn（AndroidSchedulers.mainThread（））
.subscribeOn（Schedulers.io（））
.subscribe（新订户（）{
@凌驾
未完成的公共无效（）{
//仅在所有可观察对象完成时调用一次
}
@凌驾
公共作废登记员（可丢弃）{
//不要在这里处理错误
}
@凌驾
公共void onNext（MyHttpSobj MyHttpSobj）{
}
});

---

PS：用于避免发出两次

否，此方法只需执行每个请求两次！这里没有来自

merge（）

的原因。在每个可观察的未来表单

doHttpRequest

中，do错误获取异常，并用自定义异常包装它，该异常内部也有一个

param

。至于成功，您可以使用相同的技巧，但是使用map，并在内部返回

MyHttpRsObj

和

param

。