Question

在RxJava中订阅一个在未知时间不断接收来自不同来源的事件的观察者的正确方法。

例如：假设我们有从服务器接收的任务，并且可以从许多不同的区域启动对服务器的调用（例如，通过推送通知，轮询事件，用户交互等）。

我们唯一关心用户界面的是我们收到已收到任务的通知。我们不关心他们来自哪里。我实际上想要开始观察Activity的生命，并且模型根据需要更新观察者

我已经实现了下面的类，它做了我想要的，但我不确定它是否正确，或者RxJava是否已经考虑过这样的事情。

此类有效创建ConnectableObservable，可以让许多观察者订阅一个Observable（确保所有观察者获得相同的流）。我注意到的一件事是调用observeOn和subscribeOn会以这种方式订阅ConnectableObservable时会导致意外结果，这可能是一个问题，因为类无法控制谁在使用ConnectableObservable。

public class ApiService {

private Emitter<String> myEmitter;
private ConnectableObservable myObservable;

public ApiService() {
    //Create an observable that is simply used to get the emitter.
    myObservable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            myEmitter = e;
        }
    }).publish();
    //connect must be called here to ensure we have an instance of the emitter
    // before we have any subscribers
    myObservable.connect();

}

/**
 * This method returns the observable that all observers will subscribe to
 *
 * @return
 */
public Observable<String> getObservable() {
    return myObservable;
}

/**
 * This method is used to simulate a value that has been received from
 * an unknown source
 *
 * @param value
 */
public void run(final String value) {
    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            myEmitter.onNext(value);
            //api call
        }
    }).subscribe();
}

}

我也很好奇是否有任何关于内存泄漏的问题这样做，假设订阅一个观察者的每个观察者都在适当的时候被处理掉。

在看到Bob的回答后，这是重构的课程

public class ApiService {

private PublishProcessor<String> myProcessor = PublishProcessor.create();

public void subscribe(Subscriber<String> subscriber) {
    myProcessor.subscribe(subscriber);
}

/**
 * This method is used to simulate a value that has been received from
 * an unknown source
 *
 * @param value
 */
public void run(final String value) {
    myProcessor.onNext(value);
}

}

Answer 1

使用Subject（RxJava）或Processor（RxJava 2）进行订阅。然后，您可以将主题订阅到每个可观察源。最后，您将订阅该主题并获得合并的排放流。

或者，您可以使用Relay将下游观察者与可能来自上游的任何onComplete()或onError()隔离开来。当任何可观察者可能在其他观察者之前完成时，这是一个更好的选择。

RXjava连续的数据流

1 个答案: