android - RxJava 代替接口(interface)回调 (Android)

Question

RxJava 的新手，我对接口(interface)回调(通过接口(interface)变量从代码的内层/模块调用)与 RxJava 有疑问。为了更清楚，快速示例:

标准回调接口(interface)实现，接口(interface)，类A和B

interface CustomCallback {
    void onCallbackCalled(String str);
}
class ClassA {
    private ClassB classB;
    public ClassA() {
        classB = new ClassB(new CustomCallback() {
            @Override
            public void onCallbackCalled(String str) {
                System.out.println("Callback called " + str);
            }
        });
    }
}
class ClassB {
    private CustomCallback customCallback;
    public ClassB(CustomCallback callback) {
        customCallback = callback;
    }
    private void somethingHappened() {
        customCallback.onCallbackCalled("method somethingHappened");
    }
}

当调用 classB 方法“somethingHappened”时，结果是:“回调调用方法 somethingHappened”。接口(interface)的方法 onCallbackCalled(String str) 可以从类 B 任意多次调用。

A 级 ↓ ...............................................通过构造函数注入(inject)接口(interface)

CLASS B................↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ onCallbackCalled(...) 0...n 号

现在是 RxJava。我发现的 99% 的案例。

class ClassA {
    private ClassB classB;
    public ClassA() {
        classB = new ClassB();
    }

    public void rxJavaMethod() {
                DisposableObserver<String> observer = classB.getObservable()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<String>() {

                    @Override
                    public void onNext(String s) {}

                    @Override
                    public void onError(Throwable e) {}

                    @Override
                    public void onComplete() {}
                });
    }
}

class ClassB {
    private Observable<String> getObservable() {
        return Observable.just(can be different from "just", for sake of example);
    }
}

方案是:

CLASS A ↓...................... 一次获取 Observable 资源的调用

CLASS B................↑ EDIT 返回发出 0...n 个值的 observable

所以基本上你从顶层调用(在这个例子中)，你从内层得到关于状态的响应。

问题:

1) 如果你有一个动态变化的模型(内层)(但不是任何类型的 AsyncTask 等)，并且你想通知顶层(例如 UI)状态已经改变(很好例如:游戏)。

2) RxJava 库中是否有任何类型的“桥梁”类(我认为它是“订阅它，然后你可以根据需要多次向它传递参数，并且信息/可观察值将被发送给订阅者).

3) 尝试这样做而不是标准接口(interface)回调是否有任何意义和优势(在上述情况下，不是“单击按钮，获得一次响应”)

更新，基于上述示例的答案

正如 Bob Dalgleish 提到的，建立这种桥梁的方法是使用扩展 Subject rxjava 的类之一。 http://reactivex.io/documentation/subject.html

class ClassA {
    private ClassB classB;
    public ClassA() {
        classB = new ClassB();
    }

    public void rxJavaMethod() {
                DisposableObserver<String> observer = classB.getCallbackSubjectRx()
                .subscribeWith(new DisposableObserver<String>() {

                    @Override
                    public void onNext(String s) {}

                    @Override
                    public void onError(Throwable e) {}

                    @Override
                    public void onComplete() {}
                });
    }
}

class ClassB {
    private BehaviorSubject<String> mCallbackRx;
    public ClassB() {
        mCallbackRx = BehaviorSubject.create();
    }

    // method somethingHappened can be invoked whenever whe want and
    // it will send given parameter to all subscribers
    private void somethingHappened() {
        mCallbackRx.onNext("method somethingHappened");
    }

    // multiple subscribers allowed
    public BehaviorSubject<String> getCallbackSubjectRx() {
        return mCallbackRx;
    }
}

缺点可能是，如果我们想使用一个“桥”来处理多种回调类型(接口(interface)有方法，我们只使用一种方法:“onNext()”)，我们可能需要创建带有回调参数的包装类.在我看来这不是什么大问题。

另一方面，我们可以访问所有 RxJava 运算符。 http://reactivex.io/documentation/operators.html

(上面的示例是针对 RxJava2 的，其中 Disposable 基本上是来自 RxJava1 的订阅)。

Answer 1

首先要注意的是

CLASS B................↑ returns 0...n observables to observer

不是真的。 B 类返回一个 observable，偶尔会发出 0..n 值。

1. (问题不清楚)。无论出于何种原因，来自 B 类的内部可观察对象正在改变状态。最常见的原因是另一个进程/任务/线程正在为其提供数据，而您想在 UI 中显示结果状态。

2. 我一直使用的一种简单类型的“桥接”类 Subject<>类。您可以使用 .onNext() 向它们发出新值订阅者将获得这些值。

3. 如果回调接口(interface)都是标准化的，那么它们会有一些优势，但它们在各地都各不相同。您必须记住，对于您正在查看的这个东西，您需要一些特定的界面，而对于另一个东西，则需要一个不同的界面。虽然如今 UI 事件趋于统一，但尝试混合 UI 事件、网络事件和数据库事件仍然会让您感到不知所措。具有更小的接口(interface)类，主要封装在 rxJava 泛型类中，使得组合功能更容易。

编辑:改进示例代码。

Yammer Engineering有一篇好文章关于使用 Observable.create() (以前是Observable.fromEmitter()，以前是Observable.fromAsync()。他提出的重点是

1. 使用 Observable.create()通过向底层接口(interface)注册监听器来为您处理订阅步骤。更重要的是，它安排在 unsubscribe() 时注销监听器。发生。

2. 开箱即用，此代码处理多个订阅者，每个订阅者接收其自己的可观察数据流。

3. 正如我上面提到的，监听器协议(protocol)特定于您注册的对象。如果那个东西只支持一个监听器，那么你可能想要引入一个 Subject。订阅被观察的事物，你的所有其他观察者也订阅这个主题。

编辑结束。

我最喜欢的解决方案组合示例是 distinctUntilChanged()运算符(operator)。因为它是一个适用于通用可观察对象的运算符，所以它封装了保存连续值以进行比较并仅发出不同值的状态属性。我经常用它来记录状态变化。要使用标准回调接口(interface)达到相同的目的，需要添加一个不同的接口(interface)来将先前的值保存到每个现有接口(interface)。

所以，是的，大多数时候使用 rxJava observables 方法是值得的，只是为了不必记住许多回调协议(protocol)中的哪一个可能适用于当前情况。