RxJava：如何从Observable获取所有结果和错误

Question

我正在从事涉及Hystrix的项目，因此决定使用RxJava。 现在，将剩下的事情忘给Hystrix，因为我认为主要问题是我完全搞砸了正确编写Observable代码的问题。

需要：我需要一种返回表示多个可观察对象的可观察对象的方法，每个可观察对象都运行一个用户任务。 我希望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);
                }
            });
}

鉴于MyCommand是扩展HystrixObservableCommand的类，它返回一个Observable，因此不应弄清楚我所遇到的问题。

尝试1：

如上使用的Observable.flatMap

• 好：每个命令都在其自己的线程上调度，并且任务异步运行。
• 错误：在第一个Command异常上，Observable完成了发出先前成功的结果并发出Exception的过程。 任何运行中的命令都会被忽略。

尝试2：

使用了Observable.concatMapDelayError而不是flatMap

• 不好：由于某种原因，任务是同步运行的。 为什么？？
• 好：我得到了所有成功的结果。
• 〜Good ： OnError获取一个Composite异常，并抛出了一系列异常。

任何帮助将不胜感激，并且可能会导致我很尴尬，因为我自己没有想到它。

附加代码

该测试通过Observable.flatMap成功完成，但是在使用Observable.concatMapDelayError时失败，因为这些任务不是异步运行的：

java.lang.AssertionError：执行时间超过了350ms的限制：608

@Test
public void shouldRunManagedAsyncTasksConcurrently() throws Exception {
    Observable<String> testObserver = executor.observeManagedAsync("asyncThreadPool",getTimedTasks()); 
    TestSubscriber<String> testSubscriber = new TestSubscriber<>();
    long startTime = System.currentTimeMillis();
    testObserver.doOnError(throwable -> {
        System.out.println("error: " + throwable.getMessage());
    }).subscribe(testSubscriber);
    System.out.println("Test execution time: "+(System.currentTimeMillis()-startTime));
    testSubscriber.awaitTerminalEvent();
    long execTime = (System.currentTimeMillis()-startTime);
    System.out.println("Test execution time: "+execTime);
    testSubscriber.assertCompleted();
    System.out.println("Errors: "+testSubscriber.getOnErrorEvents());
    System.out.println("Results: "+testSubscriber.getOnNextEvents());
    testSubscriber.assertNoErrors();
    assertTrue("Execution time ran under the 300ms limit: "+execTime,execTime>=300);
    assertTrue("Execution time ran over the 350ms limit: "+execTime,execTime<=350);
    testSubscriber.assertValueCount(3);
    assertThat(testSubscriber.getOnNextEvents(),containsInAnyOrder("hello","wait","world"));
    verify(this.mockSchedulerFactory, times(3)).get("asyncThreadPool");
}

以上单元测试的任务：

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);
}

Answer 1

您可以使用Observable.onErrorReturn()并返回特殊值（例如null），然后在下游过滤非特殊值。 请记住，可观察到的源将在发生错误时完成。 另外，根据使用情况， Observable.onErrorResumeNext()方法也可能有用。 如果您对错误通知感兴趣，请使用Observable.materialize() ，它将把项目和onError() ， onComplete()转换为Notifications，然后可以通过Notification.getKind()进行过滤。

编辑 。 应该在.toObservable().subscribeOn(this.schedulerFactory.get(groupName));之后.toObservable().subscribeOn(this.schedulerFactory.get(groupName));添加上述所有运算符.toObservable().subscribeOn(this.schedulerFactory.get(groupName)); 假设没有尝试/捕获。

Answer 2

您要使用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);
            }
        }));
}

请注意，您的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);

}

请记住，这仍将最多调用一次onError 。 如果需要显式处理所有错误，请使用Either<CommandResult, Throwable>之类的类型作为返回类型（或处理错误并返回一个空的observable）。

Answer 3

使用.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();
            }
        });