|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.springframework.jms.support.JmsAccessor
org.springframework.jms.support.destination.JmsDestinationAccessor
org.springframework.jms.listener.AbstractJmsListeningContainer
org.springframework.jms.listener.AbstractMessageListenerContainer
org.springframework.jms.listener.SimpleMessageListenerContainer
public class SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener()
method to
create concurrent MessageConsumers for the specified listeners.
This is the simplest form of a message listener container. It creates a fixed number of JMS Sessions to invoke the listener, not allowing for dynamic adaptation to runtime demands. Its main advantage is its low level of complexity and the minimum requirements on the JMS provider: Not even the ServerSessionPool facility is required.
See the AbstractMessageListenerContainer
javadoc for details
on acknowledge modes and transaction options.
For a different style of MessageListener handling, through looped
MessageConsumer.receive()
calls that also allow for
transactional reception of messages (registering them with XA transactions),
see DefaultMessageListenerContainer
.
javax.jms.MessageConsumer#setMessageListener
,
DefaultMessageListenerContainer
,
JmsMessageEndpointManager
Nested Class Summary |
---|
Nested classes/interfaces inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer |
---|
AbstractJmsListeningContainer.SharedConnectionNotInitializedException |
Field Summary | |
---|---|
private int |
concurrentConsumers
|
private java.util.Set<MessageConsumer> |
consumers
|
private java.lang.Object |
consumersMonitor
|
private boolean |
pubSubNoLocal
|
private java.util.Set<Session> |
sessions
|
private java.util.concurrent.Executor |
taskExecutor
|
Fields inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer |
---|
lifecycleMonitor, sharedConnectionMonitor |
Fields inherited from class org.springframework.jms.support.JmsAccessor |
---|
logger |
Constructor Summary | |
---|---|
SimpleMessageListenerContainer()
|
Method Summary | |
---|---|
protected MessageConsumer |
createConsumer(Session session,
Destination destination)
Create a JMS MessageConsumer for the given Session and Destination. |
protected MessageConsumer |
createListenerConsumer(Session session)
Create a MessageConsumer for the given JMS Session, registering a MessageListener for the specified listener. |
protected void |
doInitialize()
Creates the specified number of concurrent consumers, in the form of a JMS Session plus associated MessageConsumer. |
protected void |
doShutdown()
Destroy the registered JMS Sessions and associated MessageConsumers. |
protected void |
doStart()
Re-initializes this container's JMS message consumers, if not initialized already. |
protected void |
initializeConsumers()
Initialize the JMS Sessions and MessageConsumers for this container. |
protected boolean |
isPubSubNoLocal()
Return whether to inhibit the delivery of messages published by its own connection. |
void |
onException(JMSException ex)
JMS ExceptionListener implementation, invoked by the JMS provider in case of connection failures. |
protected void |
prepareSharedConnection(Connection connection)
Registers this listener container as JMS ExceptionListener on the shared connection. |
protected void |
processMessage(Message message,
Session session)
Process a message received from the provider. |
void |
setConcurrency(java.lang.String concurrency)
Specify concurrency limits via a "lower-upper" String, e.g. |
void |
setConcurrentConsumers(int concurrentConsumers)
Specify the number of concurrent consumers to create. |
void |
setPubSubNoLocal(boolean pubSubNoLocal)
Set whether to inhibit the delivery of messages published by its own connection. |
void |
setTaskExecutor(java.util.concurrent.Executor taskExecutor)
Set the Spring TaskExecutor to use for executing the listener once a message has been received by the provider. |
protected boolean |
sharedConnectionEnabled()
Always use a shared JMS Connection. |
protected void |
validateConfiguration()
Validate the configuration of this container. |
Methods inherited from class org.springframework.jms.listener.AbstractJmsListeningContainer |
---|
afterPropertiesSet, createSharedConnection, destroy, doRescheduleTask, doStop, establishSharedConnection, getBeanName, getClientId, getPausedTaskCount, getPhase, getSharedConnection, initialize, isActive, isAutoStartup, isRunning, logRejectedTask, refreshSharedConnection, rescheduleTaskIfNecessary, resumePausedTasks, runningAllowed, setAutoStartup, setBeanName, setClientId, setPhase, shutdown, start, startSharedConnection, stop, stop, stopSharedConnection |
Methods inherited from class org.springframework.jms.support.destination.JmsDestinationAccessor |
---|
getDestinationResolver, isPubSubDomain, resolveDestinationName, setDestinationResolver, setPubSubDomain |
Methods inherited from class org.springframework.jms.support.JmsAccessor |
---|
convertJmsAccessException, createConnection, createSession, getConnectionFactory, getSessionAcknowledgeMode, isClientAcknowledge, isSessionTransacted, setConnectionFactory, setSessionAcknowledgeMode, setSessionAcknowledgeModeName, setSessionTransacted |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
private boolean pubSubNoLocal
private int concurrentConsumers
private java.util.concurrent.Executor taskExecutor
private java.util.Set<Session> sessions
private java.util.Set<MessageConsumer> consumers
private final java.lang.Object consumersMonitor
Constructor Detail |
---|
public SimpleMessageListenerContainer()
Method Detail |
---|
public void setPubSubNoLocal(boolean pubSubNoLocal)
javax.jms.TopicSession#createSubscriber(javax.jms.Topic, String, boolean)
protected boolean isPubSubNoLocal()
public void setConcurrency(java.lang.String concurrency)
This listener container will always hold on to the maximum number of
consumers setConcurrentConsumers(int)
since it is unable to scale.
This property is primarily supported for configuration compatibility with
DefaultMessageListenerContainer
. For this local listener container,
generally use setConcurrentConsumers(int)
instead.
public void setConcurrentConsumers(int concurrentConsumers)
Raising the number of concurrent consumers is recommendable in order to scale the consumption of messages coming in from a queue. However, note that any ordering guarantees are lost once multiple consumers are registered. In general, stick with 1 consumer for low-volume queues.
Do not raise the number of concurrent consumers for a topic. This would lead to concurrent consumption of the same message, which is hardly ever desirable.
public void setTaskExecutor(java.util.concurrent.Executor taskExecutor)
Default is none, that is, to run in the JMS provider's own receive thread, blocking the provider's receive endpoint while executing the listener.
Specify a TaskExecutor for executing the listener in a different thread, rather than blocking the JMS provider, usually integrating with an existing thread pool. This allows to keep the number of concurrent consumers low (1) while still processing messages concurrently (decoupled from receiving!).
NOTE: Specifying a TaskExecutor for listener execution affects acknowledgement semantics. Messages will then always get acknowledged before listener execution, with the underlying Session immediately reused for receiving the next message. Using this in combination with a transacted session or with client acknowledgement will lead to unspecified results!
NOTE: Concurrent listener execution via a TaskExecutor will lead
to concurrent processing of messages that have been received by the same
underlying Session. As a consequence, it is not recommended to use
this setting with a SessionAwareMessageListener
, at least not
if the latter performs actual work on the given Session. A standard
javax.jms.MessageListener
will work fine, in general.
setConcurrentConsumers(int)
,
SimpleAsyncTaskExecutor
,
WorkManagerTaskExecutor
protected void validateConfiguration()
AbstractJmsListeningContainer
The default implementation is empty. To be overridden in subclasses.
validateConfiguration
in class AbstractMessageListenerContainer
protected final boolean sharedConnectionEnabled()
sharedConnectionEnabled
in class AbstractJmsListeningContainer
AbstractJmsListeningContainer.getSharedConnection()
protected void doInitialize() throws JMSException
doInitialize
in class AbstractJmsListeningContainer
JMSException
- if registration failedcreateListenerConsumer(Session)
protected void doStart() throws JMSException
doStart
in class AbstractJmsListeningContainer
JMSException
- if thrown by JMS API methodsAbstractJmsListeningContainer.startSharedConnection()
protected void prepareSharedConnection(Connection connection) throws JMSException
prepareSharedConnection
in class AbstractJmsListeningContainer
connection
- the Connection to prepare
JMSException
- if the preparation efforts failedAbstractJmsListeningContainer.getClientId()
public void onException(JMSException ex)
ex
- the reported connection exceptionprotected void initializeConsumers() throws JMSException
JMSException
- in case of setup failureprotected MessageConsumer createListenerConsumer(Session session) throws JMSException
session
- the JMS Session to work on
JMSException
- if thrown by JMS methodsAbstractMessageListenerContainer.executeListener(Session, Message)
protected void processMessage(Message message, Session session)
Executes the listener, exposing the current JMS Session as thread-bound resource (if "exposeListenerSession" is "true").
message
- the received JMS Messagesession
- the JMS Session to operate onAbstractMessageListenerContainer.executeListener(Session, Message)
,
AbstractMessageListenerContainer.setExposeListenerSession(boolean)
protected void doShutdown() throws JMSException
doShutdown
in class AbstractJmsListeningContainer
JMSException
- if shutdown failedAbstractJmsListeningContainer.shutdown()
protected MessageConsumer createConsumer(Session session, Destination destination) throws JMSException
This implementation uses JMS 1.1 API.
session
- the JMS Session to create a MessageConsumer fordestination
- the JMS Destination to create a MessageConsumer for
JMSException
- if thrown by JMS API methods
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |