Question

我有3个Observable，第二个observable需要第一个observable的输出。并且第三个可观察者需要第一个和第二个可观察者的输出。

    Observable<String> observableOne = Observable
        .just("{1}")
        .map(v -> {
            System.out.println("Executing Observable 1");
            return v;
        });

    Observable<String> observableTwo = observableOne
        .map(observableOneValue -> {
            System.out.println("Executing Observable 2");
            return "{2"+observableOneValue+"}";
        });

    Observable.zip(
        observableOne,
        observableTwo,
        (observableOneValue, observableTwoValue) ->
        {
            System.out.println("Executing Observable 3");
            return "{3"+observableOneValue+observableTwoValue+"}";
        }
    ).blockingSubscribe(System.out::println);

这重复执行第一个observable，我当然可以使第一个observable可缓存。但我想知道是否有比这更好的选择，特别是我正在寻找从第一个到另外两个可观察者的某种消息传递构造

Answer 1

我不确定你正在通过“消息传递构造”寻找什么。 cache将适用于您上面的示例，但您提到您不想使用它。

可能适合您的用例的另一个选项是使用ConnectableObservable。它只会在您调用connect时开始发出项目，而不是在订阅时。通过致电observableOne将您的ConnectableObservable转换为publish。然后设置所有订阅者。然后在connect上致电observableOne。

ConnectableObservable<String> observableOne = Observable
        .just("{1}")
        .map(v -> {
          System.out.println("Executing Observable 1");
          return v;
        }).publish();

    Observable<String> observableTwo = observableOne
        .map(observableOneValue -> {
          System.out.println("Executing Observable 2");
          return "{2"+observableOneValue+"}";
        });

    Observable.zip(
        observableOne,
        observableTwo,
        (observableOneValue, observableTwoValue) ->
        {
          System.out.println("Executing Observable 3");
          return "{3"+observableOneValue+observableTwoValue+"}";
        }
    ).subscribe(System.out::println);

    // Call when all the subscribers are ready --
    observableOne.connect();

备注

observableOne现在是ConnectableObservable
需要使用subscribe代替blockingSubscribe，因此代码将执行connect调用。

RX-java2重复使用一个Observable

1 个答案: