Java 创建通用GWT事件：这是一种好方法吗？

我试图创建一种简单的方法来为不同的域类触发CRUD类型的事件。我创建了以下事件类：

public class EntityModifiedEvent<E> extends Event<EntityModifiedEventHandler<E>> {

private E element;
private ModType modType;
private Class<E> clazz;
private static Map<String,GwtEvent.Type<EntityModifiedEventHandler<?>>> types = new HashMap<String, GwtEvent.Type<EntityModifiedEventHandler<?>>>();

public EntityModifiedEvent(ModType modType, E element, Class<E> clazz) {
    this.element = element;
    this.modType = modType;
    this.clazz = clazz;
}

public Type<EntityModifiedEventHandler<?>> getType() {
    return getType(clazz);
}

@SuppressWarnings({"rawtypes", "unchecked"})
public static GwtEvent.Type<EntityModifiedEventHandler<?>> getType(Class clazz) {
    GwtEvent.Type type = types.get(clazz.toString());
    if (type == null) {
        type = new GwtEvent.Type<EntityModifiedEventHandler<?>>();
        types.put(clazz.toString(), type);
    }
    return type;
}

public E getElement(){
    return element;
}

public ModType getModType() {
    return modType;
}

@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public Type<EntityModifiedEventHandler<E>> getAssociatedType() {
    return (Type) getType();
}

@Override
protected void dispatch(EntityModifiedEventHandler<E> handler) {
    handler.onEntityModified(this);
};

public interface EntityModifiedEventHandler<E> extends EventHandler {
    void onEntityModified(EntityModifiedEvent<E> entityModifiedEvent);
}

事件将按如下方式触发：

getEventBus().fireEventFromSource(new EntityModifiedEvent<MyDomainClass>(ModType.CREATE, instanceModified, MyDomainClass.class), this);  

getEventBus（）.fireEventFromSource（新的EntityModifiedEvent（ModType.CREATE，instanceModified，MyDomainClass.class），这个）；

ModType只是一个简单的枚举，具有不同类型的修改。 我担心在这个类中有一个包含所有class.toString->eventTypes的映射您认为这会带来性能问题吗？ 此外，这种方法依赖于使用类型对象的hashcode的EventBus来标识为该类型注册的处理程序（请参阅getType（Class clazz）函数）你认为依赖它是不对的吗？

---

关于如何做到这一点，还有其他建议吗？任何评论都将不胜感激

你必须扪心自问，你从这种方法中获得了什么

• 性能-没有。我没有关于这方面的确切数字（我必须能够分析您的应用程序），但这似乎没有提供可测量的性能增益（如果有的话）。激发事件的数量将是相同的，但是接收器的数量将比使用更细粒度的方法的数量要多。另外，还有类型检查
• 在触发任何实体修改事件时执行某些公共代码的能力，无论其类型如何。这是真的，但请继续阅读如何通过具体事件实现它

为执行的确切操作使用特定事件似乎是更好的选择：

• 它清楚地表明谁在听什么事件
• 事件可以具有特定于事件的额外元数据（删除了多少记录，是否需要刷新缓存等）

我建议您考虑修改一些样板文件并改进代码。它还允许用一种方法处理多个事件：

class SuperEvent extends GenericEvent { }

class EventOne extends SuperEvent { }

class EventTwo extends SuperEvent { }

class FormPresenter {
  interface MyEventBinder extends EventBinder<FormPresenter> {}
  private final MyEventBinder eventBinder = GWT.create(MyEventBinder.class);

  FormPresenter(EventBus eventBus) {
    eventBinder.bindEventHandlers(this, eventBus);
  }

  @EventHandler
  void onEventOne(EventOne event) {
    // handler for EventOne
  }

  @EventHandler(handles = {EventOne.class, EventTwo.class})
  void onEventOneAndTwo(SuperEvent event) {
    // handler for EventOne and EventTwo
  }

  @EventHandler(handles = {EventOne.class, EventTwo.class})
  void onEventOneAndTwo2() {
    // handler for EventOne and EventTwo without parameter
  }
}

class SuperEvent扩展了GenericeEvent{}
EventOne类扩展了SuperEvent{}
类EventTwo扩展了超级事件{}
类FormPresenter{
接口MyEventBinder扩展了EventBinder{}
私有最终MyEventBinder eventBinder=GWT.create（MyEventBinder.class）；
FormPresenter（事件总线事件总线）{
bindEventHandlers（这是eventBus）；
}
@事件处理程序
void onEventOne（EventOne事件）{
//EventOne的处理程序
}
@EventHandler（句柄={EventOne.class，EventTwo.class}）
作废一个事件和两个事件（超级事件）{
//EventOne和EventTwo的处理程序
}
@EventHandler（句柄={EventOne.class，EventTwo.class}）
void onEventOneAndTwo2（）{
//不带参数的EventOne和EventTwo的处理程序
}
}

除非您有数十万个不同的域类，否则我不认为这会是一个性能问题。如果您想避免映射查找，可以使用代码生成来使用If、else和instanceOf实现getType，但我认为这不值得。

class SuperEvent extends GenericEvent { }

class EventOne extends SuperEvent { }

class EventTwo extends SuperEvent { }

class FormPresenter {
  interface MyEventBinder extends EventBinder<FormPresenter> {}
  private final MyEventBinder eventBinder = GWT.create(MyEventBinder.class);

  FormPresenter(EventBus eventBus) {
    eventBinder.bindEventHandlers(this, eventBus);
  }

  @EventHandler
  void onEventOne(EventOne event) {
    // handler for EventOne
  }

  @EventHandler(handles = {EventOne.class, EventTwo.class})
  void onEventOneAndTwo(SuperEvent event) {
    // handler for EventOne and EventTwo
  }

  @EventHandler(handles = {EventOne.class, EventTwo.class})
  void onEventOneAndTwo2() {
    // handler for EventOne and EventTwo without parameter
  }
}