RXJava 2 /RxAndroid 2 vs Observable vs Listener 从不同的类观察

Question

因为我想以一个干净的基础开始我的新应用程序，所以我正在寻找一种在不同类之间共享信息的好方法。例如，我想订阅一个可由不同类使用/共享的接口。

接口/Observable方式示例：

class SingleTonHolder {
    private static _instance = null;  // and initalize it using a static method.
    private List<MyListener> myListeners new ArrayList<>();
    public SingleTonHolder getInstance(){ return _instance }

    public void registerListener(MyListener listener) { myListeners.add(listener); }
    public void removeListener(MyListener listener) { myListeners.remove(listener); }

    public void doSomethingToTheListener(...) { for(MyListener l : myListeners) l.doSomethingToTheListener(..); }
}

ClassOne extends MyListener {
  public void onCreate() { 
      SingleTonHolder.getInstance().registerListener(this); 
  }
  public vond onDestroy() { 
      SingleTonHolder.getInstance().removeListener(this); 
  }
}

和另一个监听变化的类。

ClassTwo {
  MyListener listener = null;
  public void onCreate() { 
      listener = new MyListener( () => { .... });
      SingleTonHolder.getInstance().registerListener(listener); 
  }
  public vond onDestroy() { 
      SingleTonHolder.getInstance().removeListener(listener); 
  }
}

这确实有效，看起来像默认解决方案。每次另一个 Object 调用 SingleTonHolder.doSomethingToTheListener() 时，它都会通知所有已注册的侦听器进行更改。

由于我想尝试使用缺少文档的 RxJava2 和 RxAndroid2 的相同解决方案，因此我尝试了以下方法。

Class CallFactory{
    public Obvservable<List<Data>> getDummyData() { return anDummyObservable; }
}

然后我创建了一个单例类，它具有修改/观察客户端订阅的功能。

public Observable<List<Data>> getData() {
    return CallFactory.with(context)
           .getDummyData(...)
           .map(modifyList -> { /** do some processing **/return modifyList;          
    }) 
}

因为每次客户端订阅它都会“召回”它并且客户端保持连接直到调用 onCompleted() ，所以它不会作为例外工作。

我第一次尝试将信息分享给所有订阅的客户，我在我的 Singleton 类中创建了一个 PublishSubject。

private PublishSubject<List<Data>> sharedSubject = PublishSubject.create(); 

现在我让我的客户使用类似的方法订阅主题

public PublishSubject getSharedSubject() { return this.sharedSubject; }

如果我想发送一条应该被所有监听客户端接收的消息，那么我创建了类似的东西

public void setNewData(List<Data> data) {
    sharedSubject.onNext(data);
}

我很确定这不是它应该的方式，但是 rxjava 是为提供这样的解决方案而设计的吗？如果我想共享与 onNext、onError、onComplete 不同的事件，我是否需要在 onNext 中包装一个接口？

这些代码未经测试，只是为了说明我是如何理解它的。任何帮助将不胜感激。

Answer 1

是的，RxJava 使用了这 3 个基本的抽象回调 onNext<T> onComplete() 和 onError()。

但我相信你错过的重要部分是，观察者和消费者是接口的通用抽象。这意味着您将只有 3 个回调，但每个数据类型您将有 3 个回调。

RxJava 的主要思想是创建数据流。这意味着您将拥有PublishSubject<List<Data>>、PublishSubject<Foo>、PublishSubject<Bar> 等。然后使用Observer<T> 或Consumer<T> 两个接口之一。无需创建另一个接口或将其包装在其他东西中。只需使用 RxJava 提供的那些并将您需要的所有信息放入数据中。

希望对你有帮助。

例子：

// first class
public static class Foo implements Consumer<Data> {
   Disposable d; 
   public Foo() {
      this.d = SingleTonClass.subject.subscribe(this);
   }

   @Override void accept(Data data) {
         .. here the original data
   }

}

// second class
public static class Bar implements Consumer<MappedData> {
   Disposable d; 
   public Foo() {
      this.d = SingleTonClass.subject
          .map( some data transform  )
          .subscribe(this);
   }

   @Override void accept(MappedData data) {
         .. here the data after the map
   }


}



class SingleTonClass {
    public static PublishSubject<Data> subject = PublishSubject.create();

  // then feel free to fire events in the subject:
    public static void onSomethingHappen(){
      subject.onNext(new Data(1));
    }

    public static void onOtherThingHappen(){
      subject.onNext(new Data(2));
    }
}

总而言之，我不会将 Rx 调用包装到其他东西中，而是直接在需要的地方使用它们。