是否可以在包含多种侦听器类型的 Java 中创建自己的事件侦听器列表？

Question

我正在实现一个客户端-服务器系统，其中客户端处于连续阻塞读取循环中，侦听来自服务器的消息。当收到消息时，我想根据消息的类型引发一个“事件”，其他 GUI 类可能会添加监听器。我对 C# 事件比较熟悉，所以我仍然习惯 Java 的做事方式。

将有许多消息类型，因此我需要为每种类型提供一个接口，称为 MessageTypeAListener、MessageTypeBListener 等，每个都包含一个句柄方法，我的 GUI 类将实现这些方法。但是，将有许多类型，而不是维护每种类型的侦听器列表并具有多个“触发”方法，我希望拥有一个大侦听器列表和一个类型化的触发方法。然后 fire 方法可以说“只触发类型是我指定的侦听器”。

例如（伪代码）：

ListenerList.Add(MessageTypeAListener); 
ListenerList.Add(MessageTypeBListener);

<T> fire(message) {
    ListenerList.Where(type is T).handle(message)
}

...  

fire<MessageTypeAListener>(message);

但是，类型擦除似乎使这变得困难。我可以尝试强制转换和捕获异常，但这似乎是错误的。是否有一种干净的方式来实现这一点，或者为每种类型保留一个单独的侦听器列表是否更明智，即使会有大量类型？

Answer 1

我实现了类似的东西，因为我发自内心地不喜欢 Java 的 EventListenerList。首先，您实现一个通用的侦听器。我根据接收到的事件定义了监听器，基本上只有一种方法

interface GenericListener<T extends Event> {
   public void handle(T t);
}

这使您不必定义 ListenerA、ListernerB 等...虽然您可以使用 ListenerA、ListenerB 等按照自己的方式进行，所有这些都扩展了一些基础，例如 MyListener。两种方式各有利弊。

然后我使用CopyOnWriteArraySet 来容纳所有这些听众。一个集合是需要考虑的，因为经常听者被草率的编码人员添加两次。 YMMV。但是，实际上你有一个Collection<GenericListener<T extends Event>> or a Collection<MyListener>

现在，正如您所发现的，通过类型擦除，集合只能容纳一种类型的侦听器。这通常是一个问题。解决方案：使用地图。

由于我的一切都基于事件，所以我使用了

Map<Class<T extends Event>, Collection<GenericListener<T extends Event>>>

根据事件的类别，获取想要获取该事件的侦听器列表。
您的替代方法是将其基于侦听器的类

Map<Class<T extends MyListener>, Collection<MyListener>>

上面可能有一些错别字...

Answer 2

老式模式方法，使用Visitor pattern：

class EventA {
    void accept(Visitor visitor) {
        System.out.println("EventA");
    }
}

class EventB {
    void accept(Visitor visitor) {
        System.out.println("EventB");
    }
}

interface Visitor {
    void visit(EventA e);
    void visit(EventB e);
}

class VisitorImpl implements Visitor {
    public void visit(EventA e) {
        e.accept(this);
    }

    public void visit(EventB e) {
        e.accept(this);
    }
}

public class Main {
    public static void main(String[] args) {
        Visitor visitor = new VisitorImpl();
        visitor.visit(new EventA());
    }
}

更现代的方法是在不应该相互派生的事件类和这些事件的各自处理程序之间使用 Map。这样可以避免访问者模式的缺点（也就是说，每次添加新事件时，您都需要更改所有访问者类，至少是它们的基类）。

另外一种方式是使用Composite pattern:

interface Listener {
    void handleEventA();
    void handleEventB();
}

class ListenerOne implements Listener {

    public void handleEventA() {
        System.out.println("eventA");
    }

    public void handleEventB() {
        // do nothing
    }
}

class CompositeListener implements Listener {
    private final CopyOnWriteArrayList<Listener> listeners = new CopyOnWriteArrayList<Listener>();
    void addListener(Listener l) {
        if (this != l)
            listeners.add(l);
    }

    public void handleEventA() {
        for (Listener l : listeners)
            l.handleEventA();
    }

    public void handleEventB() {
        for (Listener l : listeners)
            l.handleEventB();
    }
}

Answer 3

在经历了这里几乎每个人的建议的迭代之后，我最终采用了标准监听器接口和监听器列表的略微修改的路线。我从 Swing 的EventListenerList 开始，只是对数十种消息类型的添加/删除方法的数量感到失望。我意识到这不能在保持单个EventListenerList 的同时进行压缩，所以我开始考虑为每种类型单独列出一个列表。这使它类似于 .NET 事件，其中每个事件都有自己的委托列表，以便在引发时触发。我想避免大量的添加/删除方法，所以我创建了一个快速的 Event 类，看起来像这样：

public class Event<T extends EventListener> {
    private List<T> listeners = new ArrayList<T>();

    public void addListener(T listener) {
        listeners.add(listener);
    }

    public void removeListener(T listener) {
        listeners.remove(listener);
    }

    public List<T> getListeners() {
        return listeners;
    }
}

然后我保留这个类的几个实例，每个实例都根据一个侦听器键入，所以 Event<MessageTypeAListener> 等。然后我的类可以调用 add 方法将自己添加到该特定事件中。我希望能够在Event 实例上调用通用Raise 方法，然后触发所有处理程序，但我不希望它们都必须具有相同的“处理”方法，所以这是不可能。相反，当我准备解雇听众时，我就这么做了

  for (MessageTypeAListener listener : messageTypeAEvent.getListeners())
      listener.onMessageTypeA(value);

我确信这不是一个新想法，并且可能以前已经以更好/更强大的方式完成了，但它对我来说非常有用，我对此很满意。最重要的是，它很简单。

感谢大家的帮助。

Answer 4

如果您只有简单的事件，即没有数据的事件或所有事件都具有相同的数据类型，enum 可能是一个前进的方向：

public enum Event {
    A,
    B,
    C
}

public interface EventListener {
    void handle(Event event);
}

public class EventListenerImpl implements EventListener {
    @Override
    public void handle(Event event) {
        switch(event) {
            case A: 
                // ...
                break;
        }
    }
}

public class EventRegistry {
    private final Map<Event, Set<EventListener>> listenerMap;

    public EventRegistry() {
        listenerMap = new HashMap<Event, Set<EventListener>>();
        for (Event event : Event.values()) {
            listenerMap.put(event, new HashSet<EventListener>());
        }
    }

    public void registerEventListener(EventListener listener, Event event) {
        Set<EventListener> listeners = listenerMap.get(event);
        listeners.add(listener);
    }

    public void fire(Event event) {
        Set<EventListener> listeners = listenerMap.get(event);
        for (EventListener listener : listeners) {
            listener.handle(event);
        }
    }
}

评论：

如果EventListnerImpl 中的switch 语句仅注册到单个事件，或者无论收到哪个Event，它都应该始终以相同的方式运行，则可以省略它。

EventRegister 已将EventListener(s) 存储在映射中，这意味着每个侦听器只会获得其订阅的Event(s)。此外，EventRegister 使用Sets，这意味着EventListener 最多只能接收一次事件（以防止如果有人不小心注册了两次侦听器，侦听器将收到两个事件）。