protected  void checkMessageListener(Object messageListener) 
{
		if (!(messageListener instanceof MessageListener ||
				messageListener instanceof SessionAwareMessageListener)) {
			throw new IllegalArgumentException(
					"Message listener needs to be of type [" + MessageListener.class.getName() +
					"] or [" + SessionAwareMessageListener.class.getName() + "]");
		}
}

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.

 protected  void commitIfNecessary(Session session,
    Message message) throws JMSException 
{
		// Commit session or acknowledge message.
		if (session.getTransacted()) {
			// Commit necessary - but avoid commit call within a JTA transaction.
			if (isSessionLocallyTransacted(session)) {
				// Transacted session created by this container - > commit.
				JmsUtils.commitIfNecessary(session);
			}
		}
		else if (isClientAcknowledge(session)) {
			message.acknowledge();
		}
}

Perform a commit or message acknowledgement, as appropriate.

 protected  void doExecuteListener(Session session,
    Message message) throws JMSException 
{
		if (!isAcceptMessagesWhileStopping() && !isRunning()) {
			if (logger.isWarnEnabled()) {
				logger.warn("Rejecting received message because of the listener container " +
						"having been stopped in the meantime: " + message);
			}
			rollbackIfNecessary(session);
			throw new MessageRejectedWhileStoppingException();
		}
		try {
			invokeListener(session, message);
		}
		catch (JMSException ex) {
			rollbackOnExceptionIfNecessary(session, ex);
			throw ex;
		}
		catch (RuntimeException ex) {
			rollbackOnExceptionIfNecessary(session, ex);
			throw ex;
		}
		catch (Error err) {
			rollbackOnExceptionIfNecessary(session, err);
			throw err;
		}
		commitIfNecessary(session, message);
}

Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).

 protected  void doInvokeListener(MessageListener listener,
    Message message) throws JMSException 
{
		listener.onMessage(message);
}

Invoke the specified listener as standard JMS MessageListener.

Default implementation performs a plain invocation of the onMessage method.

 protected  void doInvokeListener(SessionAwareMessageListener listener,
    Session session,
    Message message) throws JMSException 
{
		Connection conToClose = null;
		Session sessionToClose = null;
		try {
			Session sessionToUse = session;
			if (!isExposeListenerSession()) {
				// We need to expose a separate Session.
				conToClose = createConnection();
				sessionToClose = createSession(conToClose);
				sessionToUse = sessionToClose;
			}
			// Actually invoke the message listener...
			if (logger.isDebugEnabled()) {
				logger.debug("Invoking listener with message of type [" + message.getClass() +
						"] and session [" + sessionToUse + "]");
			}
			listener.onMessage(message, sessionToUse);
			// Clean up specially exposed Session, if any.
			if (sessionToUse != session) {
				if (sessionToUse.getTransacted() && isSessionLocallyTransacted(sessionToUse)) {
					// Transacted session created by this container - > commit.
					JmsUtils.commitIfNecessary(sessionToUse);
				}
			}
		}
		finally {
			JmsUtils.closeSession(sessionToClose);
			JmsUtils.closeConnection(conToClose);
		}
}

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) 
{
		try {
			doExecuteListener(session, message);
		}
		catch (Throwable ex) {
			handleListenerException(ex);
		}
}

Execute the specified listener, committing or rolling back the transaction afterwards (if necessary).

 public Destination getDestination() 
{
		return (this.destination instanceof Destination ? (Destination) this.destination : null);
}

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 .

 public String getDestinationName() 
{
		return (this.destination instanceof String ? (String) this.destination : null);
}

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 is an actual Destination .

 public String getDurableSubscriptionName() 
{
		return this.durableSubscriptionName;
}

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

 public ExceptionListener getExceptionListener() 
{
		return this.exceptionListener;
}

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

 public Object getMessageListener() 
{
		return this.messageListener;
}

Return the message listener object to register.

 public String getMessageSelector() 
{
		return this.messageSelector;
}

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

 protected  void handleListenerException(Throwable ex) 
{
		if (ex instanceof MessageRejectedWhileStoppingException) {
			// Internal exception - has been handled before.
			return;
		}
		if (ex instanceof JMSException) {
			invokeExceptionListener((JMSException) ex);
		}
		if (isActive()) {
			// Regular case: failed while active.
			// Log at error level.
			logger.warn("Execution of JMS message listener failed", ex);
		}
		else {
			// Rare case: listener thread failed after container shutdown.
			// Log at debug level, to avoid spamming the shutdown log.
			logger.debug("Listener exception after container shutdown", ex);
		}
}

Handle the given exception that arose during listener execution.

The default implementation logs the exception at error 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.

 protected  void invokeExceptionListener(JMSException ex) 
{
		ExceptionListener exceptionListener = getExceptionListener();
		if (exceptionListener != null) {
			exceptionListener.onException(ex);
		}
}

Invoke the registered JMS ExceptionListener, if any.

 protected  void invokeListener(Session session,
    Message message) throws JMSException 
{
		Object listener = getMessageListener();
		if (listener instanceof SessionAwareMessageListener) {
			doInvokeListener((SessionAwareMessageListener) listener, session, message);
		}
		else if (listener instanceof MessageListener) {
			doInvokeListener((MessageListener) listener, message);
		}
		else if (listener != null) {
			throw new IllegalArgumentException(
					"Only MessageListener and SessionAwareMessageListener supported: " + listener);
		}
		else {
			throw new IllegalStateException("No message listener specified - see property 'messageListener'");
		}
}

Invoke the specified listener: either as standard JMS MessageListener or (preferably) as Spring SessionAwareMessageListener.

 public boolean isAcceptMessagesWhileStopping() 
{
		return this.acceptMessagesWhileStopping;
}

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

 public boolean isExposeListenerSession() 
{
		return this.exposeListenerSession;
}

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

 protected boolean isSessionLocallyTransacted(Session session) 
{
		return isSessionTransacted();
}

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.

 public boolean isSubscriptionDurable() 
{
		return this.subscriptionDurable;
}

Return whether to make the subscription durable.

 protected  void rollbackIfNecessary(Session session) throws JMSException 
{
		if (session.getTransacted() && isSessionLocallyTransacted(session)) {
			// Transacted session created by this container - > rollback.
			JmsUtils.rollbackIfNecessary(session);
		}
}

Perform a rollback, if appropriate.

 protected  void rollbackOnExceptionIfNecessary(Session session,
    Throwable ex) throws JMSException 
{
		try {
			if (session.getTransacted() && isSessionLocallyTransacted(session)) {
				// Transacted session created by this container - > rollback.
				if (logger.isDebugEnabled()) {
					logger.debug("Initiating transaction rollback on application exception", ex);
				}
				JmsUtils.rollbackIfNecessary(session);
			}
		}
		catch (IllegalStateException ex2) {
			logger.debug("Could not roll back because Session already closed", ex2);
		}
		catch (JMSException ex2) {
			logger.error("Application exception overridden by rollback exception", ex);
			throw ex2;
		}
		catch (RuntimeException ex2) {
			logger.error("Application exception overridden by rollback exception", ex);
			throw ex2;
		}
		catch (Error err) {
			logger.error("Application exception overridden by rollback error", ex);
			throw err;
		}
}

Perform a rollback, handling rollback exceptions properly.

 public  void setAcceptMessagesWhileStopping(boolean acceptMessagesWhileStopping) 
{
		this.acceptMessagesWhileStopping = 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.

 public  void setDestination(Destination destination) 
{
	                                                               	 
		Assert.notNull(destination, "'destination' must not be null");
		this.destination = destination;
		if (destination instanceof Topic && !(destination instanceof Queue)) {
			// Clearly a Topic: let's se the "pubSubDomain" flag.
			setPubSubDomain(true);
		}
}

Set the destination to receive messages from.

Alternatively, specify a "destinationName", to be dynamically resolved via the org.springframework.jms.support.destination.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!

 public  void setDestinationName(String destinationName) 
{
		Assert.notNull(destinationName, "'destinationName' must not be null");
		this.destination = 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!

 public  void setDurableSubscriptionName(String durableSubscriptionName) 
{
		this.durableSubscriptionName = durableSubscriptionName;
}

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

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.

 public  void setExceptionListener(ExceptionListener exceptionListener) 
{
		this.exceptionListener = exceptionListener;
}

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

 public  void setExposeListenerSession(boolean exposeListenerSession) 
{
		this.exposeListenerSession = exposeListenerSession;
}

Set whether to expose the listener JMS Session to a registered SessionAwareMessageListener as well as to org.springframework.jms.core.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 org.springframework.jms.core.JmsTemplate calls. So in terms of JmsTemplate exposure, this setting only affects locally transacted Sessions.

 public  void setMessageListener(Object messageListener) 
{
		checkMessageListener(messageListener);
		this.messageListener = messageListener;
		if (this.durableSubscriptionName == null) {
			// Use message listener class name as default name for a durable subscription.
			this.durableSubscriptionName = messageListener.getClass().getName();
		}
}

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!

 public  void setMessageSelector(String messageSelector) 
{
		this.messageSelector = 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!

 public  void setSubscriptionDurable(boolean subscriptionDurable) 
{
		this.subscriptionDurable = subscriptionDurable;
}

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

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

Only makes sense when listening to a topic (pub-sub domain).

 protected  void validateConfiguration() 
{
		if (this.destination == null) {
			throw new IllegalArgumentException("Property 'destination' or 'destinationName' is required");
		}
		if (isSubscriptionDurable() && !isPubSubDomain()) {
			throw new IllegalArgumentException("A durable subscription requires a topic (pub-sub domain)");
		}
}