如何在RxJava中創建可觀察者和觀察者？

Question

我有一個無效的偵聽功能，可以偵聽服務器推送的數據。 我需要創建一個可觀察和觀察者，以便我可以使用onNext，onComplete和onError處理數據。

Answer 1

您可能想研究使用BehaviourSubject

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();
    }

}