Question

我有2个可观测量。 1）同步订单（可完成）2）获取所有订单。我希望保持同步产品，直到我从后端获得所需的产品。这是每5分钟轮询后端5次以检索订单确认。

 apiService
.syncOrders()
.repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
        @Override
        public Observable<Integer> call(final Observable<? extends Void> observable) {
            // Retry 5 more times with 5 seconds delay
            return observable.delay(5, TimeUnit.SECONDS).zipWith(Observable.range(START_RETRY,
                                                                                  MAX_RETRIES),
                                                                 new Func2<Void, Integer, Integer>() {
                                                                     @DebugLog
                                                                     @Override
                                                                     public Integer call(Void v,
                                                                                         Integer integer) {
                                                                         return integer;
                                                                     }
                                                                 });
        }
    }).andThen(apiService.streamOrders().flatMap(new Func1<List<Order>, Observable<Order>>() {
        @Override
        public Observable<Order> call(List<Order> orderList) {
            return Observable.from(orderList);
        }
    }).filter(new Func1<Order, Boolean>() {
        @DebugLog
        @Override
        public Boolean call(Order order) {
            return order.orderRef() == orderId;
        }
    }).first());

Answer 1

重复正常完成的Completable永远不会触发andThen。你必须重新设计你的流程，例如运行一个带有5分钟周期的Observable.interval，将它的值平面映射到第一个可填充表格中，然后将其附加到内部流程中，例如：

Observable.interval(0, 5, TimeUnit.MINUTES)
.onBackpressureLatest()
.flatMap(tick -> 
     apiService.syncOrders()
     .andThen(apiService.streamOrders().flatMapIterable(list -> list))
     .retryWhen(error -> error.delay(5, TimeUnit.SECONDS))
)
.filter(v -> ...)
.subscribe(...);

重试可完成的观察

1 个答案: