AbstractEventListenerContainer (GigaSpaces 16.4.0 API)

java.lang.Object
- org.openspaces.events.AbstractEventListenerContainer

All Implemented Interfaces:

InternalDumpProcessor, EventListener, ProcessingUnitContainerContextAware, ServiceDetailsProvider, ServiceMonitorsProvider, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.DisposableBean, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, org.springframework.context.ApplicationListener<org.springframework.context.ApplicationEvent>, org.springframework.context.Lifecycle

Direct Known Subclasses:

SimpleAsyncPollingEventListenerContainer, SimpleNotifyEventListenerContainer, SimplePollingEventListenerContainer
```
public abstract class AbstractEventListenerContainer
extends Object
implements org.springframework.context.ApplicationContextAware, org.springframework.context.Lifecycle, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.DisposableBean, org.springframework.context.ApplicationListener<org.springframework.context.ApplicationEvent>, ServiceDetailsProvider, ServiceMonitorsProvider, ProcessingUnitContainerContextAware, InternalDumpProcessor
```
A simple based class for SpaceDataEventListener based containers. Allowing to register a listener and provides several support methods like invokeListener(SpaceDataEventListener, Object, org.springframework.transaction.TransactionStatus, Object) in order to simplify event listener based containers.

Author:

kimchy

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`beanName`
`protected boolean`	`disableTransactionValidation`
`protected EventExceptionHandler`	`exceptionHandler`
`protected org.apache.commons.logging.Log`	`logger`
`protected ThreadLocal<EntrySnapshot>`	`snapshotTemplateThreadLocal`

Constructor Summary

Constructors
Constructor and Description

AbstractEventListenerContainer()

Constructors
Constructor and Description
`AbstractEventListenerContainer()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`afterPropertiesSet()` Delegates to `validateConfiguration()` and `initialize()`.
`void`	`destroy()` Calls `shutdown()` when the BeanFactory destroys the container instance.
`protected void`	`doAfterStart()`
`protected void`	`doBeforeStop()`
`protected abstract void`	`doInitialize()` A callback to perform custom initialization steps.
`protected void`	`doRescheduleTask(Object task)` Reschedule the given task object immediately.
`protected abstract void`	`doShutdown()` Perform any custom shutdown operations.
`protected void`	`doStart()` Only start if we have a listener registered.
`protected void`	`doStop()` Notify all invoker tasks to stop
`protected void`	`dump(PrintWriter writer)`
`protected void`	`executeListener(SpaceDataEventListener eventListener, Object eventData, org.springframework.transaction.TransactionStatus txStatus, Object source)` Executes the given listener if the container is running (`isRunning()`.
`protected Object`	`getActualEventListener()`
`org.springframework.context.ApplicationContext`	`getApplicationContext()`
`String`	`getBeanName()` Return the bean name that this listener container has been assigned in its containing bean factory, if any.
`protected SpaceDataEventListener`	`getEventListener()`
`protected Class<?>`	`getEventListenerClass()`
`protected abstract String`	`getEventListenerContainerType()`
`EventExceptionHandler`	`getExceptionHandler()`
`long`	`getFailedEvents()`
`GigaSpace`	`getGigaSpace()` Returns the GigaSpace instance to be used for Space operations.
`long`	`getProcessedEvents()`
`Object`	`getReceiveTemplate()` Returns the template to be used for receive operations.
`protected String`	`getStatus()`
`Object`	`getTemplate()` Returns the template that will be used.
`protected org.springframework.transaction.support.DefaultTransactionDefinition`	`getTransactionDefinition()`
`org.springframework.transaction.PlatformTransactionManager`	`getTransactionManager()` Return the Spring PlatformTransactionManager to use for transactional wrapping of message reception plus listener execution.
`String`	`getTransactionManagerName()`
`protected void`	`handleListenerException(Throwable ex)` Handles exception that occurs during the event listening process.
`protected void`	`incrementFailedEvents()`
`void`	`initialize()` Initialize this container.
`protected void`	`invokeExceptionListener(Exception e)` A callback to handle exception.
`protected void`	`invokeListener(SpaceDataEventListener eventListener, Object eventData, org.springframework.transaction.TransactionStatus txStatus, Object source)` Invokes the configured `SpaceDataEventListener` based on the provided data.
`boolean`	`isActive()` Return whether this container is currently active, that is, whether it has been set up but not shut down yet.
`boolean`	`isDynamicTemplate()` Returns whether dynamic template is configured
`protected boolean`	`isPerformSnapshot()`
`boolean`	`isRunning()` Return whether this container is currently running, that is, whether it has been started and not stopped yet.
`boolean`	`isTransactional()`
`protected String`	`message(String message)`
`void`	`onApplicationEvent(org.springframework.context.ApplicationEvent applicationEvent)` If the `setActiveWhenPrimary(boolean)` is set to `true` (the default), the container lifecycle will be controlled by the space mode.
`void`	`process(InternalDump dump)`
`protected void`	`registerMetrics()`
`protected boolean`	`requiresStopStart()`
`protected boolean`	`rescheduleTaskIfNecessary(Object task)` Take the given task object and reschedule it, either immediately if this container is currently running, or later once this container has been restarted.
`void`	`setActiveWhenPrimary(boolean activeWhenPrimary)` Set whether this container will start only when it is primary (space mode).
`void`	`setApplicationContext(org.springframework.context.ApplicationContext applicationContext)`
`void`	`setAutoStart(boolean initOnStartup)` Set whether this container will start once instantiated.
`void`	`setBeanName(String beanName)`
`void`	`setDisableTransactionValidation(boolean disableTransactionValidation)` Should transaction validation be enabled or not (verify and fail if transaction manager is provided and the GigaSpace is not transactional).
`void`	`setDynamicTemplate(Object dynamicTemplate)` Called before each take and read polling operation to change the template Overrides any template defined with `setTemplate(Object)`
`void`	`setEventListener(SpaceDataEventListener eventListener)` Sets the event listener implementation that will be used to delegate events to.
`void`	`setEventListenerRef(String eventListenerRef)` Sets an event listener bean reference name that will be used to lookup the actual listener bean (based on its name).
`void`	`setExceptionHandler(EventExceptionHandler exceptionHandler)` Sets an exception handler that will be invoked when an exception occurs on the listener allowing to customize the handling of such cases.
`void`	`setGigaSpace(GigaSpace gigaSpace)` Sets the GigaSpace instance to be used for space event listening operations.
`void`	`setPerformSnapshot(boolean performSnapshot)` If set to `true` will perform prepareTemplate operation on the provided template before invoking registering as an event listener.
`void`	`setProcessingUnitContainerContext(ProcessingUnitContainerContext processingUnitContainerContext)` Sets the processing unit container context.
`void`	`setRegisterSpaceModeListener(boolean registerSpaceModeListener)`
`void`	`setTemplate(Object template)` Sets the specified template to be used with the polling space operation.
`void`	`setTransactionIsolationLevel(int transactionIsolationLevel)` Specify the transaction isolation to use for transactional wrapping.
`void`	`setTransactionIsolationLevelName(String transactionIsolationLevelName)` Specify the transaction isolation to use for transactional wrapping.
`void`	`setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)` Specify the Spring `PlatformTransactionManager` to use for transactional wrapping of listener execution.
`void`	`setTransactionName(String transactionName)` Specify the transaction name to use for transactional wrapping.
`void`	`setTransactionTimeout(int transactionTimeout)` Specify the transaction timeout to use for transactional wrapping, in seconds.
`void`	`shutdown()` Stop container, call `doShutdown()`, and close this container.
`void`	`start()` Start this container.
`void`	`stop()` Stop this container.
`protected void`	`unregisterMetrics()`
`protected void`	`validateConfiguration()` Validate the configuration of this container.
`protected void`	`waitWhileNotRunning()` Wait while this container is not running.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.springframework.context.ApplicationListener
forPayload

Methods inherited from interface org.openspaces.pu.service.ServiceDetailsProvider
getServicesDetails

Methods inherited from interface org.openspaces.pu.service.ServiceMonitorsProvider
getServicesMonitors

Methods inherited from interface com.gigaspaces.internal.dump.InternalDumpProcessor
getName

- Field Detail
  - logger
```
protected final org.apache.commons.logging.Log logger
```
  - beanName
```
protected String beanName
```
  - exceptionHandler
```
protected EventExceptionHandler exceptionHandler
```
  - disableTransactionValidation
```
protected boolean disableTransactionValidation
```
  - snapshotTemplateThreadLocal
```
protected ThreadLocal<EntrySnapshot> snapshotTemplateThreadLocal
```
- Constructor Detail
  - AbstractEventListenerContainer
```
public AbstractEventListenerContainer()
```
- Method Detail
  - setGigaSpace
```
public void setGigaSpace(GigaSpace gigaSpace)
```
    Sets the GigaSpace instance to be used for space event listening operations.
  - getGigaSpace
```
public final GigaSpace getGigaSpace()
```
    Returns the GigaSpace instance to be used for Space operations.
  - setBeanName
```
public void setBeanName(String beanName)
```
    Specified by:
    
    setBeanName in interface org.springframework.beans.factory.BeanNameAware
  - getBeanName
```
public final String getBeanName()
```
    Return the bean name that this listener container has been assigned in its containing bean factory, if any.
  - setActiveWhenPrimary
```
public void setActiveWhenPrimary(boolean activeWhenPrimary)
```
    Set whether this container will start only when it is primary (space mode).
    Default is true. Set to false in order for this container to always start regardless of the space mode.
  - setRegisterSpaceModeListener
```
public void setRegisterSpaceModeListener(boolean registerSpaceModeListener)
```
  - setAutoStart
```
public void setAutoStart(boolean initOnStartup)
```
    Set whether this container will start once instantiated.
    Default is true. Set to false in order for this container to be started using start().
  - isRunning
```
public final boolean isRunning()
```
    Return whether this container is currently running, that is, whether it has been started and not stopped yet.
    
    Specified by:
    
    isRunning in interface org.springframework.context.Lifecycle
  - isActive
```
public final boolean isActive()
```
    Return whether this container is currently active, that is, whether it has been set up but not shut down yet.
  - getStatus
```
protected String getStatus()
```
  - getExceptionHandler
```
public EventExceptionHandler getExceptionHandler()
```
  - setExceptionHandler
```
public void setExceptionHandler(EventExceptionHandler exceptionHandler)
```
    Sets an exception handler that will be invoked when an exception occurs on the listener allowing to customize the handling of such cases.
  - setEventListener
```
public void setEventListener(SpaceDataEventListener eventListener)
```
    Sets the event listener implementation that will be used to delegate events to. Also see different adapter classes provided for simpler event listeners integration.
    
    Parameters:
    
    eventListener - The event listener used
  - setEventListenerRef
```
public void setEventListenerRef(String eventListenerRef)
```
    Sets an event listener bean reference name that will be used to lookup the actual listener bean (based on its name). Mainly used when configuring a listener with specific scope setting (such as prototype) allowing to scope to take affect by using getBean for each request of the listener.
  - getEventListener
```
protected SpaceDataEventListener getEventListener()
```
  - getActualEventListener
```
protected Object getActualEventListener()
```
  - setApplicationContext
```
public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
```
    Specified by:
    
    setApplicationContext in interface org.springframework.context.ApplicationContextAware
  - setProcessingUnitContainerContext
```
public void setProcessingUnitContainerContext(ProcessingUnitContainerContext processingUnitContainerContext)
```
    Description copied from interface: ProcessingUnitContainerContextAware
    
    Sets the processing unit container context.
    
    Specified by:
    
    setProcessingUnitContainerContext in interface ProcessingUnitContainerContextAware
    
    Parameters:
    
    processingUnitContainerContext - The processing unit container context to be injected
  - getApplicationContext
```
public org.springframework.context.ApplicationContext getApplicationContext()
```
  - getEventListenerClass
```
protected Class<?> getEventListenerClass()
```
  - afterPropertiesSet
```
public void afterPropertiesSet()
```
    Delegates to validateConfiguration() and initialize().
    
    Specified by:
    
    afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean
  - initialize
```
public void initialize()
                throws org.springframework.dao.DataAccessException
```
    Initialize this container. If this container is not configured with "activeWhenPrimary" flag set to true will call doStart() (if it is set to true, lifecycle of the container will be controlled by the current space mode). doInitialize() will be called for additional initialization after the possible doStart() call.
    
    Throws:
    
    org.springframework.dao.DataAccessException
    
    See Also:
    
    onApplicationEvent(org.springframework.context.ApplicationEvent)
  - doInitialize
```
protected abstract void doInitialize()
                              throws org.springframework.dao.DataAccessException
```
    A callback to perform custom initialization steps.
    
    Throws:
    
    org.springframework.dao.DataAccessException
  - validateConfiguration
```
protected void validateConfiguration()
```
    Validate the configuration of this container.
  - destroy
```
public void destroy()
```
    Calls shutdown() when the BeanFactory destroys the container instance.
    
    Specified by:
    
    destroy in interface org.springframework.beans.factory.DisposableBean
    
    See Also:
    
    shutdown()
  - shutdown
```
public void shutdown()
              throws org.springframework.dao.DataAccessException
```
    Stop container, call doShutdown(), and close this container.
    
    Throws:
    
    org.springframework.dao.DataAccessException
  - doShutdown
```
protected abstract void doShutdown()
                            throws org.springframework.dao.DataAccessException
```
    Perform any custom shutdown operations.
    
    Throws:
    
    org.springframework.dao.DataAccessException
    
    See Also:
    
    shutdown()
  - start
```
public void start()
           throws org.springframework.dao.DataAccessException
```
    Start this container.
    
    Specified by:
    
    start in interface org.springframework.context.Lifecycle
    
    Throws:
    
    org.springframework.dao.DataAccessException
    
    See Also:
    
    doStart()
  - doStart
```
protected void doStart()
                throws org.springframework.dao.DataAccessException
```
    Only start if we have a listener registered. If we don't, then explicit start should be called.
    
    Throws:
    
    org.springframework.dao.DataAccessException
  - doAfterStart
```
protected void doAfterStart()
                     throws org.springframework.dao.DataAccessException
```
    Throws:
    
    org.springframework.dao.DataAccessException
  - stop
```
public void stop()
          throws org.springframework.dao.DataAccessException
```
    Stop this container.
    
    Specified by:
    
    stop in interface org.springframework.context.Lifecycle
    
    Throws:
    
    org.springframework.dao.DataAccessException
    
    See Also:
    
    doStop()
  - doStop
```
protected void doStop()
               throws org.springframework.dao.DataAccessException
```
    Notify all invoker tasks to stop
    
    Throws:
    
    org.springframework.dao.DataAccessException
  - doBeforeStop
```
protected void doBeforeStop()
                     throws org.springframework.dao.DataAccessException
```
    Throws:
    
    org.springframework.dao.DataAccessException
  - onApplicationEvent
```
public void onApplicationEvent(org.springframework.context.ApplicationEvent applicationEvent)
```
    If the setActiveWhenPrimary(boolean) is set to true (the default), the container lifecycle will be controlled by the space mode. The container will start when the space is in PRIMARY mode, and will stop when the space is in BACKUP mode.
    Note, this might cause doStart() or doStop() to be called several times in a row, and sub classes should take this into account.
    
    Specified by:
    
    onApplicationEvent in interface org.springframework.context.ApplicationListener<org.springframework.context.ApplicationEvent>
  - waitWhileNotRunning
```
protected final void waitWhileNotRunning()
```
    Wait while this container is not running.
    To be called by asynchronous tasks that want to block while the container is in stopped state.
  - rescheduleTaskIfNecessary
```
protected final boolean rescheduleTaskIfNecessary(Object task)
```
    Take the given task object and reschedule it, either immediately if this container is currently running, or later once this container has been restarted.
    If this container has already been shut down, the task will not get rescheduled at all.
    
    Parameters:
    
    task - the task object to reschedule
    
    Returns:
    
    whether the task has been rescheduled (either immediately or for a restart of this container)
    
    See Also:
    
    doRescheduleTask(java.lang.Object)
  - doRescheduleTask
```
protected void doRescheduleTask(Object task)
```
    Reschedule the given task object immediately.
    To be implemented by subclasses if they ever call rescheduleTaskIfNecessary. This implementation throws an UnsupportedOperationException.
    
    Parameters:
    
    task - the task object to reschedule
    
    See Also:
    
    rescheduleTaskIfNecessary(java.lang.Object)
  - executeListener
```
protected void executeListener(SpaceDataEventListener eventListener,
                               Object eventData,
                               org.springframework.transaction.TransactionStatus txStatus,
                               Object source)
                        throws Throwable
```
    Executes the given listener if the container is running (isRunning().
    
    Parameters:
    
    eventData - The event data object
    
    txStatus - An optional transaction status allowing to rollback a transaction programmatically
    
    source - An optional source (or additional event information)
    
    Throws:
    
    Throwable
  - invokeListener
```
protected void invokeListener(SpaceDataEventListener eventListener,
                              Object eventData,
                              org.springframework.transaction.TransactionStatus txStatus,
                              Object source)
                       throws Throwable
```
    Invokes the configured SpaceDataEventListener based on the provided data. Currently simply delegates to SpaceDataEventListener.onEvent(Object, org.openspaces.core.GigaSpace, org.springframework.transaction.TransactionStatus, Object).
    
    Parameters:
    
    eventData - The event data object
    
    txStatus - An optional transaction status allowing to rollback a transaction programmatically
    
    source - An optional source (or additional event information)
    
    Throws:
    
    Throwable
  - handleListenerException
```
protected void handleListenerException(Throwable ex)
```
    Handles exception that occurs during the event listening process. Currently simply logs it.
    
    Parameters:
    
    ex - the exception to handle
  - invokeExceptionListener
```
protected void invokeExceptionListener(Exception e)
```
    A callback to handle exception. Possible extension point for registered exception listeners.
  - getProcessedEvents
```
public long getProcessedEvents()
```
  - getFailedEvents
```
public long getFailedEvents()
```
  - incrementFailedEvents
```
protected void incrementFailedEvents()
```
  - setTemplate
```
public void setTemplate(Object template)
```
    Sets the specified template to be used with the polling space operation.
    
    See Also:
    
    GigaSpace.take(Object, long)
  - getTemplate
```
public Object getTemplate()
```
    Returns the template that will be used. Note, in order to perform receive operations, the getReceiveTemplate() should be used.
  - setDynamicTemplate
```
public void setDynamicTemplate(Object dynamicTemplate)
```
    Called before each take and read polling operation to change the template Overrides any template defined with setTemplate(Object)
    
    Parameters:
    
    dynamicTemplate - - An object that implements DynamicEventTemplateProvider or has a method annotated with DynamicEventTemplateProvider
  - isDynamicTemplate
```
public boolean isDynamicTemplate()
```
    Returns whether dynamic template is configured
  - setPerformSnapshot
```
public void setPerformSnapshot(boolean performSnapshot)
```
    If set to true will perform prepareTemplate operation on the provided template before invoking registering as an event listener.
    
    See Also:
    
    GigaSpace.prepareTemplate(Object)
  - isPerformSnapshot
```
protected boolean isPerformSnapshot()
```
  - getReceiveTemplate
```
public Object getReceiveTemplate()
```
    Returns the template to be used for receive operations. If setPerformSnapshot(boolean) is set to true (the default) will return the snapshot of the provided template.
  - setTransactionManager
```
public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
```
    Specify the Spring PlatformTransactionManager to use for transactional wrapping of listener execution.
    Default is none, not performing any transactional wrapping.
  - getTransactionManager
```
public final org.springframework.transaction.PlatformTransactionManager getTransactionManager()
```
    Return the Spring PlatformTransactionManager to use for transactional wrapping of message reception plus listener execution.
  - setTransactionName
```
public void setTransactionName(String transactionName)
```
    Specify the transaction name to use for transactional wrapping. Default is the bean name of this listener container, if any.
    
    See Also:
    
    TransactionDefinition.getName()
  - setTransactionTimeout
```
public void setTransactionTimeout(int transactionTimeout)
```
    Specify the transaction timeout to use for transactional wrapping, in seconds. Default is none, using the transaction manager's default timeout.
    
    See Also:
    
    TransactionDefinition.getTimeout()
  - setTransactionIsolationLevel
```
public void setTransactionIsolationLevel(int transactionIsolationLevel)
```
    Specify the transaction isolation to use for transactional wrapping.
    
    See Also:
    
    DefaultTransactionDefinition.setIsolationLevel(int)
  - setTransactionIsolationLevelName
```
public void setTransactionIsolationLevelName(String transactionIsolationLevelName)
```
    Specify the transaction isolation to use for transactional wrapping.
    
    See Also:
    
    DefaultTransactionDefinition.setIsolationLevelName(String)
  - getTransactionDefinition
```
protected org.springframework.transaction.support.DefaultTransactionDefinition getTransactionDefinition()
```
  - setDisableTransactionValidation
```
public void setDisableTransactionValidation(boolean disableTransactionValidation)
```
    Should transaction validation be enabled or not (verify and fail if transaction manager is provided and the GigaSpace is not transactional). Default to false.
  - getTransactionManagerName
```
public String getTransactionManagerName()
```
  - isTransactional
```
public boolean isTransactional()
```
  - requiresStopStart
```
protected boolean requiresStopStart()
```
  - message
```
protected String message(String message)
```
  - process
```
public void process(InternalDump dump)
             throws InternalDumpProcessorFailedException
```
    Specified by:
    
    process in interface InternalDumpProcessor
    
    Throws:
    
    InternalDumpProcessorFailedException
  - dump
```
protected void dump(PrintWriter writer)
```
  - getEventListenerContainerType
```
protected abstract String getEventListenerContainerType()
```
  - registerMetrics
```
protected void registerMetrics()
```
  - unregisterMetrics
```
protected void unregisterMetrics()
```

Class AbstractEventListenerContainer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.context.ApplicationListener

Methods inherited from interface org.openspaces.pu.service.ServiceDetailsProvider

Methods inherited from interface org.openspaces.pu.service.ServiceMonitorsProvider

Methods inherited from interface com.gigaspaces.internal.dump.InternalDumpProcessor

Field Detail

logger

beanName

exceptionHandler

disableTransactionValidation

snapshotTemplateThreadLocal

Constructor Detail

AbstractEventListenerContainer

Method Detail

setGigaSpace

getGigaSpace

setBeanName

getBeanName

setActiveWhenPrimary

setRegisterSpaceModeListener

setAutoStart

isRunning

isActive

getStatus

getExceptionHandler

setExceptionHandler

setEventListener

setEventListenerRef

getEventListener

getActualEventListener

setApplicationContext

setProcessingUnitContainerContext

getApplicationContext

getEventListenerClass

afterPropertiesSet

initialize

doInitialize

validateConfiguration

destroy

shutdown

doShutdown

start

doStart

doAfterStart

stop

doStop

doBeforeStop

onApplicationEvent

waitWhileNotRunning

rescheduleTaskIfNecessary

doRescheduleTask

executeListener

invokeListener

handleListenerException

invokeExceptionListener

getProcessedEvents

getFailedEvents

incrementFailedEvents

setTemplate

getTemplate

setDynamicTemplate

isDynamicTemplate

setPerformSnapshot

isPerformSnapshot

getReceiveTemplate

setTransactionManager

getTransactionManager

setTransactionName

setTransactionTimeout

setTransactionIsolationLevel

setTransactionIsolationLevelName

getTransactionDefinition

setDisableTransactionValidation

getTransactionManagerName

isTransactional

requiresStopStart