Question

我试图通过实现RxJava来进行异步休息调用。以下是实施 -

final Observable<List<A>> observableA = Observable.create(new Observable.OnSubscribe<List<A>>() {
    @Override
    public void call(Subscriber<? super List<A>> subscriber) {
        try {
            if (!subscriber.isUnsubscribed()) {
                subscriber.onNext(//another Function call);
                subscriber.onCompleted();
            }
        } catch (Exception e) {
            subscriber.onError(e);
        }
    }
});

final Observable<List<B>> observableB = Observable.create(new Observable.OnSubscribe<List<B>>() {
    @Override
    public void call(Subscriber<? super List<B>> subscriber) {
        try {
            if (!subscriber.isUnsubscribed()) {
                subscriber.onNext(//another Function call);
                subscriber.onCompleted();
            }
        } catch (Exception e) {
            subscriber.onError(e);
        }
    }
});


Observable<List<C>> reservationObserv = Observable.zip(observableA, observableB, new Func2< List<A>, List<B> ,  List<C>>() {
    @Override
    public List<C> call(final List<A> a, final List<B> b) {
        // Merge the response
        return c;
    }
});

截至目前，ObservableA首先被执行，然后是ObservableB。任何人都可以建议为什么调用不是异步的。

提前致谢。

当我按以下方式执行时，首先执行observableB，然后执行ObservableA

final Observable<List<A>> observableA = Observable.create(new  Observable.OnSubscribe<List<A>>() {

@Override
public void call(final Subscriber<? super List<A>> subscriber) {
    Runnable run = new Runnable() {
        @Override
        public void run() {
            // Delay of 1000ms
            subscriber.onNext(//calling a method);
            subscriber.onCompleted();
        }
    };
    executorService.execute(run);
}
});

final Observable<List<B>> observableB = Observable.create(new Observable.OnSubscribe<List<B>>() {

@Override
public void call(final Subscriber<? super List<B>> subscriber) {
    Runnable run = new Runnable() {
        @Override
        public void run() {
            // No delay
            subscriber.onNext(//calling a method);
            subscriber.onCompleted();
        }
    };
    executorService.execute(run);
}
});


Observable<List<C>> observableC = Observable.zip(observableA, observableB, new Func2< List<A>, List<B> ,  List<C>>() {
@Override
public List<C> call(final List<A> a, final List<B> b) {
    // Merge the response
    return c;
}
});

Answer 1

默认情况下，RxJava是同步的。因此，在您的第一种情况下，zip运算符将订阅observableA，然后，当observableA完成时，将订阅observableB。

在第二种情况下，当您使用执行程序服务时，您实际上是异步的。

要与您的第一个版本保持同步，因为它在评论中已经过时了，您应该查看Schedulers并告诉RxJava您的订阅应该执行哪些schdeulers。

Observable<List<C>> observableC = Observable.zip(
                   observableA.subscribeOn(Schedulers.io()),
                   observableB.subscribeOn(Schedulers.io()),
                   (a, b) -> /** ... **/);
observableC.subscribe();

您可以使用不同的计划程序，具体取决于您希望获得的内容。（对I / O使用Schedulers.io（），...）

使用RxJava -Observables进行异步调用

1 个答案: