我是RxJava的新手,无法弄清楚如何使用ConnectableObservable实现可重复的轮询,由2个订阅者在不同线程上处理事件。
我有一个大致如下的管道:
我想在延迟后重复整个管道,其方式类似于https://github.com/ReactiveX/RxJava/issues/448
的解决方案Observable.fromCallable(() -> pollValue())
.repeatWhen(o -> o.concatMap(v -> Observable.timer(20, TimeUnit.SECONDS)));
或Dynamic delay value with repeatWhen()。
这对于普通(不可连接)的Observable可以正常工作,但对于多播则不能。
代码示例:
作品
final int[] i = {0};
Observable<Integer> integerObservable =
Observable.defer(() -> Observable.fromArray(i[0]++, i[0]++, i[0]++));
integerObservable
.observeOn(Schedulers.newThread())
.collect(StringBuilder::new, (sb, x) -> sb.append(x).append(","))
.map(StringBuilder::toString)
.toObservable().repeatWhen(o -> o.concatMap(v -> Observable.timer(1, TimeUnit.SECONDS)))
.subscribe(System.out::println);
不起作用:
final int[] i = {0};
ConnectableObservable<Integer> integerObservable =
Observable.defer(() -> Observable.fromArray(i[0]++, i[0]++, i[0]++))
.publish();
integerObservable.observeOn(Schedulers.newThread()).subscribe(System.out::println);
integerObservable
.observeOn(Schedulers.newThread())
.collect(StringBuilder::new, (sb, x) -> sb.append(x).append(","))
.map(StringBuilder::toString)
.toObservable().repeatWhen(o -> o.concatMap(v -> Observable.timer(1, TimeUnit.SECONDS)))
.subscribe(System.out::println);
integerObservable.connect();
答案 0 :(得分:1)
第二个示例中的问题不在多播中。它在collect运算符中,然后重复when。
考虑重复当您像“钩子”时,您将连接到onComplete方法。这个“钩子”将拦截onComplete方法并“覆盖”它,因此除非在开始重复过程之前此可观察对象第一次完成,否则将不会调用它。
没有一个名为collect的onComplete方法,它不知道应该收集多少个项目。因此,您将不得不处理如何收集项目以及在流外部将其存储在何处的逻辑,但这是一种解决方法。
这是一个例子:
List<String> test = new ArrayList<>();
final String[] currentString = {""};
final int[] i = {0};
ConnectableObservable<Integer> integerObservable =
Observable.defer(() -> Observable.fromArray(i[0]++, i[0]++, i[0]++))
.doOnComplete(() -> {
test.add(currentString[0]);
currentString[0] = "";
})
.repeatWhen(o -> {
return o.concatMap(v ->
Observable.timer(3, TimeUnit.SECONDS)
.doOnComplete(() -> {
test.add(currentString[0]);
currentString[0] = "";
}));
})
.publish();
integerObservable
.observeOn(Schedulers.newThread())
.subscribe(System.out::println);
integerObservable
.observeOn(Schedulers.newThread())
.map((sa) -> {
currentString[0] = currentString[0] + sa;
System.out.println(currentString[0]);
return sa;
})
.subscribe();
在此示例中,我们使用可观察的onComplete方法,我们持有计时器以重置状态。当使用者使用数据的速度比重复使用的延迟慢时,此示例未考虑该选项(这将导致从一个数据链到另一个数据链的结果溢出)。我建议使用其他方式来处理重复部分,例如:
final int [] i = {0};
ConnectableObservable<Integer> integerObservable =
Observable.defer(() -> Observable.fromArray(i[0]++, i[0]++, i[0]++)).publish();
Observable b = integerObservable.observeOn(Schedulers.newThread());
Observable a = integerObservable
.observeOn(Schedulers.newThread())
.collect(StringBuilder::new, (sb, x) -> sb.append(x).append(","))
.map(StringBuilder::toString)
.toObservable();
Observable
.interval(1, TimeUnit.SECONDS)
.doOnSubscribe((d) -> {
a.subscribe(System.out::println);
b.subscribe(System.out::println);
integerObservable.connect();
})
.doOnNext((d) -> {
a.subscribe(System.out::println);
b.subscribe(System.out::println);
integerObservable.connect();
})
.doOnComplete(() -> {})
.subscribe();
第一次连接是第一次执行,onNext每1秒调用一次,它从头开始重新启动整个管道。
希望这会有所帮助。
答案 1 :(得分:0)
仍然不清楚这是否是您所要的,但这也许会对您有所帮助
Observable<Integer> integerObservable1;
@Override
public void run(String... args) throws Exception {
Integer[] integers = {1, 2, 3};
Observable<Integer> integerObservable = Observable.fromArray(integers);
integerObservable1 = Observable.zip(integerObservable.observeOn(Schedulers.newThread()).delay(100, TimeUnit.MILLISECONDS), integerObservable.observeOn(Schedulers.newThread()).delay(200, TimeUnit.MILLISECONDS), (integer, integer2) -> {
System.out.println(integer + " " + integer2);
return integer;
})
.doOnComplete(() -> {
integerObservable1.subscribe();
});
integerObservable1.subscribe();
}