Question

我有一堆observables，我正在一个方法中运行/订阅（准确地说大约是9），它本身返回一个observable。为了这个问题，我把它缩小到2个可观测量。这是我创建的方法，它返回一个包含其他observable的Observable。

public static Observable<MyCustomObject> runAll(Service networkService) {
        return Observable.create(subscriber -> {

            networkService.getOne().subscribe(response -> {
                Request request = response.raw().request();
                MyCustomObject case = new MyCustomObject(request);
                subscriber.onNext(case);
            }, exception -> {
                throw new OnErrorNotImplementedException(exception);
            });


            networkService.getTwo().subscribe(response -> {
                Request request = response.raw().request();
                MyCustomObject case = new MyCustomObject(request);
                subscriber.onNext(case);
            }, exception -> {
                throw new OnErrorNotImplementedException(exception);
            });

            subscriber.onComplete();
        });
    }

然后我使用已返回的Observable ......

       runAll(networkService)
.subscribeOn(Schedulers.io())
.subscribe(case -> {
           //do stuff

        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //handle error
            }
        });

我不确定我是否正确创建了一个observable。我实际上是用Observable替换了之前的侦听器/接口，但我知道使用Observable.create（）是不容易的。我应该用另一种方式吗？做我正在做的事情有什么不对吗？

编辑：getOne（）和getTwo（）是网络调用，因此它们返回Observables。

编辑2：目前有这个

public static Observable<MyCustomObject> quickRun(Service networkService) {
    return Observable.concat(
            networkService.getOne().map(response -> {
                Request request = response.raw().request();
                MyCustomObject case = new MyCustomObject(request);
                return case;
            }),
            networkService.getTwo().map(response -> {
                Request request = response.raw().request();
                MyCustomObject case = new MyCustomObject(request);
                return case;
            })
    );
}

Answer 1

是的，你应该以不同的方式做到这一点每当你像对待常规的异步回调一样对待Observable时，这种气味就是你没有表现出“反应性”。正如你所说Observable.create()是非常重要的方式，有一些创建Observable的陷阱，可以说，你可能使用旧版本的RxJava 1，更新版本（我认为是1.3+），而使用RxJava2，create是基于在发射器上，更安全。你可以阅读here关于Create和发射器方法的缺陷。（作为RxJava2的旁注，有另一种方式extending Observable）。

所有这些方法都是在异步回调世界与Reactive world之间架起桥梁，并将其与Observable包装在任何类型的异步操作中。

至于你的情况，因为你已经掌握了Observables，你需要的是将它们组合成单个流 - Observable。 Rx有很多运算符用于此目的，根据您的示例Observable.merge似乎是合适的运算符，所有Observable都将异步运行（注意，您需要向它们中的每一个应用IO调度程序）），并且每个Observable将在合并流上发出其结果，当所有Observable都将完成时 - onCompleted将在合并的Observable上被调用，这在你的例子中是错误的，因为它是在你开始完成所有任务之后，就在一开始就打电话。

Observable.merge(
        networkService.getOne()
                .subscribeOn(Schedulers.io()),
        networkService.getTwo()
                .subscribeOn(Schedulers.io())
)
        .map(response -> {
            Request request = response.raw().request();
            return new MyCustomObject(request);
        })
        .subscribe(customObject -> {
                    //do stuff
                }, throwable -> {
                    //handle error
                }
        );

使用多个observable来创建一个可观察的？

1 个答案: