Question

我有一个observable订阅了Observable，我不能保证服务可以继续，直到我发出第一个项目。

所以我创建了一个阻止操作的未来，直到发出第一个操作。问题是，因为如果我是正确的，间隔用户永远不会取消订阅，所以操作永远不会结束。所以这意味着future.complete将在每个时间间隔执行

public static Future<Void> initialize(Scheduler scheduler) {
    Future<Void> future = Future.future();
    if (observable == null) {
        observable = getProductsObservable();
        observable.subscribeOn(scheduler);
        observable.subscribe(newProducts -> {
            future.complete();
            products.clear();
            products.addAll(newProducts);
        });
    }
    return future;
}

private static Observable<List<String>> getProductsObservable() {
    return Observable.interval(0, 24, TimeUnit.HOURS)
            .doOnNext(time -> log.info("New job run at {}", new Date(time)))
            .map(time -> getProducts());
}

也许间隔不是Cron工作的最佳选择。

我的问题是，如何确定区间是否第一次发射。只需要做一次future.complete（）。

编辑：

我最终使用ReplySubject来共享两个observable之间的项目。但仍然不相信，因为我需要使用first（）以便在我收到为其他可观察者发出的第一个项目后取消订阅我的主题。

   public static synchronized Single<String> initialize(Scheduler scheduler, ProductClient productClient) {
        if (discountableSubject == null) {
            discountableSubject = ReplaySubject.create(1);
            getProductsObservable(scheduler, productClient)
                    .map(newProducts -> products = newProducts)
                    .map(products -> "done")
                    .subscribe(discountableSubject);
        }
        return getFirstElementAndUnsubscribe(scheduler).toSingle();
    }

    private static Observable<String> getFirstElementAndUnsubscribe(Scheduler scheduler) {
        return discountableSubject.observeOn(scheduler).first();
    }

    private static Observable<List<String>> getProductsObservable(Scheduler scheduler, ProductClient productClient) {
        return Observable.interval(0, 24, TimeUnit.HOURS, scheduler)
                .doOnNext(time -> log.info("New job run at {}", new Date(time)))
                .map(time -> getProducts(productClient));
    }

如果有人有更好的选择，请告诉我。

只获取Interval发出的第一个项目

0 个答案: