Spring AMQP

org.springframework.amqp.rabbit.listener
Class SimpleMessageListenerContainer

java.lang.Object
  extended by org.springframework.amqp.rabbit.support.RabbitAccessor
      extended by org.springframework.amqp.rabbit.listener.AbstractRabbitListeningContainer
          extended by org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer
              extended by org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer
All Implemented Interfaces:
BeanNameAware, DisposableBean, InitializingBean, Lifecycle, Phased, SmartLifecycle

public class SimpleMessageListenerContainer
extends AbstractMessageListenerContainer

Author:
Mark Pollack, Mark Fisher, Dave Syer

Nested Class Summary
 
Nested classes/interfaces inherited from class org.springframework.amqp.rabbit.listener.AbstractRabbitListeningContainer
AbstractRabbitListeningContainer.SharedConnectionNotInitializedException
 
Field Summary
static long DEFAULT_RECEIVE_TIMEOUT
           
 
Fields inherited from class org.springframework.amqp.rabbit.support.RabbitAccessor
logger
 
Constructor Summary
SimpleMessageListenerContainer()
           
SimpleMessageListenerContainer(ConnectionFactory connectionFactory)
           
 
Method Summary
 void afterPropertiesSet()
          Avoid the possibility of not configuring the CachingConnectionFactory in sync with the number of concurrent consumers.
protected  BlockingQueueConsumer createBlockingQueueConsumer(com.rabbitmq.client.Channel channel)
           
protected  void doInitialize()
          Creates the specified number of concurrent consumers, in the form of a Rabbit Channel plus associated MessageConsumer.
protected  void doShutdown()
          Close the registered invokers.
protected  void doStart()
          Re-initializes this container's Rabbit message consumers, if not initialized already.
protected  void doStop()
          Notify all invoker tasks and stop the shared Connection, if any.
 int getBlockingQueueConsumerCapacity()
           
 int getPrefetchCount()
           
 int getTxSize()
           
protected  void initializeConsumers()
           
protected  boolean isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)
          Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this listener container's Channel handling and not by an external transaction coordinator.
 void setBlockingQueueConsumerCapacity(int blockingQueueConsumerCapacity)
           
 void setConcurrentConsumers(int concurrentConsumers)
          Specify the number of concurrent consumers to create.
 void setPrefetchCount(int prefetchCount)
           
 void setReceiveTimeout(long receiveTimeout)
           
 void setTaskExecutor(Executor taskExecutor)
           
 void setTransactionManager(PlatformTransactionManager transactionManager)
           
 void setTxSize(int txSize)
           
protected  boolean sharedConnectionEnabled()
          Always use a shared Rabbit Connection.
 
Methods inherited from class org.springframework.amqp.rabbit.listener.AbstractMessageListenerContainer
checkMessageListener, commitIfNecessary, doExecuteListener, doInvokeListener, doInvokeListener, executeListener, getMessageListener, getQueueName, getRequiredQueueName, handleListenerException, invokeErrorHandler, invokeListener, isExposeListenerChannel, rollbackIfNecessary, rollbackOnExceptionIfNecessary, setErrorHandler, setExposeListenerChannel, setMessageListener, setQueueName, setQueues
 
Methods inherited from class org.springframework.amqp.rabbit.listener.AbstractRabbitListeningContainer
createSharedConnection, destroy, establishSharedConnection, getBeanName, getPhase, getSharedConnection, initialize, isActive, isAutoStartup, isRunning, prepareSharedConnection, refreshSharedConnection, runningAllowed, setAutoStartup, setBeanName, setPhase, shutdown, start, stop, stop, stopSharedConnection, validateConfiguration
 
Methods inherited from class org.springframework.amqp.rabbit.support.RabbitAccessor
convertRabbitAccessException, createChannel, createConnection, getChannel, getConnection, getConnectionFactory, getTransactionalResourceHolder, isChannelTransacted, setChannelTransacted, setConnectionFactory
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

DEFAULT_RECEIVE_TIMEOUT

public static final long DEFAULT_RECEIVE_TIMEOUT
See Also:
Constant Field Values
Constructor Detail

SimpleMessageListenerContainer

public SimpleMessageListenerContainer()

SimpleMessageListenerContainer

public SimpleMessageListenerContainer(ConnectionFactory connectionFactory)
Method Detail

setConcurrentConsumers

public void setConcurrentConsumers(int concurrentConsumers)
Specify the number of concurrent consumers to create. Default is 1.

Raising the number of concurrent consumers is recommended 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.


setReceiveTimeout

public void setReceiveTimeout(long receiveTimeout)

setTaskExecutor

public void setTaskExecutor(Executor taskExecutor)

getPrefetchCount

public int getPrefetchCount()

setPrefetchCount

public void setPrefetchCount(int prefetchCount)

getTxSize

public int getTxSize()

setTxSize

public void setTxSize(int txSize)

getBlockingQueueConsumerCapacity

public int getBlockingQueueConsumerCapacity()

setBlockingQueueConsumerCapacity

public void setBlockingQueueConsumerCapacity(int blockingQueueConsumerCapacity)

setTransactionManager

public void setTransactionManager(PlatformTransactionManager transactionManager)

afterPropertiesSet

public void afterPropertiesSet()
Avoid the possibility of not configuring the CachingConnectionFactory in sync with the number of concurrent consumers.

Specified by:
afterPropertiesSet in interface InitializingBean
Overrides:
afterPropertiesSet in class AbstractRabbitListeningContainer

sharedConnectionEnabled

protected final boolean sharedConnectionEnabled()
Always use a shared Rabbit Connection.

Specified by:
sharedConnectionEnabled in class AbstractRabbitListeningContainer
See Also:
AbstractRabbitListeningContainer.getSharedConnection()

doInitialize

protected void doInitialize()
                     throws Exception
Creates the specified number of concurrent consumers, in the form of a Rabbit Channel plus associated MessageConsumer.

Specified by:
doInitialize in class AbstractRabbitListeningContainer
Throws:
Exception
AbstractRabbitListeningContainer.SharedConnectionNotInitializedException
See Also:
AbstractRabbitListeningContainer.getSharedConnection()

doStart

protected void doStart()
                throws Exception
Re-initializes this container's Rabbit message consumers, if not initialized already. Then submits each consumer to this container's task executor.

Overrides:
doStart in class AbstractRabbitListeningContainer
Throws:
Exception
AbstractRabbitListeningContainer.SharedConnectionNotInitializedException - if thrown by Rabbit API methods
See Also:
AbstractRabbitListeningContainer.establishSharedConnection()

doStop

protected void doStop()
Description copied from class: AbstractRabbitListeningContainer
Notify all invoker tasks and stop the shared Connection, if any.

Overrides:
doStop in class AbstractRabbitListeningContainer
See Also:
AbstractRabbitListeningContainer.stopSharedConnection()

doShutdown

protected void doShutdown()
Description copied from class: AbstractRabbitListeningContainer
Close the registered invokers.

Subclasses need to implement this method for their specific invoker management process.

A shared Rabbit Connection, if any, will automatically be closed afterwards.

Specified by:
doShutdown in class AbstractRabbitListeningContainer
See Also:
AbstractRabbitListeningContainer.shutdown()

initializeConsumers

protected void initializeConsumers()
                            throws IOException
Throws:
IOException

isChannelLocallyTransacted

protected boolean isChannelLocallyTransacted(com.rabbitmq.client.Channel channel)
Description copied from class: AbstractMessageListenerContainer
Check whether the given Channel is locally transacted, that is, whether its transaction is managed by this listener container's Channel handling and not by an external transaction coordinator.

Note:This method is about finding out whether the Channel's transaction is local or externally coordinated.

Overrides:
isChannelLocallyTransacted in class AbstractMessageListenerContainer
Parameters:
channel - the Channel to check
Returns:
whether the given Channel is locally transacted
See Also:
RabbitAccessor.isChannelTransacted()

createBlockingQueueConsumer

protected BlockingQueueConsumer createBlockingQueueConsumer(com.rabbitmq.client.Channel channel)
                                                     throws IOException
Throws:
IOException

Spring AMQP

Copyright © 2010. All Rights Reserved.