Class AbstractListenerImpl<T,L extends ListenerInvocation<T>>

Type Parameters:
T - Defines the type of event that will be used by the subclass
L - Defines the type of ListenerInvocations that the subclasses use
Direct Known Subclasses:
CacheManagerNotifierImpl, CacheNotifierImpl

public abstract class AbstractListenerImpl<T,L extends ListenerInvocation<T>> extends Object
Functionality common to both CacheManagerNotifierImpl and CacheNotifierImpl
Manik Surtani, William Burns
  • Field Details

  • Constructor Details

    • AbstractListenerImpl

      public AbstractListenerImpl()
  • Method Details

    • stop

      public void stop()
      Removes all listeners from the notifier
    • resumeOnCPU

      protected CompletionStage<Void> resumeOnCPU(CompletionStage<Void> stage, Object traceId)
    • getLog

      protected abstract org.infinispan.util.logging.Log getLog()
    • getAllowedMethodAnnotations

      protected abstract Map<Class<? extends Annotation>,Class<?>> getAllowedMethodAnnotations(Listener l)
    • hasListener

      public boolean hasListener(Class<? extends Annotation> annotationClass)
    • getListenerCollectionForAnnotation

      protected List<L> getListenerCollectionForAnnotation(Class<? extends Annotation> annotation)
    • removeListenerAsync

      public abstract CompletionStage<Void> removeListenerAsync(Object listener)
    • composeStageIfNeeded

      protected static AggregateCompletionStage<Void> composeStageIfNeeded(AggregateCompletionStage<Void> aggregateCompletionStage, CompletionStage<Void> stage)
      If the given stage is null or normally completed returns the provided aggregateCompletionStage as is. Otherwise the stage is used as a dependant for the provided aggregateCompletionStage if provided or a new one is created that depends upon the provided stage. The existing or new aggregateCompletionStage is then returned to the caller.
      aggregateCompletionStage - the existing composed stage or null
      stage - the stage to rely upon
      null or a composed stage that relies upon the provided stage
    • removeListenerFromMaps

      protected void removeListenerFromMaps(Object listener)
    • removeListenerInvocation

      protected Set<L> removeListenerInvocation(Class<? extends Annotation> annotation, Object listener)
    • getListeners

      public Set<Object> getListeners()
    • validateAndAddListenerInvocations

      protected boolean validateAndAddListenerInvocations(Object listener, AbstractListenerImpl<T,L>.AbstractInvocationBuilder builder)
      Loops through all valid methods on the object passed in, and caches the relevant methods as ListenerInvocation for invocation by reflection. The builder provided will be used to create the listener invocations. This method will set the target, subject sync, and methods as needed. If other values are needed to be set they should be invoked before passing to this method.
      listener - object to be considered as a listener.
      builder - The builder to use to build the invocation
      true if annotated listener methods were found or false otherwise
    • validateAndAddFilterListenerInvocations

      protected boolean validateAndAddFilterListenerInvocations(Object listener, AbstractListenerImpl<T,L>.AbstractInvocationBuilder builder, Set<Class<? extends Annotation>> filterAnnotations)
    • canApply

      public boolean canApply(Set<Class<? extends Annotation>> filterAnnotations, Class<? extends Annotation> annotationClass)
    • findListenerCallbacks

      protected Set<Class<? extends Annotation>> findListenerCallbacks(Object listener)
    • testListenerClassValidity

      protected static Listener testListenerClassValidity(Class<?> listenerClass)
      Tests if a class is properly annotated as a CacheListener and returns the Listener annotation.
      listenerClass - class to inspect
      the Listener annotation
    • testListenerMethodValidity

      protected static void testListenerMethodValidity(Method m, Class<?> allowedParameter, String annotationName)
      Tests that a method is a valid listener method, that is that it has a single argument that is assignable to allowedParameter. The method must also return either void or a CompletionStage, meaning the method promises not block.
      m - method to test
      allowedParameter - what parameter is allowed for the method argument
      annotationName - name of the annotation
      IncorrectListenerException - if the listener is not a valid target
    • invokeListeners

      protected CompletionStage<Void> invokeListeners(T event, Collection<L> listeners)
    • handleException

      protected void handleException(Throwable t)
    • suspendIfNeeded

      protected abstract javax.transaction.Transaction suspendIfNeeded()
    • resumeIfNeeded

      protected abstract void resumeIfNeeded(javax.transaction.Transaction transaction)