观察者设计——如何访问method.invoke作用域？

Question

我目前有一个Java Observer/Observable 设置，其中我打开Observer.update 的Object 参数中的某些字段（例如事件ID）来确定如何处理Observable 通知。

这会创建冗长的代码，例如：

public void update (Observable o, Object arg) {
    if (arg instanceof Event) {
        switch (((Event)arg).getID()) {
            case EVENT_TYPE_A:
                // do stuff...
                break;
            case EVENT_TYPE_B:
                // do stuff...
                break;
            case EVENT_TYPE_C:
                // do stuff...
                break;
        }
    }
}

来自 ActionScript 背景，这对我来说感觉不必要的冗长...我宁愿传递一个由 Observable 直接调用的回调方法，而不是传递一个观察者的实例（更具体地说，由子类）。但是，我不清楚如何确定应调用该方法的对象（“拥有”该方法的类实例）。

我可以传递对包含该方法的实例的引用，但这听起来像是糟糕的 OOP。

我是不是找错树了？或者有没有一种干净的方法来实现这一目标？

Answer 1

这可能有点离谱，但由于 Java 5 及更高版本有泛型，传统的观察者和侦听器模式似乎都有点过时了。也就是说，类型是当今 Java 的常用语言。具有整数 ID 的事件的存在主要是因为针对常量的 switch 语句非常高效 - 以牺牲可读性为代价，并且通常需要强制转换来执行任何有用的操作（您可能知道，如果 ID = 23，则对象必须是 MouseEvent，但它更好如果您让编译器和运行时类型信息为您处理此问题，则更安全）。在现代 JVM 中的现代机器上，效率可能不值得。

因此，如果您没有结合 ID 和传统的观察者模式，您可能会考虑这样的事情：

public abstract class Observer<T> {
  private final Class<T> type;

  protected Observer(Class<T> type) {
    this.type = type;
  }

  //implement this method;  if it returns false, the event (object) 
  //is "consumed" and no other observers should be called
  public abstract boolean onEvent(T instance);

  protected final boolean matches(Object obj) {
    return type.isInstance(obj);
  }

  Boolean maybeDispatch(Object o) {
    if (matches(o)) {
      return onEvent(type.cast(o));
    }
    return null;
  }
}

这让我们（字面意思）成为一个通用的事件观察者；我们像这样打开传入对象的类型：

public class Bus {
  private final List<Observer<?>> observers = new ArrayList<Observer<?>>();

  public void registerObserver(Observer<?> observer) {
    observers.add(observer);
  }

  public <T> void onEvent(T t) {
    Boolean keepGoing;
    for (Observer<?> obs : observers) {
      keepGoing = obs.maybeDispatch(t);
      if (keepGoing != null && !keepGoing.booleanValue()) {
        break;
      }
    }
  }
}

生成的代码（稍微）效率较低，但编写这样一个“观察者”的子类具有无限的可读性。它看起来不太像传统的观察者模式，但功能上是等效的。

如果您仍然需要额外的“事件”参数，您可以执行类似的逻辑来对两种类型进行参数化。

Answer 2

更清晰的实现将涉及将事件是否可以由观察者/可观察对象处理的逻辑删除到实际观察者/可观察对象本身。看起来 ActionScript 给您留下了一个关于观察者模式的有趣想法。观察（无双关语）：

public interface Observer{

  public void update( Event arg );
}

public class Event{

  public int ID;
}

public Button implements Observer{

  public void update ( Event arg ){

     switch (arg.ID){

       case 1:  //Buttonsy handle events of type 1
         //do something useful;
         break;
       default:
         System.out.println("Buttons don't handle events of ID: " + arg.ID);
         break;
     }
  }
}

public ProgressBar implements Observer{

  public void update ( Event arg ){

     switch (arg.ID){

       case 2: //ProgressBars handle events of type 2 and 3
         //do something useful;
         break;
       case 3:
         //do something else useful;
         break;
       default:
         System.out.println("Progress bars don't handle events of ID: " + arg.ID);
         break;
     }
  }
}


public class Subject{

 private ArrayList<Observer> allUIControls;

 public registerControl( Observer control ){

   allUIControls.add( control );
 }

 public void updateControls ( Event arg ) {

   foreach ( Observer control in allUIControls ){

     //pass the event to each UI control, and let the EVENT decide if it can understand the Event.ID
     //its not the job of Subject to decide if the Observer is fit to handle the event. THIS IS NOT THE OBSERVER pattern.
     control.update( arg );
   }
 }
}