Question

我发现我有一个共同的机制，我想知道是否有更好的方法来实现它或另一种方式。

我想在订阅Observable时发出网络请求，我希望它“刷新” - 每次发生某些事件时再次请求，因此可观察性将变为无限。

例如，假设我有一个请求getScreenData（）所以当我打开屏幕时我会调用它，但如果有一个事件，如relogin和needRefresh，我希望它再次发出请求。

我想出的是：

Merge(onRelogin().map(a-> null),onNeedRefresh().map(r -> null)).switchMap(o->getData()).startWith(getData);

我不太喜欢它，因为我需要将所有这些事件映射到某个对象，因此我将能够合并它们（我不关心值...）并且我需要编写getData （）两次用于开关和startWith得到我想要的东西。

那么有更好的方法来实现这一目标吗？和其他运营商一样，我会这样做。你将如何制造变压器呢？所以你会在没有重复的情况下得到那种模式，请不要听我们想要再次提出请求的那么多可观察数据。

编辑：Observable.merge（）可以返回Observable，从而解决了对map

的需求

Answer 1

使用repeatWhen运算符。

Observable
    .fromCallable(() -> getScreenData())
    .repeatWhen(it -> it.mergeWith(whenToRepeat))
    .subscribe()

whenToRepeat是一个可观察的东西，通过发出任何东西来触发重复。

repeatWhen运算符here的进一步说明。

Answer 2

我最终制作了一个变压器：

public static class SwitchWhen<T> implements Transformer<T,T> {


    private final Observable<?>[] observables;

    public static <K> SwitchWhen<K> create(Observable<?>...observables){
        return new SwitchWhen<>(observables);
    }

    public SwitchWhen(Observable<?>[] observables) {
        this.observables = observables;

    }

    @Override
    public Observable<T> call(Observable<T> tObservable) {
        return Observable.merge(observables).switchMap(o -> tObservable).startWith(tObservable);
    }
}

public static <T> SwitchWhen<T> switchWhen(Observable<?>...observables){
    return SwitchWhen.create(observables);
}

你可以像这样使用它：

getData().compose(switchWhen(onRelogin(),onNeedRefresh());

它会在你订阅它时发出请求，并且每次在交换机中发出一个项目的那些observable时，它使用switchMap意味着它会丢弃旧的请求，重要的是它还没有到达所以回收的流将保证有序。

RxJava - 发出请求，然后在每次事件发生时请求

2 个答案: