private void addAnnotatedListenerMethod(Object listener, Object sourceObject, Class<? extends Annotation> annotation, Method method, List<EventFilter<? extends EventObject>> filters){ List<EventFilter<? extends EventObject>> regFilters = new ArrayList<EventFilter<? extends EventObject>>(); regFilters.addAll(filters); addEventFilterByAnnotation(listener, method, regFilters); validateAnnotatedEventMethod(listener, method, annotation, eventRegister.getEventByAnnotation(annotation).getEventClass()); addListener(listener, eventRegister.getEventByAnnotation(annotation) .getEventClass(), sourceObject, regFilters); }
/** * Register a new Event type to the register. * * @param eventClass * New event type to handle * * @throws NoSuchEventException if no event can be found of type eventClass. **/ @Override public void registerEvent(Class<? extends EventObject> eventClass) throws NoSuchEventException { EventConfig eventConfig = eventRegister.getEventByClass(eventClass); if (!eventMap.containsKey(eventClass)) { eventMap.put(eventClass, eventConfig.getListener()); channelRegister.registerEventHandler(this, eventClass); } }
/** * Register @Event annotated events with the channels referenced in the channels attribute. * * @param config The configuration build this far. */ protected void registerEventsAtChannels(EventRegister eventRegister, ChannelFactory channelFactory, ChannelRegister channelRegister) { for (Class<? extends EventObject> eventClass : eventRegister.getEventClasses()) { Event eventAnno = eventClass.getAnnotation(Event.class); if (eventAnno != null && eventAnno.channels().length > 0) { registerEventAtChannelByAnnotation(channelFactory, channelRegister, eventClass, eventAnno); } } }
if (!interfaces.isEmpty()) { for (Class<? extends EventListener> interfaceClass : interfaces) { addListener(listener, eventRegister.getEventByInterface(interfaceClass).getEventClass(), sourceObject, filters); listenerAdded = true; Set<Class<? extends Annotation>> registeredAnnotations = eventRegister.getRegisteredEventAnnotations(); Map<Class<? extends Annotation>, Method> methodAnnotations = AnnotationsUtils.findAnnotatedMethods(listener.getClass(), registeredAnnotations); for (Map.Entry<Class<? extends Annotation>, Method> annotation : methodAnnotations.entrySet()){ validateAnnotatedEventMethod(listener, annotation.getValue(), annotation.getKey(), eventRegister.getEventByAnnotation(annotation.getKey()).getEventClass()); addListener(listener, eventRegister.getEventByAnnotation(annotation.getKey()) .getEventClass(), sourceObject, filters); listenerAdded = true;
/** * Returns all lister interfaces form the listener object that is a Ka-Event registered event. * * @param listener * Listener object to inspect. * * @return All interfaces from listener object that is registered with Ka-Event. **/ @SuppressWarnings("unchecked") private Set<Class<? extends EventListener>> getRegisteredInterfaces(EventListener listener) { Set<Class<?>> interfaces = InterfaceUtils.getInterfacesExtending(listener, EventListener.class); Set<Class<? extends EventListener>> registeredEvents = new HashSet<Class<? extends EventListener>>(); for (Class<?> interfaceClass : interfaces) { if (eventRegister.hasEventByInterface((Class<? extends EventListener>) interfaceClass)) { registeredEvents.add((Class<? extends EventListener>) interfaceClass); } } filterInterfaces(registeredEvents); return registeredEvents; }
/** * Register events for a channel. * * @param eventRegister Event Register. * @param channel Channel XML Configuration Element. * @param eventSet Set of events to register at the channel. **/ private void registerEventsForChannel(EventRegister eventRegister, KaEventConfig.Channels.Channel channel, Set<Class<? extends EventObject>> eventSet) { if (channel.getHandle() != null) { for (KaEventConfig.Channels.Channel.Handle handleEvent : channel.getHandle()) { String eventName = handleEvent.getEvent(); EventConfig eventConfig = eventRegister.getEventByName(eventName); if (eventConfig != null) { eventSet.add(eventConfig.getEventClass()); } else { throw new IllegalStateException("Event " + eventName + " could not be found!"); } } } }
/** * Import and register events from the eventExporter provided. * * @param eventExporter * Creates the events to register. * @param eventBuilderFactory * Used by the exporter. * @param eventRegister * Event Register. **/ protected void importAndRegisterEvents(EventExporter eventExporter, EventBuilderFactory eventBuilderFactory, EventRegister eventRegister) { Set<EventConfig> events; try { events = eventExporter.exportEvents(eventBuilderFactory); for (EventConfig event : events) { eventRegister.registerEvent(event); } } catch (RuntimeException re) { LOG.error("Error when importing annotated events", re); throw re; } catch (IOException e) { throw new IllegalStateException("Could not import events", e); } }
private boolean registerEventListenerByAnnotation(Object listener, Object sourceObject, List<EventFilter<? extends EventObject>> filters) { boolean listenerAdded = false; Set<Class<? extends Annotation>> registeredAnnotations = eventRegister.getRegisteredEventAnnotations(); Map<Class<? extends Annotation>, Set<Method>> methodAnnotations = AnnotationsUtils.findAnnotatedMethods(listener.getClass(), registeredAnnotations); for (Map.Entry<Class<? extends Annotation>, Set<Method>> annotationEntry : methodAnnotations.entrySet()){ Set<Method> methods = annotationEntry.getValue(); Class<? extends Annotation> annotation = annotationEntry.getKey(); if(methods.size() > 1) { throw new IllegalStateException("More than one method found annotated with " + annotation + " in class " + listener.getClass()); } addAnnotatedListenerMethod(listener, sourceObject, annotation, methods.iterator().next(), filters); listenerAdded = true; } return listenerAdded; }
private void registerInterfaceListener(Object listener, Object sourceObject, List<EventFilter<? extends EventObject>> filters, Class<? extends EventListener> interfaceClass) { List<EventFilter<? extends EventObject>> regFilters = new ArrayList<EventFilter<? extends EventObject>>(); regFilters.addAll(filters); Set<Method> methods = MethodUtils.getDeclaredMethods(interfaceClass, new MethodFilterBuilder().returnType(Void.TYPE).numberOfParameters(1).build()); // Only inspect method level @EventListerFilter on single method interfaces if(methods.size() == 1) { addEventFilterByAnnotation(listener, methods.iterator().next(), filters); } else { addEventFilterByAnnotation(listener, null, filters); // If any method is annotated with @EventListenerFilter an // exception could be thrown here. } addListener(listener, eventRegister.getEventByInterface(interfaceClass).getEventClass(), sourceObject, filters); }
/** * Validates that the event is registered. * * @param event Event to inspect * * @throws IllegalArgumentException if the event is not registered. **/ protected void validateEvent(EventObject event) throws IllegalArgumentException{ if(!eventRegister.hasEventByClass(event.getClass())) { throw new IllegalArgumentException(event.getClass() + " is not a registerd event."); } }
.getClass().getGenericInterfaces()[0]).getActualTypeArguments()[0]; Collection<EventConfig> events = eventRegister.getEvents(); boolean found = false; for (EventConfig eventConfig : events) {
/** * Returns all lister interfaces form the listener object that is a Ka-Event registered event. * * @param listener * Listener object to inspect. * * @return All interfaces from listener object that is registered with Ka-Event. **/ @SuppressWarnings("unchecked") private Set<Class<? extends EventListener>> getRegisteredInterfaces(EventListener listener) { Set<Class<?>> interfaces = InterfaceUtils.getInterfaces(listener.getClass(), new ClassFilterBuilder().extendsType(EventListener.class).build()); Set<Class<? extends EventListener>> registeredEvents = new HashSet<Class<? extends EventListener>>(); for (Class<?> interfaceClass : interfaces) { if (eventRegister.hasEventByInterface((Class<? extends EventListener>) interfaceClass)) { registeredEvents.add((Class<? extends EventListener>) interfaceClass); } } filterInterfaces(registeredEvents); return registeredEvents; }
/** * Register events for a channel. * * @param eventRegister Event Register. * @param channel Channel XML Configuration Element. * @param eventSet Set of events to register at the channel. **/ private void registerEventsForChannel(EventRegister eventRegister, KaEventConfig.Channels.Channel channel, Set<Class<? extends EventObject>> eventSet) { if (channel.getHandle() != null) { for (KaEventConfig.Channels.Channel.Handle handleEvent : channel.getHandle()) { String eventName = handleEvent.getEvent(); EventConfig eventConfig = eventRegister.getEventByName(eventName); if (eventConfig != null) { eventSet.add(eventConfig.getEventClass()); } else { throw new IllegalStateException("Event " + eventName + " could not be found!"); } } } }
/** * Import and register events from the eventExporter provided. * * @param eventExporter * Creates the events to register. * @param eventBuilderFactory * Used by the exporter. * @param eventRegister * Event Register. **/ protected void importAndRegisterEvents(EventExporter eventExporter, EventBuilderFactory eventBuilderFactory, EventRegister eventRegister) { Set<EventConfig> events; try { events = eventExporter.exportEvents(eventBuilderFactory); for (EventConfig event : events) { eventRegister.registerEvent(event); } } catch (RuntimeException re) { LOG.error("Error when importing annotated events", re); throw re; } catch (IOException e) { throw new IllegalStateException("Could not import events", e); } }
public void bridgeEvent(EventObject event) { if(eventRegister.hasEventByClass(event.getClass()) && filterExecutor.passFilters(bridgeFilters, event)){ fire(event); } }
@Override public void fire(EventObject event) throws IllegalArgumentException { EventConfig config = eventRegister.getEventByClass(event.getClass()); if(config == null) { throw new IllegalArgumentException(event.getClass() + " is not a registerd event."); } if(config.getEventQueue() != null) { config.getEventQueue().enqueue(event); } else { eventQueue.enqueue(event); } }
/** * Register @Event annotated events with the channels referenced in the channels attribute. * * @param config The configuration build this far. */ protected void registerEventsAtChannels(EventRegister eventRegister, ChannelFactory channelFactory, ChannelRegister channelRegister) { for (Class<? extends EventObject> eventClass : eventRegister.getEventClasses()) { Event eventAnno = eventClass.getAnnotation(Event.class); if (eventAnno != null && eventAnno.channels().length > 0) { registerEventAtChannelByAnnotation(channelFactory, channelRegister, eventClass, eventAnno); } } }
/** * Invokes event on all listeners. * * If blocked is true exceptions are thrown else exceptions are logged and suppressed. * * @param event Event to invoke. * @param listeners Collection if listener to invoke the event method on. * @param throwException Exception handling type, true throws exception and false suppresses exceptions. **/ @Override public void invokeEventMethod(EventObject event, Collection<EventListenerRegistration> listeners, boolean throwException) { if (listeners != null && listeners.size() > 0) { EventConfig eventConfig = eventRegister.getEventByClass(event.getClass()); for (EventListenerRegistration listener : listeners) { Method method = eventConfig.getEventMethod(event, listener.getListener()); invokeEvent(event, throwException, method, listener); } } }
/** * Register a new Event type to the register. * * @param eventClass * New event type to handle * * @throws NoSuchEventException if no event can be found of type eventClass. **/ @Override public void registerEvent(Class<? extends EventObject> eventClass) throws NoSuchEventException { EventConfig eventConfig = eventRegister.getEventByClass(eventClass); if (!eventMap.containsKey(eventClass)) { if(eventConfig.getListener() != null) { eventMap.put(eventClass, eventConfig.getListener()); } channelRegister.registerEventHandler(this, eventClass); } }
/** * Invokes event on all listeners. * * If blocked is true exceptions are thrown else exceptions are logged and suppressed. * * @param event Event to invoke. * @param listeners Collection if listener to invoke the event method on. * @param throwException Exception handling type, true throws exception and false suppresses exceptions. **/ @Override public void invokeEventMethod(EventObject event, Collection<EventListenerRegistration> listeners, boolean throwException) { if (listeners != null && listeners.size() > 0) { EventConfig eventConfig = eventRegister.getEventByClass(event.getClass()); for (EventListenerRegistration listener : listeners) { Method method = eventConfig.getEventMethod(event, listener.getListener()); invokeEvent(event, throwException, method, listener); } } }