使用「this.getClass（）。getMethod（）」檢查泛型類型是不是個好主意？

Question

我有一個類：

public class EventListener<T extends Event> { 

    private final EventHandler<T> handler; 

    public EventListener(EventHandler<T> handler) { 
     if (handler == null) { 
      throw new NullPointerException(); 
     } 
     this.handler = handler; 
    } 

    public boolean isApplicable(Event event) { 
     try { 
      this.getClass().getMethod("onEvent", event.getClass()); 
      return true; 
     } catch (NoSuchMethodException | SecurityException ex) { 
      return false; 
     } 
    } 

    public void onEvent(T event) { 
     handler.handle(event); 
    } 
} 

中的onEvent（T事件）方法，我需要調用isApplicable（事件event）方法來檢查監聽器可以處理此事件的調用之前。

我不想增加這種方式的一些構造函數的參數：

public class GenericClass<T> { 

    private final Class<T> type; 

    public GenericClass(Class<T> type) { 
      this.type = type; 
    } 

    public Class<T> getMyType() { 
     return this.type; 
    } 
} 

聽衆爲不同的事件將被存儲在相同的列表。所以我需要一些工具來檢查監聽器是否可以處理列表中的事件。

public class EventService extends Service { 

    private final ArrayList<EventListener> listeners = new ArrayList<>(); 

    public EventService(ServiceContainer serviceContainer) { 
     super(serviceContainer); 
    } 

    public ArrayList<EventListener> getListeners() { 
     return listeners; 
    } 

    public <T extends Event> void trigger(T event) { 
     listeners.stream().forEach((listener) -> { 
      if (listener.isApplicable(event)) { 
       listener.onEvent(event); 
      } 
     }); 
    } 
} 

是否有一個更優雅的代碼，把這個方法：

public boolean isApplicable(Event event) { 
    try { 
     this.getClass().getMethod("onEvent", event.getClass()); 
     return true; 
    } catch (NoSuchMethodException | SecurityException ex) { 
     return false; 
    } 
} 

Answer 1

正如在評論中提到，你的代碼應該，除非你的事件是Event一個實例，而不是一類的繼承它...如果Event是一個接口或抽象類，這是不可能的。

爲了保持同樣的「哲學」，我將傳遞期望的類作爲構造函數參數，並檢查事件是否是此類的實例。

public class EventListener<T extends Event> { 

    private final EventHandler<T> handler; 
    private final Class<T> eventClass; 

    public EventListener(EventHandler<T> handler, Class<T> eventClass) { 
     if (handler == null) { 
      throw new NullPointerException(); 
     } 
     if (eventClass == null) { 
      throw new NullPointerException(); 
     } 
     this.handler = handler; 
     this.eventClass = eventClass; 
    } 

    public boolean isApplicable(Event event) { 
     return this.eventClass.isInstance(event); 
    } 

    public void onEvent(T event) { 
     handler.handle(event); 
    } 
} 

Answer 2

最後：

public class EventService extends Service { 

    private final ArrayList<EventListener> listeners = new ArrayList<>(); 

    public EventService(ServiceContainer serviceContainer) { 
     super(serviceContainer); 
    } 

    public ArrayList<EventListener> getListeners() { 
     return listeners; 
    } 

    public <T extends Event> void trigger(T event) { 
     listeners.stream().forEach((listener) -> { 
      listener.onEvent(event); 
     }); 
    } 
} 

public class EventListener { 

    private final Consumer<Event> handler; 

    public EventListener(Consumer<Event> handler) { 
     if (handler == null) { 
      throw new NullPointerException(); 
     } 
     this.handler = handler; 
    } 

    public void onEvent(Event event) { 
     handler.accept(event); 
    } 
} 

public class SpecifiedEventListener<T extends Event> extends EventListener { 

    private final Class<T> eventClass; 

    public SpecifiedEventListener(Class<T> eventClass, Consumer<T> handler) { 
     super((Event event) -> { 
      handler.accept((T) event); 
     }); 
     if (eventClass == null 
       || handler == null) { 
      throw new NullPointerException(); 
     } 
     this.eventClass = eventClass; 
    } 

    @Override 
    public void onEvent(Event event) { 
     if (event.getClass().isAssignableFrom(eventClass)) { 
      super.onEvent(event); 
     } 
    } 

    public Class<T> getEventClass() { 
     return eventClass; 
    } 

}