Java 将可观测转换为可观测值/绑定/事件流的最有效方法？

我将更频繁地使用RxJava和ReactFX，但我试图理解的是如何协调这两种语言，因为ReactFX没有RxJava依赖关系，所以这两种语言如何在同一个monad中相互对话？在JavaFX的

observeValue

、RxJava的

observeable

和ReactFX的

StreamEvent

之间架桥时，尤其如此，因为它们没有太多的样板文件

我想用RxJava编写我的核心业务逻辑，因为它们并不总是支持JavaFX应用程序。但是我希望JavaFXUI使用

ReactFX

并使用

EventStream

。因此，我的问题是，将

事件流

转化为

可观察的

，将

可观察的

转化为

事件流

，

绑定

，或

可观察值

，最有效的方法是什么？我知道我可以全面使用RxJava，但我想利用ReactFX的平台线程安全性和便利性

//DESIRE 1- Turn EventStream into Observable in the same monad
Observable<Foo> obs = EventStream.valuesOf(fooObservableValue).toObservable();

//Desire 2- Turn Observable into ObservableValue, Eventstream, or Binding
Binding<Foo> obsVal = Observable.create(...).toBinding();

//DESIRE 1-在同一个monad中将EventStream转换为可观察的
Observable obs=EventStream.valuesOf（fooObservableValue.toobbservable（）；
//Desire 2-将Observable转换为ObservableValue、Eventstream或Binding
Binding obsVal=Observable.create（…）.toBinding（）；

将ReactFX

事件流

转换为RxJava

可观察的

：

Observable<Foo> toRx(EventStream<Foo> es) {
    PublishSubject<Foo> sub = PublishSubject.create();
    es.subscribe(sub::onNext);
    return sub;
}

注意后一种情况下的

Platform.runLater（…）

。这使得生成的

EventStream

在JavaFX应用程序线程上发出事件

---

还要注意，在这两种情况下，我们都忽略了从

subscribe

方法返回的

Subscription

s。如果要在应用程序的生命周期内建立绑定，这是很好的。另一方面，如果它们之间的绑定应该是短期的，那么在第一种情况下，您将让RxJava组件公开

主题

，您的ReactFX组件公开

事件流

，然后根据需要执行

订阅

/

取消订阅

。与第二种情况类似。

要将ReactFX

EventStream

转换为RxJava

可观察的

：

Observable<Foo> toRx(EventStream<Foo> es) {
    PublishSubject<Foo> sub = PublishSubject.create();
    es.subscribe(sub::onNext);
    return sub;
}

注意后一种情况下的

Platform.runLater（…）

。这使得生成的

EventStream

在JavaFX应用程序线程上发出事件

---

还要注意，在这两种情况下，我们都忽略了从

subscribe

方法返回的

Subscription

s。如果要在应用程序的生命周期内建立绑定，这是很好的。另一方面，如果它们之间的绑定应该是短期的，那么在第一种情况下，您将让RxJava组件公开

主题

，您的ReactFX组件公开

事件流

，然后根据需要执行

订阅

/

取消订阅

。与第二种情况类似。

我不熟悉ReactFX，但通过查看API，我可以推断出以下转换：

public static <T> Observable<T> toObservable(EventStream<? extends T> es) {
    return Observable.create(child -> {
        Subscription s = es.subscribe(child::onNext);
        child.add(Subscriptions.create(s::unsubscribe));
    });
}
public static <T> EventStream<T> toEventStream(Observable<? extends T> o) {
    return new EventStream<T>() {
        final Vector<Consumer<? super T>> observers = new Vector<>();
        @Override
        public void addObserver(Consumer<? super T> observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Consumer<? super T> observer) {
            observers.remove(observer);
        }
        @Override
        public Subscription subscribe(Consumer<? super T> subscriber) {
            addObserver(subscriber);

            rx.Subscriber<T> s = new rx.Subscriber<T>() {
                @Override
                public void onNext(T t) {
                    subscriber.accept(t);
                }
                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    removeObserver(subscriber);
                }
                @Override
                public void onCompleted() {
                    removeObserver(subscriber);
                }
            };
            o.subscribe(s);

            return () -> {
                s.unsubscribe();
                removeObserver(subscriber);
            };
        }
    };
}

---

publicstaticobservable到Observable（EventStream我不熟悉ReactFX，但看看API，我可以推断出以下转换：

public static <T> Observable<T> toObservable(EventStream<? extends T> es) {
    return Observable.create(child -> {
        Subscription s = es.subscribe(child::onNext);
        child.add(Subscriptions.create(s::unsubscribe));
    });
}
public static <T> EventStream<T> toEventStream(Observable<? extends T> o) {
    return new EventStream<T>() {
        final Vector<Consumer<? super T>> observers = new Vector<>();
        @Override
        public void addObserver(Consumer<? super T> observer) {
            observers.add(observer);
        }

        @Override
        public void removeObserver(Consumer<? super T> observer) {
            observers.remove(observer);
        }
        @Override
        public Subscription subscribe(Consumer<? super T> subscriber) {
            addObserver(subscriber);

            rx.Subscriber<T> s = new rx.Subscriber<T>() {
                @Override
                public void onNext(T t) {
                    subscriber.accept(t);
                }
                @Override
                public void onError(Throwable e) {
                    e.printStackTrace();
                    removeObserver(subscriber);
                }
                @Override
                public void onCompleted() {
                    removeObserver(subscriber);
                }
            };
            o.subscribe(s);

            return () -> {
                s.unsubscribe();
                removeObserver(subscriber);
            };
        }
    };
}

publicstaticobservable到Observable（EventStreamPerfect！谢谢你Tomas。顺便说一句，我发现这在TableView TableColumn cellValueFactory中不起作用。FX线程和调度程序发生了一些奇怪的事情。不太确定该怎么办。太好了！谢谢你Tomas。顺便说一句，我发现这在TableView TableColumn cellValueFactory中不起作用。有些奇怪的事情发生在FX线程和调度程序上。不知道该怎么办。