/** * Removes listeners for a single event type. */ public void clear(int type) { eventCallbacks[type].clear(); }
/** * Invokes callbacks for a collection of entity objects. */ void performCallbacks(Collection<?> objects) { for (Object object : objects) { performCallbacks((Persistent) object); } }
/** * Invokes callbacks for a given entity object. */ void performCallbacks(Persistent object) { if(object == null) { // this can happen if object resolved to null from some query with outer join // (e.g. in EJBQL or SQLTemplate) return; } // default listeners are invoked first if (!defaultListeners.isEmpty() && !excludingDefaultListeners(object.getObjectId().getEntityName())) { for (AbstractCallback listener : defaultListeners) { listener.performCallback(object); } } // apply per-entity listeners performCallbacks(object, object.getClass()); }
/** * Invokes callbacks for the class hierarchy, starting from the most generic * superclass. */ private void performCallbacks(Persistent object, Class<?> callbackEntityClass) { if (callbackEntityClass == null || Object.class.equals(callbackEntityClass)) { return; } // recursively perform super callbacks first if (!excludingSuperclassListeners(object.getObjectId().getEntityName())) { performCallbacks(object, callbackEntityClass.getSuperclass()); } // perform callbacks on provided class String key = callbackEntityClass.getName(); Collection<AbstractCallback> entityListeners = listeners.get(key); if (entityListeners != null) { for (final AbstractCallback listener : entityListeners) { listener.performCallback(object); } } }
eventCallbacks[reader.eventType().ordinal()].addListener(type, listener, m); eventCallbacks[reader.eventType().ordinal()].addDefaultListener(listener, m.getName());
/** * Registers callback method to be invoked on a provided non-entity object when a * lifecycle event occurs. */ void addListener(Class<?> entityClass, Object listener, String methodName) { CallbackOnListener callback = new CallbackOnListener( listener, methodName, entityClass); addCallback(entityClass, callback); }
/** * Registers callback method to be invoked on a provided non-entity object * when a lifecycle event occurs for a specific entity. */ public void addListener(LifecycleEvent type, Class<?> entityClass, Object listener, String methodName) { eventCallbacks[type.ordinal()].addListener(entityClass, listener, methodName); }
/** * Registers a callback method to be invoked on a provided non-entity object * when a lifecycle event occurs on any entity that does not suppress * default callbacks. */ public void addDefaultListener(LifecycleEvent type, Object listener, String methodName) { eventCallbacks[type.ordinal()].addDefaultListener(listener, methodName); }
/** * Registers a callback method to be invoked on a provided non-entity object when a * lifecycle event occurs on any entity that does not suppress default callbacks. */ void addDefaultListener(Object listener, String methodName) { CallbackOnListener callback = new CallbackOnListener(listener, methodName); addDefaultCallback(callback); }
/** * Returns true if there are no listeners for a specific event type. */ public boolean isEmpty(LifecycleEvent type) { return eventCallbacks[type.ordinal()].isEmpty(); }
/** * Creates an empty callback registry. */ public LifecycleCallbackRegistry(EntityResolver resolver) { this.entityResolver = resolver; // initialize callbacks map in constructor to avoid synchronization // issues // downstream. this.eventCallbacks = new LifecycleCallbackEventHandler[LifecycleEvent.values().length]; for (int i = 0; i < eventCallbacks.length; i++) { eventCallbacks[i] = new LifecycleCallbackEventHandler(resolver); } // other "static" lookup maps are initialized on-demand this.entitiesByAnnotation = new ConcurrentHashMap<>(); }
/** * Registers a callback method to be invoked on an entity class instances when a * lifecycle event occurs. */ void addListener(Class<?> entityClass, String methodName) { addCallback(entityClass, new CallbackOnEntity(entityClass, methodName)); }
/** * Registers a callback method to be invoked on an entity class instances * when a lifecycle event occurs. * * @since 4.0 */ public void addCallback(LifecycleEvent type, Class<?> entityClass, String methodName) { eventCallbacks[type.ordinal()].addListener(entityClass, methodName); }
/** * Invokes callbacks of a specific type for a given entity object. */ public void performCallbacks(LifecycleEvent type, Persistent object) { eventCallbacks[type.ordinal()].performCallbacks(object); }
void addListener(Class<?> entityClass, Object listener, Method method) { CallbackOnListener callback = new CallbackOnListener( listener, method, entityClass); addCallback(entityClass, callback); }
/** * Removes all listeners for all event types. */ public void clear() { for (LifecycleCallbackEventHandler eventCallback : eventCallbacks) { eventCallback.clear(); } }
/** * Invokes callbacks of a specific type for a collection of entity objects. */ public void performCallbacks(LifecycleEvent type, Collection<?> objects) { eventCallbacks[type.ordinal()].performCallbacks(objects); }