org.springframework.jms.listener

## Class AbstractMessageListenerContainer

- java.lang.Object
- - org.springframework.jms.support.JmsAccessor
  - - org.springframework.jms.support.destination.JmsDestinationAccessor
    - - org.springframework.jms.listener.AbstractJmsListeningContainer
      - - org.springframework.jms.listener.AbstractMessageListenerContainer

- All Implemented Interfaces:
    Aware, BeanNameAware, DisposableBean, InitializingBean, Lifecycle, Phased, SmartLifecycle, MessageListenerContainer
  Direct Known Subclasses:
    AbstractPollingMessageListenerContainer, SimpleMessageListenerContainer

      public abstract class AbstractMessageListenerContainer
      extends AbstractJmsListeningContainer
      implements MessageListenerContainer

  Abstract base class for Spring message listener container implementations. Can either host a standard JMS `MessageListener` or Spring's `SessionAwareMessageListener` for actual message processing.

  Usually holds a single JMS `Connection` that all listeners are supposed to be registered on, which is the standard JMS way of managing listener sessions. Can alternatively also be used with a fresh Connection per listener, for Java EE style XA-aware JMS messaging. The actual registration process is up to concrete subclasses.

  NOTE: The default behavior of this message listener container is to never propagate an exception thrown by a message listener up to the JMS provider. Instead, it will log any such exception at the error level. This means that from the perspective of the attendant JMS provider no such listener will ever fail. However, if error handling is necessary, then any implementation of the `ErrorHandler` strategy may be provided to the `setErrorHandler(ErrorHandler)` method. Note that JMSExceptions will be passed to the ErrorHandler in addition to (but after) being passed to an `ExceptionListener`, if one has been provided.

  The listener container offers the following message acknowledgment options:

  - "sessionAcknowledgeMode" set to "AUTO_ACKNOWLEDGE" (default): This mode is container-dependent: For `DefaultMessageListenerContainer`, it means automatic message acknowledgment before listener execution, with no redelivery in case of an exception and no redelivery in case of other listener execution interruptions either. For `SimpleMessageListenerContainer`, it means automatic message acknowledgment after listener execution, with no redelivery in case of a user exception thrown but potential redelivery in case of the JVM dying during listener execution. In order to consistently arrange for redelivery with any container variant, consider "CLIENT_ACKNOWLEDGE" mode or - preferably - setting "sessionTransacted" to "true" instead.
  - "sessionAcknowledgeMode" set to "DUPS_OK_ACKNOWLEDGE": Lazy message acknowledgment during (`DefaultMessageListenerContainer`) or shortly after (`SimpleMessageListenerContainer`) listener execution; no redelivery in case of a user exception thrown but potential redelivery in case of the JVM dying during listener execution. In order to consistently arrange for redelivery with any container variant, consider "CLIENT_ACKNOWLEDGE" mode or - preferably - setting "sessionTransacted" to "true" instead.
  - "sessionAcknowledgeMode" set to "CLIENT_ACKNOWLEDGE": Automatic message acknowledgment after successful listener execution; best-effort redelivery in case of a user exception thrown as well as in case of other listener execution interruptions (such as the JVM dying).
  - "sessionTransacted" set to "true": Transactional acknowledgment after successful listener execution; guaranteed redelivery in case of a user exception thrown as well as in case of other listener execution interruptions (such as the JVM dying).

  There are two solutions to the duplicate message processing problem:

  - Either add duplicate message detection to your listener, in the form of a business entity existence check or a protocol table check. This usually just needs to be done in case of the JMSRedelivered flag being set on the incoming message (otherwise just process straightforwardly). Note that with "sessionTransacted" set to "true", duplicate messages will only appear in case of the JVM dying at the most unfortunate point possible (i.e. after your business logic executed but before the JMS part got committed), so duplicate message detection is just there to cover a corner case.
  - Or wrap your entire processing with an XA transaction, covering the reception of the JMS message as well as the execution of the business logic in your message listener (including database operations etc). This is only supported by `DefaultMessageListenerContainer`, through specifying an external "transactionManager" (typically a `JtaTransactionManager`, with a corresponding XA-aware JMS `ConnectionFactory` passed in as "connectionFactory").
  Note that XA transaction coordination adds significant runtime overhead, so it might be feasible to avoid it unless absolutely necessary.

  Recommendations:

  - The general recommendation is to set "sessionTransacted" to "true", typically in combination with local database transactions triggered by the listener implementation, through Spring's standard transaction facilities. This will work nicely in Tomcat or in a standalone environment, often combined with custom duplicate message detection (if it is unacceptable to ever process the same message twice).
  - Alternatively, specify a `JtaTransactionManager` as "transactionManager" for a fully XA-aware JMS provider - typically when running on a Java EE server, but also for other environments with a JTA transaction manager present. This will give full "exactly-once" guarantees without custom duplicate message checks, at the price of additional runtime processing overhead.

  Note that the "sessionTransacted" flag is strongly recommended over `JmsTransactionManager`, provided that transactions do not need to be managed externally. As a consequence, set the transaction manager only if you are using JTA or if you need to synchronize with custom external transaction arrangements.

  Since:
    2.0
  Author:
    Juergen Hoeller, Stephane Nicoll
  See Also:
    `setMessageListener(java.lang.Object)`, `MessageListener`, `SessionAwareMessageListener`, `handleListenerException(java.lang.Throwable)`, `DefaultMessageListenerContainer`, `SimpleMessageListenerContainer`, `JmsMessageEndpointManager`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer

      `AbstractJmsListeningContainer.SharedConnectionNotInitializedException`

  - ### Field Summary

    - ### Fields inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer

      `lifecycleMonitor, sharedConnectionMonitor`

    - ### Fields inherited from class org.springframework.jms.support.destination.JmsDestinationAccessor

      `RECEIVE_TIMEOUT_INDEFINITE_WAIT, RECEIVE_TIMEOUT_NO_WAIT`

    - ### Fields inherited from class org.springframework.jms.support.JmsAccessor

      `logger`

    - ### Fields inherited from interface org.springframework.context.SmartLifecycle

      `DEFAULT_PHASE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractMessageListenerContainer()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `checkMessageListener(Object messageListener)` Check the given message listener, throwing an exception if it does not correspond to a supported listener type.
    `protected void` | `commitIfNecessary(Session session, Message message)` Perform a commit or message acknowledgement, as appropriate.
    `protected MessageConsumer` | `createConsumer(Session session, Destination destination)` Create a JMS MessageConsumer for the given Session and Destination.
    `protected void` | `doExecuteListener(Session session, Message message)` Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).
    `protected void` | `doInvokeListener(MessageListener listener, Message message)` Invoke the specified listener as standard JMS MessageListener.
    `protected void` | `doInvokeListener(SessionAwareMessageListener listener, Session session, Message message)` Invoke the specified listener as Spring SessionAwareMessageListener, exposing a new JMS Session (potentially with its own transaction) to the listener if demanded.
    `protected void` | `executeListener(Session session, Message message)` Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).
    `protected String` | `getDefaultSubscriptionName(Object messageListener)` Determine the default subscription name for the given message listener.
    `Destination` | `getDestination()` Return the destination to receive messages from.
    `protected String` | `getDestinationDescription()` Return a descriptive String for this container's JMS destination (never `null`).
    `String` | `getDestinationName()` Return the name of the destination to receive messages from.
    `String` | `getDurableSubscriptionName()` Return the name of a durable subscription to create, if any.
    `ErrorHandler` | `getErrorHandler()` Return the ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message.
    `ExceptionListener` | `getExceptionListener()` Return the JMS ExceptionListener to notify in case of a JMSException thrown by the registered message listener or the invocation infrastructure, if any.
    `MessageConverter` | `getMessageConverter()` Return the `MessageConverter` that can be used to convert `Message`, if any.
    `Object` | `getMessageListener()` Return the message listener object to register.
    `String` | `getMessageSelector()` Return the JMS message selector expression (or `null` if none).
    `QosSettings` | `getReplyQosSettings()` Return the `QosSettings` to use when sending a reply, or `null` if the broker's defaults should be used.
    `String` | `getSubscriptionName()` Return the name of a subscription to create, if any.
    `protected void` | `handleListenerException(Throwable ex)` Handle the given exception that arose during listener execution.
    `protected void` | `invokeErrorHandler(Throwable ex)` Invoke the registered ErrorHandler, if any.
    `protected void` | `invokeExceptionListener(JMSException ex)` Invoke the registered JMS ExceptionListener, if any.
    `protected void` | `invokeListener(Session session, Message message)` Invoke the specified listener: either as standard JMS MessageListener or (preferably) as Spring SessionAwareMessageListener.
    `boolean` | `isAcceptMessagesWhileStopping()` Return whether to accept received messages while the listener container in the process of stopping.
    `boolean` | `isExposeListenerSession()` Return whether to expose the listener JMS `Session` to a registered `SessionAwareMessageListener`.
    `boolean` | `isPubSubNoLocal()` Return whether to inhibit the delivery of messages published by its own connection.
    `boolean` | `isReplyPubSubDomain()` Return whether the Publish/Subscribe domain (`Topics`) is used for replies.
    `protected boolean` | `isSessionLocallyTransacted(Session session)` Check whether the given Session is locally transacted, that is, whether its transaction is managed by this listener container's Session handling and not by an external transaction coordinator.
    `boolean` | `isSubscriptionDurable()` Return whether to make the subscription durable.
    `boolean` | `isSubscriptionShared()` Return whether to make the subscription shared.
    `protected void` | `rollbackIfNecessary(Session session)` Perform a rollback, if appropriate.
    `protected void` | `rollbackOnExceptionIfNecessary(Session session, Throwable ex)` Perform a rollback, handling rollback exceptions properly.
    `void` | `setAcceptMessagesWhileStopping(boolean acceptMessagesWhileStopping)` Set whether to accept received messages while the listener container in the process of stopping.
    `abstract void` | `setConcurrency(String concurrency)` Specify concurrency limits.
    `void` | `setDestination(Destination destination)` Set the destination to receive messages from.
    `void` | `setDestinationName(String destinationName)` Set the name of the destination to receive messages from.
    `void` | `setDurableSubscriptionName(String durableSubscriptionName)` Set the name of a durable subscription to create.
    `void` | `setErrorHandler(ErrorHandler errorHandler)` Set the ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message.
    `void` | `setExceptionListener(ExceptionListener exceptionListener)` Set the JMS ExceptionListener to notify in case of a JMSException thrown by the registered message listener or the invocation infrastructure.
    `void` | `setExposeListenerSession(boolean exposeListenerSession)` Set whether to expose the listener JMS Session to a registered `SessionAwareMessageListener` as well as to `JmsTemplate` calls.
    `void` | `setMessageConverter(MessageConverter messageConverter)` Set the `MessageConverter` strategy for converting JMS Messages.
    `void` | `setMessageListener(Object messageListener)` Set the message listener implementation to register.
    `void` | `setMessageSelector(String messageSelector)` Set the JMS message selector expression (or `null` if none).
    `void` | `setPubSubNoLocal(boolean pubSubNoLocal)` Set whether to inhibit the delivery of messages published by its own connection.
    `void` | `setReplyPubSubDomain(boolean replyPubSubDomain)` Configure the reply destination type.
    `void` | `setReplyQosSettings(QosSettings replyQosSettings)` Configure the `QosSettings` to use when sending a reply.
    `void` | `setSubscriptionDurable(boolean subscriptionDurable)` Set whether to make the subscription durable.
    `void` | `setSubscriptionName(String subscriptionName)` Set the name of a subscription to create.
    `void` | `setSubscriptionShared(boolean subscriptionShared)` Set whether to make the subscription shared.
    `void` | `setupMessageListener(Object messageListener)` Set up the message listener to use.
    `protected void` | `validateConfiguration()` Validate the configuration of this container.

    - ### Methods inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer

      `afterPropertiesSet, createSharedConnection, destroy, doInitialize, doRescheduleTask, doShutdown, doStart, doStop, establishSharedConnection, getBeanName, getClientId, getPausedTaskCount, getPhase, getSharedConnection, initialize, isActive, isAutoStartup, isRunning, logRejectedTask, prepareSharedConnection, refreshSharedConnection, rescheduleTaskIfNecessary, resumePausedTasks, runningAllowed, setAutoStartup, setBeanName, setClientId, setPhase, sharedConnectionEnabled, shutdown, start, startSharedConnection, stop, stopSharedConnection`

    - ### Methods inherited from class org.springframework.jms.support.destination.JmsDestinationAccessor

      `getDestinationResolver, isPubSubDomain, receiveFromConsumer, resolveDestinationName, setDestinationResolver, setPubSubDomain`

    - ### Methods inherited from class org.springframework.jms.support.JmsAccessor

      `convertJmsAccessException, createConnection, createSession, getConnectionFactory, getSessionAcknowledgeMode, isClientAcknowledge, isSessionTransacted, obtainConnectionFactory, setConnectionFactory, setSessionAcknowledgeMode, setSessionAcknowledgeModeName, setSessionTransacted`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.springframework.jms.listener.MessageListenerContainer

      `getDestinationResolver, isPubSubDomain`

    - ### Methods inherited from interface org.springframework.context.SmartLifecycle

      `getPhase, isAutoStartup, stop`

    - ### Methods inherited from interface org.springframework.context.Lifecycle

      `isRunning, start, stop`

- - ### Constructor Detail

    - #### AbstractMessageListenerContainer

          public AbstractMessageListenerContainer()

  - ### Method Detail

    - #### setConcurrency

          public abstract void setConcurrency(String concurrency)

      Specify concurrency limits.

    - #### setDestination

          public void setDestination(@Nullable
                                     Destination destination)

      Set the destination to receive messages from.

      Alternatively, specify a "destinationName", to be dynamically resolved via the `DestinationResolver`.

      Note: The destination may be replaced at runtime, with the listener container picking up the new destination immediately (works e.g. with DefaultMessageListenerContainer, as long as the cache level is less than CACHE_CONSUMER). However, this is considered advanced usage; use it with care!

      See Also:
        `setDestinationName(String)`

    - #### getDestination

          @Nullable
          public Destination getDestination()

      Return the destination to receive messages from. Will be `null` if the configured destination is not an actual `Destination` type; c.f. `when the destination is a String`.

    - #### setDestinationName

          public void setDestinationName(@Nullable
                                         String destinationName)

      Set the name of the destination to receive messages from.

      The specified name will be dynamically resolved via the configured `destination resolver`.

      Alternatively, specify a JMS `Destination` object as "destination".

      Note: The destination may be replaced at runtime, with the listener container picking up the new destination immediately (works e.g. with DefaultMessageListenerContainer, as long as the cache level is less than CACHE_CONSUMER). However, this is considered advanced usage; use it with care!

      See Also:
        `setDestination(javax.jms.Destination)`

    - #### getDestinationName

          @Nullable
          public String getDestinationName()

      Return the name of the destination to receive messages from. Will be `null` if the configured destination is not a `String` type; c.f. `when it is an actual Destination`.

    - #### getDestinationDescription

          protected String getDestinationDescription()

      Return a descriptive String for this container's JMS destination (never `null`).

    - #### setMessageSelector

          public void setMessageSelector(@Nullable
                                         String messageSelector)

      Set the JMS message selector expression (or `null` if none). Default is none.

      See the JMS specification for a detailed definition of selector expressions.

      Note: The message selector may be replaced at runtime, with the listener container picking up the new selector value immediately (works e.g. with DefaultMessageListenerContainer, as long as the cache level is less than CACHE_CONSUMER). However, this is considered advanced usage; use it with care!

    - #### getMessageSelector

          @Nullable
          public String getMessageSelector()

      Return the JMS message selector expression (or `null` if none).

    - #### setMessageListener

          public void setMessageListener(@Nullable
                                         Object messageListener)

      Set the message listener implementation to register. This can be either a standard JMS `MessageListener` object or a Spring `SessionAwareMessageListener` object.

      Note: The message listener may be replaced at runtime, with the listener container picking up the new listener object immediately (works e.g. with DefaultMessageListenerContainer, as long as the cache level is less than CACHE_CONSUMER). However, this is considered advanced usage; use it with care!

      Throws:
        `IllegalArgumentException` - if the supplied listener is not a `MessageListener` or a `SessionAwareMessageListener`
      See Also:
        `MessageListener`, `SessionAwareMessageListener`

    - #### getMessageListener

          @Nullable
          public Object getMessageListener()

      Return the message listener object to register.

    - #### checkMessageListener

          protected void checkMessageListener(@Nullable
                                              Object messageListener)

      Check the given message listener, throwing an exception if it does not correspond to a supported listener type.

      By default, only a standard JMS `MessageListener` object or a Spring `SessionAwareMessageListener` object will be accepted.

      Parameters:
        `messageListener` - the message listener object to check
      Throws:
        `IllegalArgumentException` - if the supplied listener is not a `MessageListener` or a `SessionAwareMessageListener`
      See Also:
        `MessageListener`, `SessionAwareMessageListener`

    - #### getDefaultSubscriptionName

          protected String getDefaultSubscriptionName(Object messageListener)

      Determine the default subscription name for the given message listener.
      Parameters:
        `messageListener` - the message listener object to check
      Returns:
        the default subscription name
      See Also:
        `SubscriptionNameProvider`

    - #### setSubscriptionDurable

          public void setSubscriptionDurable(boolean subscriptionDurable)

      Set whether to make the subscription durable. The durable subscription name to be used can be specified through the "subscriptionName" property.

      Default is "false". Set this to "true" to register a durable subscription, typically in combination with a "subscriptionName" value (unless your message listener class name is good enough as subscription name).

      Only makes sense when listening to a topic (pub-sub domain), therefore this method switches the "pubSubDomain" flag as well.

      See Also:
        `setSubscriptionName(java.lang.String)`, `JmsDestinationAccessor.setPubSubDomain(boolean)`

    - #### isSubscriptionDurable

          public boolean isSubscriptionDurable()

      Return whether to make the subscription durable.

    - #### setSubscriptionShared

          public void setSubscriptionShared(boolean subscriptionShared)

      Set whether to make the subscription shared. The shared subscription name to be used can be specified through the "subscriptionName" property.

      Default is "false". Set this to "true" to register a shared subscription, typically in combination with a "subscriptionName" value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable, so this flag can (and often will) be combined with "subscriptionDurable" as well.

      Only makes sense when listening to a topic (pub-sub domain), therefore this method switches the "pubSubDomain" flag as well.

      Requires a JMS 2.0 compatible message broker.

      Since:
        4.1
      See Also:
        `setSubscriptionName(java.lang.String)`, `setSubscriptionDurable(boolean)`, `JmsDestinationAccessor.setPubSubDomain(boolean)`

    - #### isSubscriptionShared

          public boolean isSubscriptionShared()

      Return whether to make the subscription shared.
      Since:
        4.1

    - #### setSubscriptionName

          public void setSubscriptionName(@Nullable
                                          String subscriptionName)

      Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription.

      The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener.

      Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription, except for a shared subscription (which requires JMS 2.0).

      Since:
        4.1
      See Also:
        `JmsDestinationAccessor.setPubSubDomain(boolean)`, `setSubscriptionDurable(boolean)`, `setSubscriptionShared(boolean)`, `AbstractJmsListeningContainer.setClientId(java.lang.String)`, `setMessageListener(java.lang.Object)`

    - #### getSubscriptionName

          @Nullable
          public String getSubscriptionName()

      Return the name of a subscription to create, if any.
      Since:
        4.1

    - #### setDurableSubscriptionName

          public void setDurableSubscriptionName(@Nullable
                                                 String durableSubscriptionName)

      Set the name of a durable subscription to create. This method switches to pub-sub domain mode and activates subscription durability as well.

      The durable subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener.

      Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each durable subscription, except for a shared durable subscription (which requires JMS 2.0).

      See Also:
        `JmsDestinationAccessor.setPubSubDomain(boolean)`, `setSubscriptionDurable(boolean)`, `setSubscriptionShared(boolean)`, `AbstractJmsListeningContainer.setClientId(java.lang.String)`, `setMessageListener(java.lang.Object)`

    - #### getDurableSubscriptionName

          @Nullable
          public String getDurableSubscriptionName()

      Return the name of a durable subscription to create, if any.

    - #### setPubSubNoLocal

          public void setPubSubNoLocal(boolean pubSubNoLocal)

      Set whether to inhibit the delivery of messages published by its own connection. Default is "false".
      Since:
        4.1
      See Also:
        `Session.createConsumer(javax.jms.Destination, String, boolean)`

    - #### isPubSubNoLocal

          public boolean isPubSubNoLocal()

      Return whether to inhibit the delivery of messages published by its own connection.
      Since:
        4.1

    - #### setReplyPubSubDomain

          public void setReplyPubSubDomain(boolean replyPubSubDomain)

      Configure the reply destination type. By default, the configured `pubSubDomain` value is used (see `JmsDestinationAccessor.isPubSubDomain()`).

      This setting primarily indicates what type of destination to resolve if dynamic destinations are enabled.

      Parameters:
        `replyPubSubDomain` - "true" for the Publish/Subscribe domain (`Topics`), "false" for the Point-to-Point domain (`Queues`)
      Since:
        4.2
      See Also:
        `JmsDestinationAccessor.setDestinationResolver(org.springframework.jms.support.destination.DestinationResolver)`

    - #### isReplyPubSubDomain

          public boolean isReplyPubSubDomain()

      Return whether the Publish/Subscribe domain (`Topics`) is used for replies. Otherwise, the Point-to-Point domain (`Queues`) is used.
      Specified by:
        `isReplyPubSubDomain` in interface `MessageListenerContainer`
      Since:
        4.2

    - #### setReplyQosSettings

          public void setReplyQosSettings(@Nullable
                                          QosSettings replyQosSettings)

      Configure the `QosSettings` to use when sending a reply. Can be set to `null` to indicate that the broker's defaults should be used.
      Parameters:
        `replyQosSettings` - the QoS settings to use when sending a reply or `null` to use the default vas.
      Since:
        5.0

    - #### getReplyQosSettings

          @Nullable
          public QosSettings getReplyQosSettings()

      Description copied from interface: `MessageListenerContainer`
      Return the `QosSettings` to use when sending a reply, or `null` if the broker's defaults should be used.
      Specified by:
        `getReplyQosSettings` in interface `MessageListenerContainer`

    - #### setMessageConverter

          public void setMessageConverter(@Nullable
                                          MessageConverter messageConverter)

      Set the `MessageConverter` strategy for converting JMS Messages.
      Since:
        4.1

    - #### getMessageConverter

          @Nullable
          public MessageConverter getMessageConverter()

      Description copied from interface: `MessageListenerContainer`
      Return the `MessageConverter` that can be used to convert `Message`, if any.
      Specified by:
        `getMessageConverter` in interface `MessageListenerContainer`

    - #### setExceptionListener

          public void setExceptionListener(@Nullable
                                           ExceptionListener exceptionListener)

      Set the JMS ExceptionListener to notify in case of a JMSException thrown by the registered message listener or the invocation infrastructure.

    - #### getExceptionListener

          @Nullable
          public ExceptionListener getExceptionListener()

      Return the JMS ExceptionListener to notify in case of a JMSException thrown by the registered message listener or the invocation infrastructure, if any.

    - #### setErrorHandler

          public void setErrorHandler(@Nullable
                                      ErrorHandler errorHandler)

      Set the ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message.

      By default, there will be no ErrorHandler so that error-level logging is the only result.

    - #### getErrorHandler

          @Nullable
          public ErrorHandler getErrorHandler()

      Return the ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message.
      Since:
        4.1

    - #### setExposeListenerSession

          public void setExposeListenerSession(boolean exposeListenerSession)

      Set whether to expose the listener JMS Session to a registered `SessionAwareMessageListener` as well as to `JmsTemplate` calls.

      Default is "true", reusing the listener's `Session`. Turn this off to expose a fresh JMS Session fetched from the same underlying JMS `Connection` instead, which might be necessary on some JMS providers.

      Note that Sessions managed by an external transaction manager will always get exposed to `JmsTemplate` calls. So in terms of JmsTemplate exposure, this setting only affects locally transacted Sessions.

      See Also:
        `SessionAwareMessageListener`

    - #### isExposeListenerSession

          public boolean isExposeListenerSession()

      Return whether to expose the listener JMS `Session` to a registered `SessionAwareMessageListener`.

    - #### setAcceptMessagesWhileStopping

          public void setAcceptMessagesWhileStopping(boolean acceptMessagesWhileStopping)

      Set whether to accept received messages while the listener container in the process of stopping.

      Default is "false", rejecting such messages through aborting the receive attempt. Switch this flag on to fully process such messages even in the stopping phase, with the drawback that even newly sent messages might still get processed (if coming in before all receive timeouts have expired).

      NOTE: Aborting receive attempts for such incoming messages might lead to the provider's retry count decreasing for the affected messages. If you have a high number of concurrent consumers, make sure that the number of retries is higher than the number of consumers, to be on the safe side for all potential stopping scenarios.

    - #### isAcceptMessagesWhileStopping

          public boolean isAcceptMessagesWhileStopping()

      Return whether to accept received messages while the listener container in the process of stopping.

    - #### validateConfiguration

          protected void validateConfiguration()

      Description copied from class: `AbstractJmsListeningContainer`
      Validate the configuration of this container.

      The default implementation is empty. To be overridden in subclasses.

      Overrides:
        `validateConfiguration` in class `AbstractJmsListeningContainer`

    - #### setupMessageListener

          public void setupMessageListener(Object messageListener)

      Description copied from interface: `MessageListenerContainer`
      Set up the message listener to use. Throws an `IllegalArgumentException` if that message listener type is not supported.
      Specified by:
        `setupMessageListener` in interface `MessageListenerContainer`

    - #### executeListener

          protected void executeListener(Session session,
                                         Message message)

      Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).
      Parameters:
        `session` - the JMS Session to operate on
        `message` - the received JMS Message
      See Also:
        `invokeListener(javax.jms.Session, javax.jms.Message)`, `commitIfNecessary(javax.jms.Session, javax.jms.Message)`, `rollbackOnExceptionIfNecessary(javax.jms.Session, java.lang.Throwable)`, `handleListenerException(java.lang.Throwable)`

    - #### doExecuteListener

          protected void doExecuteListener(Session session,
                                           Message message)
                                    throws JMSException

      Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).
      Parameters:
        `session` - the JMS Session to operate on
        `message` - the received JMS Message
      Throws:
        `JMSException` - if thrown by JMS API methods
      See Also:
        `invokeListener(javax.jms.Session, javax.jms.Message)`, `commitIfNecessary(javax.jms.Session, javax.jms.Message)`, `rollbackOnExceptionIfNecessary(javax.jms.Session, java.lang.Throwable)`, `JmsAccessor.convertJmsAccessException(javax.jms.JMSException)`

    - #### invokeListener

          protected void invokeListener(Session session,
                                        Message message)
                                 throws JMSException

      Invoke the specified listener: either as standard JMS MessageListener or (preferably) as Spring SessionAwareMessageListener.
      Parameters:
        `session` - the JMS Session to operate on
        `message` - the received JMS Message
      Throws:
        `JMSException` - if thrown by JMS API methods
      See Also:
        `setMessageListener(java.lang.Object)`

    - #### doInvokeListener

          protected void doInvokeListener(SessionAwareMessageListener listener,
                                          Session session,
                                          Message message)
                                   throws JMSException

      Invoke the specified listener as Spring SessionAwareMessageListener, exposing a new JMS Session (potentially with its own transaction) to the listener if demanded.
      Parameters:
        `listener` - the Spring SessionAwareMessageListener to invoke
        `session` - the JMS Session to operate on
        `message` - the received JMS Message
      Throws:
        `JMSException` - if thrown by JMS API methods
      See Also:
        `SessionAwareMessageListener`, `setExposeListenerSession(boolean)`

    - #### doInvokeListener

          protected void doInvokeListener(MessageListener listener,
                                          Message message)
                                   throws JMSException

      Invoke the specified listener as standard JMS MessageListener.

      Default implementation performs a plain invocation of the `onMessage` method.

      Parameters:
        `listener` - the JMS MessageListener to invoke
        `message` - the received JMS Message
      Throws:
        `JMSException` - if thrown by JMS API methods
      See Also:
        `MessageListener.onMessage(javax.jms.Message)`

    - #### commitIfNecessary

          protected void commitIfNecessary(Session session,
                                           @Nullable
                                           Message message)
                                    throws JMSException

      Perform a commit or message acknowledgement, as appropriate.
      Parameters:
        `session` - the JMS Session to commit
        `message` - the Message to acknowledge
      Throws:
        `JMSException` - in case of commit failure

    - #### rollbackIfNecessary

          protected void rollbackIfNecessary(Session session)
                                      throws JMSException

      Perform a rollback, if appropriate.
      Parameters:
        `session` - the JMS Session to rollback
      Throws:
        `JMSException` - in case of a rollback error

    - #### rollbackOnExceptionIfNecessary

          protected void rollbackOnExceptionIfNecessary(Session session,
                                                        Throwable ex)
                                                 throws JMSException

      Perform a rollback, handling rollback exceptions properly.
      Parameters:
        `session` - the JMS Session to rollback
        `ex` - the thrown application exception or error
      Throws:
        `JMSException` - in case of a rollback error

    - #### isSessionLocallyTransacted

          protected boolean isSessionLocallyTransacted(Session session)

      Check whether the given Session is locally transacted, that is, whether its transaction is managed by this listener container's Session handling and not by an external transaction coordinator.

      Note: The Session's own transacted flag will already have been checked before. This method is about finding out whether the Session's transaction is local or externally coordinated.

      Parameters:
        `session` - the Session to check
      Returns:
        whether the given Session is locally transacted
      See Also:
        `JmsAccessor.isSessionTransacted()`, `ConnectionFactoryUtils.isSessionTransactional(javax.jms.Session, javax.jms.ConnectionFactory)`

    - #### createConsumer

          protected MessageConsumer createConsumer(Session session,
                                                   Destination destination)
                                            throws JMSException

      Create a JMS MessageConsumer for the given Session and Destination.

      This implementation uses JMS 1.1 API.

      Parameters:
        `session` - the JMS Session to create a MessageConsumer for
        `destination` - the JMS Destination to create a MessageConsumer for
      Returns:
        the new JMS MessageConsumer
      Throws:
        `JMSException` - if thrown by JMS API methods

    - #### handleListenerException

          protected void handleListenerException(Throwable ex)

      Handle the given exception that arose during listener execution.

      The default implementation logs the exception at warn level, not propagating it to the JMS provider — assuming that all handling of acknowledgement and/or transactions is done by this listener container. This can be overridden in subclasses.

      Parameters:
        `ex` - the exception to handle

    - #### invokeExceptionListener

          protected void invokeExceptionListener(JMSException ex)

      Invoke the registered JMS ExceptionListener, if any.
      Parameters:
        `ex` - the exception that arose during JMS processing
      See Also:
        `setExceptionListener(javax.jms.ExceptionListener)`

    - #### invokeErrorHandler

          protected void invokeErrorHandler(Throwable ex)

      Invoke the registered ErrorHandler, if any. Log at warn level otherwise.
      Parameters:
        `ex` - the uncaught error that arose during JMS processing.
      See Also:
        `setErrorHandler(org.springframework.util.ErrorHandler)`