Question

我有一个侦听服务器推送数据的void listen函数。我需要创建一个observable和observer，这样我就可以使用onNext，onComplete和onError来处理数据。

Answer 1

private final BehaviorSubject<YourImmutableDataClass> mServerObservable = BehaviorSubject.create();

private void update(YourImmutableDataClass next) {
    mServerObservable.onNext(next);
}

public Observable<YourImmutableDataClass> observe() {
    return mServerObservable.distinctUntilChanged();
}

Answer 2

下面是一些粗略的猜测。

如果你试图通过无限流来管道，rxjava 1.x并不能解决背压问题，但是Rxjava2有一个更好的Observable.create（.. target）你可能有你的listen（）实现调用目标的onnext / onerror / oncomplete。

当然，当订阅者取消订阅（如果有）以便可以删除侦听器时，需要添加许多代码。但这是一个开始。

演示可能解决方案的要素：

小心：这不是防弹代码，监听器列表不是线程安全的。我现在只是保持清醒。

package tests.rxjava2;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

import io.reactivex.Observable;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

public class TestRxjava2Basics {

    static void p(Object msg) {
        System.out.println(Thread.currentThread().getName()+"]: "+msg);
    }

    static void w(long delay) {
        try {
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        List<Consumer<String>> listeners = new ArrayList<>(); //NOT THREADSAFE!!!!!
        Consumer<String> c1 = s -> p("consumer permanent: "+s);
        listeners.add(c1);

        Thread machinegun = new Thread(() -> {
            while(!Thread.interrupted()) {
                listeners.forEach(c -> c.accept(""+System.currentTimeMillis()));
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    break;
                }
            }
        }, "gun");

        machinegun.start();

//      for(int i=0; i<5; i++) {
//          final int fi = i;
//          Consumer<String> c = s -> p("consumer adapter "+fi+": "+s);
//          listeners.add(c);
//          Thread.sleep(1000);
//          
//          listeners.remove(c);
//          Thread.sleep(1000);
//      }

        //equivalent in RX:
        for(int i=0; i<5; i++) {
            final int fi = i;
            Disposable disp = Observable.create(tgt -> {
                    Consumer<String> c = s -> {
                        p("consumer adapter "+fi+": "+s);
                        tgt.onNext(s);
                    };
                    tgt.setCancellable(() -> {
                        p("cancelling consumer adapter "+fi);
                        listeners.remove(c);
                    });
                    listeners.add(c);
                })
                .doOnNext(s -> p("onnext "+fi+": "+s))
                .subscribe();

            Thread.sleep(1000);

            disp.dispose();
            Thread.sleep(1000);
        }

        machinegun.interrupt();
    }

}

如何在RxJava中创建一个observable和observer？

2 个答案: