泛型映射：读写

Question

有许多不同的事件，都实现相同的接口：

interface Event {}
class FooEvent implements Event {}
class BarEvent implements Event {}

每个事件都有一个专用的处理程序：

interface EventHandler<T extends Event> {
    void handle(T event);
}
class FooEventHandler implements EventHandler<FooEvent> {
    @Override
    public void handle(FooEvent event) { }
}
class BarEventHandler implements EventHandler<BarEvent> {
    @Override
    public void handle(BarEvent event) { }
}

所有事件处理程序都创建一次并添加到地图中。每当发生事件时，都应使用此映射来找到合适的事件处理程序。

class Main {
    Map<Class<? extends Event>, EventHandler<? extends Event>> eventHandlerRegistry = Map.of(
            FooEvent.class, new FooEventHandler(),
            BarEvent.class, new BarEventHandler()
    );

    void handleEvent(Event event) {
        EventHandler<? extends Event> handler = this.eventHandlerRegistry.get(event.getClass());
        handler.handle(event); // DOES NOT COMPILE: needed=capture<? extends Event>, given=Event
    }
}

不幸的是，最后一行无法编译。我可以通过省略 EventHandler 的类型参数来编译它：

EventHandlerhandler = this.eventHandlerRegistry.get(event.getClass());
handler.handle(event); // WARNING: unchecked call to 'handle(T)' as a member of raw type 'EventHandler'

但这感觉不太对劲…… 我知道PECS，但我感觉有点被困住了，因为我生产和消费了我的事件处理程序。

我怎样才能干净利落地实现这个？

Answer 1

如果您要将（通用）处理程序混合在同一个映射中，则不能具有类型安全性。据我所知，使代码类型安全的方法是去掉EventHandler 上的泛型类型参数；但这是您要避免的一件事。

如果您可能会牺牲类型安全，知道您的处理程序将始终与指定的类匹配，那么您可以尝试以下操作：

private <T extends Event> EventHandler<T> getHandler(Class<?> eventClass) {
    return (EventHandler<T>) 
              this.eventHandlerRegistry.get(eventClass); //Unchecked cast
}

然后让你的 handleEvent 方法通用：

<T extends Event> void handleEvent(T event) {
    EventHandler<T> handler = this.getHandler(event.getClass());
    handler.handle(event);
}

然后此方法将成功编译，而不会发出警告。你唯一需要确定的是eventHandlerRegistry 永远不会被这样的东西污染：

put(FooEvent.class, new BarEventHandler())); //this can happen

Answer 2

这是一个使用新 EventType 枚举可以做什么的示例：

声明枚举：

public enum EventType {
    FOO_EVENT, BAR_EVENT
}

声明Event接口：

interface Event {
    EventType getType();
}

class FooEvent implements Event {
    EventType getType() {
        return FOO_EVENT;
    }
}

class BarEvent implements Event {
    EventType getType() {
        return BAR_EVENT;
    }
}

和EventHandlers：

interface EventHandler {
    void handle(Event event);
}

class FooEventHandler implements EventHandler {
    @Override
    public void handle(Event event) {
        //cast Event to FooEvent when processing
    }
}

class BarEventHandler implements EventHandler {
    @Override
    public void handle(Event event) {
        //cast Event to BarEvent when processing
    }
}

在EventType 和EventHandler 之间声明一个Map：

Map<EventType, EventHandler> eventHandlerRegistry = //... fill the map here

最后，当事件发生时，只需执行以下操作：

eventHandlerRegistry.get(event.getType()).handle(event);

P.S.注意，对于枚举，最好使用java.util.EnumMap。