RxJava：如何从一个可观察对象获取所有结果和错误

我正在从事一个涉及Hystrix的项目，我决定使用RxJava。现在，在剩下的时间里，忘记Hystrix吧，因为我认为主要的问题是我完全搞砸了如何正确地编写可观察的代码

需要： 我需要一种方法来返回一个表示多个可观察对象的可观察对象，每个可观察对象运行一个用户任务。我希望Observable能够返回任务的所有结果，甚至错误

问题： 可观察到的流因错误而消亡。如果我有三个任务，而第二个任务抛出了一个异常，那么即使第三个任务成功了，我也不会收到它

我的代码：

public <T> Observable<T> observeManagedAsync(String groupName,List<EspTask<T>> tasks) {
    return Observable
            .from(tasks)
            .flatMap(task -> {
                try {
                    return new MyCommand(task.getTaskId(),groupName,task).toObservable().subscribeOn(this.schedulerFactory.get(groupName));
                } catch(Exception ex) {
                    return Observable.error(ex);
                }
            });
}

上述单元测试的任务：

protected List<EspTask<String>> getTimedTasks() {
    EspTask longTask = new EspTask("helloTask") {
        @Override
        public Object doCall() throws Exception {
            Thread.currentThread().sleep(100);
            return "hello";
        }
    };
    EspTask longerTask = new EspTask("waitTask") {
        @Override
        public Object doCall() throws Exception {
            Thread.currentThread().sleep(150);
            return "wait";
        }

    };
    EspTask longestTask = new EspTask("worldTask") {
        @Override
        public Object doCall() throws Exception {
            Thread.currentThread().sleep(300);
            return "world";
        }
    };
    return Arrays.asList(longTask, longerTask, longestTask);
}

受保护列表getTimedTasks（）{
EspTask longTask=新EspTask（“helloTask”）{
@凌驾
公共对象doCall（）引发异常{
Thread.currentThread（）.sleep（100）；
回复“你好”；
}
};
EspTask longerTask=新EspTask（“等待任务”）{
@凌驾
公共对象doCall（）引发异常{
Thread.currentThread（）.sleep（150）；
返回“等待”；
}
};
EspTask longestTask=新EspTask（“worldTask”）{
@凌驾
公共对象doCall（）引发异常{
Thread.currentThread（）.sleep（300）；
回归“世界”；
}
};
返回Arrays.asList（longTask、longerTask、longestask）；
}

您可以使用

Observable.onErrorReturn（）

，返回特殊值（例如null），然后过滤下游的非特殊值。请记住，SourceObservable将在出错时完成。还取决于用例

可观察。onErrorResumeNext（）

方法也可能有用。如果您对错误通知感兴趣，请使用

Observable.materialize（）

，这将把项目和

onError（）

，

onComplete（）

转换为通知，然后可以通过

Notification.getKind（）

编辑。

---

上面提到的所有操作符都应该添加到

.toObservable（）.subscribeOn（this.schedulerFactory.get（groupName））之后假设try/catch不存在
 您可以使用
Observable.onErrorReturn（）
，返回特殊值（例如null），然后过滤下游的非特殊值。请记住，SourceObservable将在出错时完成。还取决于用例
可观察。onErrorResumeNext（）
方法也可能有用。如果您对错误通知感兴趣，请使用
Observable.materialize（）
，这将把项目和
onError（）
，
onComplete（）
转换为通知，然后可以通过
Notification.getKind（）

编辑。
上面提到的所有操作符都应该添加到
.toObservable（）.subscribeOn（this.schedulerFactory.get（groupName））之后假设try/catch不存在
 您想使用
mergeDelayError
：

public <T> Observable<T> observeManagedAsync(String groupName,List<EspTask<T>> tasks) {
    return Observable.mergeDelayError(Observable
        .from(tasks)
        .map(task -> {
            try {
                return new MyCommand(task.getTaskId(),groupName,task).toObservable().subscribeOn(this.schedulerFactory.get(groupName));
            } catch(Exception ex) {
                return Observable.error(ex);
            }
        }));
}

public observeManagedAsync（字符串组名，列出任务）{
返回可观察。合并延迟错误（可观察
.来自（任务）
.map（任务->{
试一试{
返回新的MyCommand（task.getTaskId（），groupName，task）.toObservable（）.subscribeOn（this.schedulerFactory.get（groupName））；
}捕获（例外情况除外）{
返回可观测误差（ex）；
}
}));
}

请注意，MyCommand构造函数不应抛出任何异常；这样可以更简洁地编写代码：

public <T> Observable<T> observeManagedAsync(String groupName,List<EspTask<T>> tasks) {
    return from(tasks)
           .map(task -> new MyCommand(task.getTaskId(), groupName, task)
                        .toObservable()
                        .subscribeOn(this.schedulerFactory.get(groupName)))
           .compose(Observable::mergeDelayError);

public observeManagedAsync（字符串组名，列出任务）{
从（任务）返回
.map（任务->新建MyCommand（任务.getTaskId（），组名，任务）
.TooObservable（）文件
.subscribeOn（this.schedulerFactory.get（groupName）））
.compose（可观察：：合并延迟错误）；

}

请记住，这最多只能调用一次
onError
；如果您需要显式处理所有错误，请使用类似于
的内容作为返回类型（或处理错误并返回空的可观察值）。
您希望使用
mergeDelayError
：

public <T> Observable<T> observeManagedAsync(String groupName,List<EspTask<T>> tasks) {
    return Observable.mergeDelayError(Observable
        .from(tasks)
        .map(task -> {
            try {
                return new MyCommand(task.getTaskId(),groupName,task).toObservable().subscribeOn(this.schedulerFactory.get(groupName));
            } catch(Exception ex) {
                return Observable.error(ex);
            }
        }));
}

public observeManagedAsync（字符串组名，列出任务）{
返回可观察。合并延迟错误（可观察
.来自（任务）
.map（任务->{
试一试{
返回新的MyCommand（task.getTaskId（），groupName，task）.toObservable（）.subscribeOn（this.schedulerFactory.get（groupName））；
}捕获（例外情况除外）{
返回可观测误差（ex）；
}
}));
}

请注意，MyCommand构造函数不应抛出任何异常；这样可以更简洁地编写代码：

public <T> Observable<T> observeManagedAsync(String groupName,List<EspTask<T>> tasks) {
    return from(tasks)
           .map(task -> new MyCommand(task.getTaskId(), groupName, task)
                        .toObservable()
                        .subscribeOn(this.schedulerFactory.get(groupName)))
           .compose(Observable::mergeDelayError);

public observeManagedAsync（字符串组名，列出任务）{
从（任务）返回
.map（任务->新建MyCommand（任务.getTaskId（），组名，任务）
.TooObservable（）文件
.subscribeOn（this.schedulerFactory.get（groupName）））
.compose（可观察：：合并延迟错误）；

}

请记住，这最多只能调用一次
onError
；如果您需要显式处理所有错误，请使用
或
作为返回类型（或处理错误并返回空的可观测值）。
使用
.materialize（）
允许所有发射和错误以包装通知的形式发送，然后根据您的意愿处理它们：

     .flatMap(task -> {
            try {
                return new MyCommand(task.getTaskId(),groupName,task)
                    .toObservable()
                    .subscribeOn(this.schedulerFactory.get(groupName))
                    .materialize();
            } catch(Exception ex) {
                return Observable.error(ex).materialize();
            }
        });

使用
.materialize（）
允许所有排放和错误以包装通知的形式通过，然后按照您的意愿处理它们：

     .flatMap(task -> {
            try {
                return new MyCommand(task.getTaskId(),groupName,task)
                    .toObservable()
                    .subscribeOn(this.schedulerFactory.get(groupName))
                    .materialize();
            } catch(Exception ex) {
                return Observable.error(ex).materialize();
            }
        });