@Override public void addEvent(String listenerName, Event event) { Map<String, RegisteredListener> listeners = getListenersByEvent().get(event.getClass()); if (listeners == null) { listeners = new ConcurrentHashMap<String, RegisteredListener>(); this.listenersByEvent.put(event.getClass(), listeners); } RegisteredListener listener = listeners.get(listenerName); if (listener != null) { listener.addEvent(event); } else { listeners.put(listenerName, new RegisteredListener(this.getListener(listenerName), event)); } }
@Override public void notify(Event event, Object source, Object data) { // Find all listeners for this event Map<String, RegisteredListener> regListeners = getListenersByEvent().get(event.getClass()); if (regListeners != null) { notify(regListeners.values(), event, source, data); } // Find listener listening all events Map<String, RegisteredListener> allEventRegListeners = this.listenersByEvent.get(AllEvent.class); if (allEventRegListeners != null) { notify(allEventRegListeners.values(), event, source, data); } // We want this Observation Manager to be able to handle new Event Listener components being // added or removed // at runtime. Thus ideally we should make this Manager an Event Listener itself. However in // order to avoid // circular dependencies issues and in order to be more performant we simply handle // ComponentDescriptorEvents // here to add/remove Event Listeners. if (event instanceof ComponentDescriptorEvent) { onComponentEvent( (ComponentDescriptorEvent) event, (ComponentManager) source, (ComponentDescriptor<EventListener>) data); } }
@Override public void removeEvent(String listenerName, Event event) { Map<String, RegisteredListener> listeners = getListenersByEvent().get(event.getClass()); RegisteredListener listener = listeners.get(listenerName); if (listener != null) { listener.removeEvent(event); } }
@Override public void addListener(EventListener eventListener) { // Register the listener by name. If already registered, override it. EventListener previousListener = getListenersByName().put(eventListener.getName(), eventListener); // If the passed event listener name is already registered, log a warning if (previousListener != null) { this.logger.warn( "The [{}] listener has overwritten a previously " + "registered listener [{}] since they both are registered under the same id [{}]. " + "In the future consider removing a Listener first if you really want to register it again.", new Object[] { eventListener.getClass().getName(), previousListener.getClass().getName(), eventListener.getName() }); } // For each event defined for this listener, add it to the Event Map. for (Event event : eventListener.getEvents()) { // Check if this is a new Event type not already registered Map<String, RegisteredListener> eventListeners = this.listenersByEvent.get(event.getClass()); if (eventListeners == null) { // No listener registered for this event yet. Create a map to store listeners for this // event. eventListeners = new ConcurrentHashMap<String, RegisteredListener>(); this.listenersByEvent.put(event.getClass(), eventListeners); // There is no RegisteredListener yet, create one eventListeners.put(eventListener.getName(), new RegisteredListener(eventListener, event)); } else { // Add an event to existing RegisteredListener object RegisteredListener registeredListener = eventListeners.get(eventListener.getName()); if (registeredListener == null) { eventListeners.put(eventListener.getName(), new RegisteredListener(eventListener, event)); } else { registeredListener.addEvent(event); } } } }
@Test public void testGetEvents() { Set<Class<? extends Event>> eventClasses = new HashSet<Class<? extends Event>>(); for (Event theEvent : listener.getEvents()) { eventClasses.add(theEvent.getClass()); } assertEquals(2, eventClasses.size()); assertTrue( "Expecting registration for DocumentUpdatingEvent", eventClasses.contains(DocumentUpdatingEvent.class)); assertTrue( "Expecting registration for DocumentUpdatedEvent events", eventClasses.contains(DocumentUpdatedEvent.class)); }