CustomObservable与Observable.create()? [英] CustomObservable vs Observable.create()?

问题描述

我正在将侦听器包装到Observable中.通常我们使用 Observable.create()进行包装，但是有些库更喜欢使用自定义Observable并将其内部的内容包装起来，例如 RxBinding 甚至RxJava本身(来自我的理解是 operators 基本上是创建新的Custom Observable来在其中进行操作).

所以我的问题是:我们可以从Custom Observable获得什么好处?它的开销仅比 Observable.create()低，因为我们不会生成另一个 ObservableCreate 来覆盖我们的 ObservableSource .

我应该使用哪种方式将现有的库包装为Rx样式(例如:Firebase)?

解决方案

在某些情况下，创建自定义Observable会给情人带来负担.

在RxJava 1.x中，扩展 Observable 并使用 Observable.create(OnSubscribe)没有好处，因为它们实际上是相同的.但是，与将 lift()与自定义 Operator 结合使用相比，为中间操作员创建 Observable 的好处是. Observable.create(Emitter，BackpressureStrategy)通过额外的保护措施增加了开销，因为人们倾向于先找到 create 并实际上重新实现 just()，<在意识到它是不必要的之前，先将它与code> range()或 from()一起使用.

在RxJava 2.x中，默认方法是扩展 Observable 以及其他类型以添加​​源/中间运算符，这可能是最低的开销.受保护的创建方法仍然存在，但是只需花一点点钱就可以理解协议，因此可以通过使用 Observer 或 Disposable 还实现了接口或扩展了目标外部技术的基类.

例如，这就是我编写Java Swing和RxJava 2适配器库的方式.

 最终类ActionEventObservable扩展了Observable< ActionEvent>{最终的AbstractButton小部件；ActionEventObservable(AbstractButton小部件){this.widget =小部件；}@Override受保护的void subscriptionActual(Observer< ;? Super ActionEvent>观察者){w =小部件；ActionEventConsumer aec =新的ActionEventConsumer(observer，w);Observer.onSubscribe(aec);w.addActionListener(aec);如果(aec.get()== null){w.removeActionListener(aec);}}静态最终类ActionEventConsumer扩展AbstractEventConsumer< ActionEvent，AbstractButton>实现ActionListener {私有静态最终长serialVersionUID = -3605206827474016488L;ActionEventConsumer(Observer< ;? Super ActionEvent>实际的AbstractButton小部件){超级(实际，小部件)；}@Override公共无效actionPerformed(ActionEvent e){actual.onNext(e);}@Override受保护的void onDispose(AbstractButton组件){component.removeActionListener(this);}}} 

一些一次性管理隐藏在一个常见的 AbstractEventConsumer 类中，并且各个事件处理程序大多必须实现所需的 Listener 并在dispose上调用适当的remove方法.>

附带说明，大多数流行的技术可能已经具有您可以使用的RxJava适配器.

I'm working on wrapping listeners into Observables. Normally we use Observable.create() to wrap that but there are libraries prefer to use custom Observables and wrap things inside of it such as RxBinding, or even RxJava itself (from what my understanding, operators are basically create new Custom Observable to do operation inside of it).

So my questions are: what benefits we can get from Custom Observable? It's just lower overhead than Observable.create() since we don't generate another ObservableCreate to cover ObservableSource for us.

Which should I use for wrapping an existing Library into Rx Style (ex: Firebase)?

解决方案

Creating custom Observables offers lover overhead in some situations.

In RxJava 1.x, there is no benefit extending an Observable and using Observable.create(OnSubscribe) because they are practically the same. There is, however the benefit of creating an Observable for an intermediate operator than using lift() with a custom Operator. Observable.create(Emitter, BackpressureStrategy) adds overhead with the extra safeguard because people tend to find create first and practically reimplement just(), range() or from() with it before realizing it's unnecessary.

In RxJava 2.x, the default way is to extend Observable and the other types to add source/intermediate operators which is the lowest overhead there could be. The safeguarded creation methods are still there but with some small investment into understanding the protocol, you can avoid the allocation of extra objects due to create() by having an Observer or Disposable also implement the interfaces or extending a base class of the targeted external technology.

For example, this is how I wrote an adapter library for Java Swing and RxJava 2:

final class ActionEventObservable extends Observable<ActionEvent> {

    final AbstractButton widget;

    ActionEventObservable(AbstractButton widget) {
        this.widget = widget;
    }

    @Override 
    protected void subscribeActual(Observer<? super ActionEvent> observer) {
        AbstractButton w = widget;
        ActionEventConsumer aec = new ActionEventConsumer(observer, w);
        observer.onSubscribe(aec);
        w.addActionListener(aec);
        if (aec.get() == null) {
            w.removeActionListener(aec);
        }
    }

    static final class ActionEventConsumer
            extends AbstractEventConsumer<ActionEvent, AbstractButton>
            implements ActionListener {

        private static final long serialVersionUID = -3605206827474016488L;

        ActionEventConsumer(Observer<? super ActionEvent> actual, AbstractButton widget) {
            super(actual, widget);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            actual.onNext(e);
        }

        @Override
        protected void onDispose(AbstractButton component) {
            component.removeActionListener(this);
        }
    }
}

Some Disposable management is hidden in a common AbstractEventConsumer class and the individual event handlers mostly have to implement the required Listener and call the appropriate remove method on dispose.

On a side note, most popular technologies may already have RxJava adapters you can use.

这篇关于CustomObservable与Observable.create()?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！