RxJava2/RxAndroid2 vs Observable vs Listener从不同类观察

Question

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

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

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

然后ive创建了一个Singleton类，它有一个函数来修改/observ onec客户机订阅。

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

因为每次客户端订阅它时都会“召回”它，并且客户端一直保持连接，直到调用onCompleted（）。

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 oncomplete()和onerror()。

但我相信您忽略的重要部分是，观察者和使用者是接口的一般抽象。这意味着您将只有3个回调，但每个数据类型将有3个回调。

RxJava的主要思想是创建数据流。这意味着您将拥有publishSubject > 、publishSubject 、 等，然后使用两个接口之一observer 或consumer 。没有必要创建另一个接口或将其包装在其他东西中。只需使用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调用包装成其他东西，而是直接在需要的地方使用它们。