Question

我正在尝试绕过一个丑陋的条件转换，当解释一个observable的update（）调用时，它想要通知它的观察者多种类型的事件。另外，我不想将标志传递给notifyObservers（）/ update（）方法。

我不希望观察者必须轮询可观察对象以找出发生了什么变化，我希望通过update（）方法（或类似方法）将这些新数据提供给观察者。

我有一个解决方案的想法。我为每种类型的通知实例化一个可观察对象。例如：observable是一个表示硬件设备的对象，它将包含代表其状态的observable：

public final Observable connectionState = new Observable();
public final Observable dataState = new Observable ();

这样，观察者不需要像一个观察者那样进行任何类型的查询或条件转换，即每个通知类型可以使用一个重写的update（）方法。

经过多次挫折之后，这是我能想到的最优雅的解决方案，但是我有这种可怕的感觉，我错过了关于如何正确使用Observers / Observables的观点。

我对该解决方案的主要问题是：

它仍然涉及演员表（至少不是有条件的）
由于观察者需要被观察，他们必须是公共成员。虽然这确实允许观察者调用addObservable（），但它也允许它们调用notifyObservers（）。

我做对了吗？

由于

Answer 1

您正在努力克服Observer模式的Java 1.0实现的局限性。看一下this answer问题 java.util.Observable在任何地方使用过吗？

他们没有被使用，因为他们的   设计有缺陷：它们不是类型   安全。你可以附加任何对象   实现任何Observable的Observer，   这会导致细微的错误   这条线。

将它们包裹在类型保险箱内   界面大约相同的数量   从实现模式开始工作   划伤，所以我猜后者是   在大多数情况下是首选。

不是试图将你的需求强加给java.util.Observer，也许你应该只是实现自己的模式版本，以更好地满足你的需求。

Answer 2

您可以尝试使用与访客模式配对的Observable：

class MyObserver implements Observer, EventVisitor {
    public void update(Observable o, Object arg) {
        ((EventAcceptor) arg).accept(this);
    }

    public void visit(SomeEvent v) {
        System.out.println("SomeEvent: " + v.s);
    }

    public void visit(AnotherEvent v) {
        System.out.println("AnotherEvent: " + v.info);
    }
}

interface EventVisitor {
    void visit(SomeEvent v);
    void visit(AnotherEvent v);
}

interface EventAcceptor {
    void accept(EventVisitor v);
}

class SomeEvent implements EventAcceptor {
    public final String s;

    public SomeEvent(String s) {
        this.s = s;
    }

    public void accept(EventVisitor v) {
        v.visit(this);
    }
}

class AnotherEvent implements EventAcceptor {
    public final String info;

    public AnotherEvent(String info) {
        this.info = info;
    }

    public void accept(EventVisitor v) {
        v.visit(this);
    }
}

class MyObservable extends Observable {
    void handleSomeEvent() {
        setChanged();
        notifyObservers(new SomeEvent("some event"));
    }

    void handleAnotherEvent() {
        setChanged();
        notifyObservers(new AnotherEvent("some event"));
    }
}

class Sample {
      public static void main(String[] args) {
          MyObservable observable = new MyObservable();
          observable.addObserver(new MyObserver());
          observable.handleSomeEvent();
          observable.handleAnotherEvent();
      }
}

Answer 3

您的问题有很多可能的解决方案。如果您认为Observable类不适合您的问题，您可以维护自己的监听器集合。

interface Listener {
    void onEvent1(Type1 arg);
    void onEvent2(Type2 t2, Type3 t3);
    void onEvent3();
}

List<Listener> listeners = new CopyOnWriteArray<Listener>();

public void addListener(Listener l) { listeners.add(l); }

public void onEvent1(Type1 arg) {
     for(Listener l: listeners) l.onEvent1(arg);
}

一个可观察的多个可观察事件

3 个答案: