java.lang.Object
- org.springframework.amqp.rabbit.config.BaseRabbitListenerContainerFactory<C>
- - org.springframework.amqp.rabbit.config.AbstractRabbitListenerContainerFactory<C>

Type Parameters:

C - the container type.

All Implemented Interfaces:

RabbitListenerContainerFactory<C>, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware, org.springframework.context.ApplicationEventPublisherAware

Direct Known Subclasses:

DirectRabbitListenerContainerFactory, SimpleRabbitListenerContainerFactory
```
public abstract class AbstractRabbitListenerContainerFactory<C extends AbstractMessageListenerContainer>
extends BaseRabbitListenerContainerFactory<C>
implements org.springframework.context.ApplicationContextAware, org.springframework.context.ApplicationEventPublisherAware
```
RabbitListenerContainerFactory for Spring's base container implementation.

Since:

1.4

See Also:

AbstractMessageListenerContainer

Field Summary

Fields
Modifier and Type Field Description

protected java.util.concurrent.atomic.AtomicInteger counter

protected org.apache.commons.logging.Log logger

Constructor Summary

Constructors
Constructor Description

AbstractRabbitListenerContainerFactory()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`protected abstract C`	`createContainerInstance()`	Create an empty container instance.
`C`	`createListenerContainer(RabbitListenerEndpoint endpoint)`	Create a `MessageListenerContainer` for the given `RabbitListenerEndpoint`.
`protected void`	`initializeContainer(C instance, RabbitListenerEndpoint endpoint)`	Further initialize the specified container.
`void`	`setAcknowledgeMode(org.springframework.amqp.core.AcknowledgeMode acknowledgeMode)`
`void`	`setAfterReceivePostProcessors(org.springframework.amqp.core.MessagePostProcessor... postProcessors)`	Set post processors which will be applied after the Message is received.
`void`	`setApplicationContext(org.springframework.context.ApplicationContext applicationContext)`
`void`	`setApplicationEventPublisher(org.springframework.context.ApplicationEventPublisher applicationEventPublisher)`
`void`	`setAutoStartup(java.lang.Boolean autoStartup)`
`void`	`setBatchingStrategy(BatchingStrategy batchingStrategy)`	Set a `BatchingStrategy` to use when debatching messages.
`void`	`setBatchListener(boolean isBatch)`	Set to true to receive a list of debatched messages that were created by a `BatchingRabbitTemplate`.
`void`	`setChannelTransacted(java.lang.Boolean channelTransacted)`
`void`	`setConnectionFactory(ConnectionFactory connectionFactory)`
`void`	`setConsumerTagStrategy(org.springframework.amqp.support.ConsumerTagStrategy consumerTagStrategy)`
`void`	`setContainerCustomizer(ContainerCustomizer<C> containerCustomizer)`	Set a `ContainerCustomizer` that is invoked after a container is created and configured to enable further customization of the container.
`void`	`setDeBatchingEnabled(java.lang.Boolean deBatchingEnabled)`	Determine whether or not the container should de-batch batched messages (true) or call the listener with the batch (false).
`void`	`setErrorHandler(org.springframework.util.ErrorHandler errorHandler)`
`void`	`setFailedDeclarationRetryInterval(java.lang.Long failedDeclarationRetryInterval)`
`void`	`setForceStop(boolean forceStop)`	Set to true to stop the container after the current message(s) are processed and requeue any prefetched.
`void`	`setGlobalQos(boolean globalQos)`	Apply prefetch to the entire channel.
`void`	`setIdleEventInterval(java.lang.Long idleEventInterval)`	How often to publish idle container events.
`void`	`setMessageAckListener(MessageAckListener messageAckListener)`	Set a `MessageAckListener` to use when ack a message(messages) in `AcknowledgeMode.AUTO` mode.
`void`	`setMessageConverter(org.springframework.amqp.support.converter.MessageConverter messageConverter)`
`void`	`setMismatchedQueuesFatal(java.lang.Boolean mismatchedQueuesFatal)`
`void`	`setMissingQueuesFatal(java.lang.Boolean missingQueuesFatal)`
`void`	`setPhase(int phase)`
`void`	`setPrefetchCount(java.lang.Integer prefetch)`
`void`	`setRecoveryBackOff(org.springframework.util.backoff.BackOff recoveryBackOff)`
`void`	`setRecoveryInterval(java.lang.Long recoveryInterval)`
`void`	`setTaskExecutor(java.util.concurrent.Executor taskExecutor)`
`void`	`setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)`

Methods inherited from class org.springframework.amqp.rabbit.config.BaseRabbitListenerContainerFactory
applyCommonOverrides, getAdviceChain, getDefaultRequeueRejected, setAdviceChain, setBeforeSendReplyPostProcessors, setDefaultRequeueRejected, setReplyRecoveryCallback, setRetryTemplate

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

Methods inherited from interface org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory
createListenerContainer

- Field Detail
  - logger
```
protected final org.apache.commons.logging.Log logger
```
  - counter
```
protected final java.util.concurrent.atomic.AtomicInteger counter
```
- Constructor Detail
  - AbstractRabbitListenerContainerFactory
```
public AbstractRabbitListenerContainerFactory()
```
- Method Detail
  - setConnectionFactory
```
public void setConnectionFactory(ConnectionFactory connectionFactory)
```
    Parameters:
    
    connectionFactory - The connection factory.
    
    See Also:
    
    RabbitAccessor.setConnectionFactory(ConnectionFactory)
  - setErrorHandler
```
public void setErrorHandler(org.springframework.util.ErrorHandler errorHandler)
```
    Parameters:
    
    errorHandler - The error handler.
    
    See Also:
    
    AbstractMessageListenerContainer.setErrorHandler(org.springframework.util.ErrorHandler)
  - setMessageConverter
```
public void setMessageConverter(org.springframework.amqp.support.converter.MessageConverter messageConverter)
```
    Parameters:
    
    messageConverter - the message converter to use
    
    See Also:
    
    RabbitListenerEndpoint.setMessageConverter(MessageConverter)
  - setAcknowledgeMode
```
public void setAcknowledgeMode(org.springframework.amqp.core.AcknowledgeMode acknowledgeMode)
```
    Parameters:
    
    acknowledgeMode - the acknowledge mode to set. Defaults to AcknowledgeMode.AUTO
    
    See Also:
    
    AbstractMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode)
  - setChannelTransacted
```
public void setChannelTransacted(java.lang.Boolean channelTransacted)
```
    Parameters:
    
    channelTransacted - the flag value to set
    
    See Also:
    
    RabbitAccessor.setChannelTransacted(boolean)
  - setTaskExecutor
```
public void setTaskExecutor(java.util.concurrent.Executor taskExecutor)
```
    Parameters:
    
    taskExecutor - the Executor to use.
    
    See Also:
    
    AbstractMessageListenerContainer.setTaskExecutor(java.util.concurrent.Executor)
  - setTransactionManager
```
public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager)
```
    Parameters:
    
    transactionManager - the PlatformTransactionManager to use.
    
    See Also:
    
    AbstractMessageListenerContainer.setTransactionManager(org.springframework.transaction.PlatformTransactionManager)
  - setPrefetchCount
```
public void setPrefetchCount(java.lang.Integer prefetch)
```
    Parameters:
    
    prefetch - the prefetch count
    
    See Also:
    
    AbstractMessageListenerContainer.setPrefetchCount(int)
  - setRecoveryInterval
```
public void setRecoveryInterval(java.lang.Long recoveryInterval)
```
    Parameters:
    
    recoveryInterval - The recovery interval.
    
    See Also:
    
    AbstractMessageListenerContainer.setRecoveryInterval(long)
  - setRecoveryBackOff
```
public void setRecoveryBackOff(org.springframework.util.backoff.BackOff recoveryBackOff)
```
    Parameters:
    
    recoveryBackOff - The BackOff to recover.
    
    Since:
    
    1.5
    
    See Also:
    
    AbstractMessageListenerContainer.setRecoveryBackOff(BackOff)
  - setMissingQueuesFatal
```
public void setMissingQueuesFatal(java.lang.Boolean missingQueuesFatal)
```
    Parameters:
    
    missingQueuesFatal - the missingQueuesFatal to set.
    
    See Also:
    
    AbstractMessageListenerContainer.setMissingQueuesFatal(boolean)
  - setMismatchedQueuesFatal
```
public void setMismatchedQueuesFatal(java.lang.Boolean mismatchedQueuesFatal)
```
    Parameters:
    
    mismatchedQueuesFatal - the mismatchedQueuesFatal to set.
    
    Since:
    
    1.6
    
    See Also:
    
    AbstractMessageListenerContainer.setMismatchedQueuesFatal(boolean)
  - setConsumerTagStrategy
```
public void setConsumerTagStrategy(org.springframework.amqp.support.ConsumerTagStrategy consumerTagStrategy)
```
    Parameters:
    
    consumerTagStrategy - the consumerTagStrategy to set
    
    See Also:
    
    AbstractMessageListenerContainer.setConsumerTagStrategy(ConsumerTagStrategy)
  - setIdleEventInterval
```
public void setIdleEventInterval(java.lang.Long idleEventInterval)
```
    How often to publish idle container events.
    
    Parameters:
    
    idleEventInterval - the interval.
  - setFailedDeclarationRetryInterval
```
public void setFailedDeclarationRetryInterval(java.lang.Long failedDeclarationRetryInterval)
```
  - setApplicationEventPublisher
```
public void setApplicationEventPublisher(org.springframework.context.ApplicationEventPublisher applicationEventPublisher)
```
    Specified by:
    
    setApplicationEventPublisher in interface org.springframework.context.ApplicationEventPublisherAware
  - setApplicationContext
```
public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
                           throws org.springframework.beans.BeansException
```
    Specified by:
    
    setApplicationContext in interface org.springframework.context.ApplicationContextAware
    
    Throws:
    
    org.springframework.beans.BeansException
  - setAutoStartup
```
public void setAutoStartup(java.lang.Boolean autoStartup)
```
    Parameters:
    
    autoStartup - true for auto startup.
    
    See Also:
    
    AbstractMessageListenerContainer.setAutoStartup(boolean)
  - setPhase
```
public void setPhase(int phase)
```
    Parameters:
    
    phase - The phase.
    
    See Also:
    
    AbstractMessageListenerContainer.setPhase(int)
  - setAfterReceivePostProcessors
```
public void setAfterReceivePostProcessors(org.springframework.amqp.core.MessagePostProcessor... postProcessors)
```
    Set post processors which will be applied after the Message is received.
    
    Parameters:
    
    postProcessors - the post processors.
    
    Since:
    
    2.0
    
    See Also:
    
    AbstractMessageListenerContainer.setAfterReceivePostProcessors(MessagePostProcessor...)
  - setContainerCustomizer
```
public void setContainerCustomizer(ContainerCustomizer<C> containerCustomizer)
```
    Set a ContainerCustomizer that is invoked after a container is created and configured to enable further customization of the container.
    
    Parameters:
    
    containerCustomizer - the customizer.
    
    Since:
    
    2.2.2
  - setBatchListener
```
public void setBatchListener(boolean isBatch)
```
    Set to true to receive a list of debatched messages that were created by a BatchingRabbitTemplate.
    
    Parameters:
    
    isBatch - true for a batch listener.
    
    Since:
    
    2.2
    
    See Also:
    
    setBatchingStrategy(BatchingStrategy)
  - setBatchingStrategy
```
public void setBatchingStrategy(BatchingStrategy batchingStrategy)
```
    Set a BatchingStrategy to use when debatching messages.
    
    Parameters:
    
    batchingStrategy - the batching strategy.
    
    Since:
    
    2.2
    
    See Also:
    
    setBatchListener(boolean)
  - setDeBatchingEnabled
```
public void setDeBatchingEnabled(java.lang.Boolean deBatchingEnabled)
```
    Determine whether or not the container should de-batch batched messages (true) or call the listener with the batch (false). Default: true.
    
    Parameters:
    
    deBatchingEnabled - whether or not to disable de-batching of messages.
    
    Since:
    
    2.2
    
    See Also:
    
    AbstractMessageListenerContainer.setDeBatchingEnabled(boolean)
  - setGlobalQos
```
public void setGlobalQos(boolean globalQos)
```
    Apply prefetch to the entire channel.
    
    Parameters:
    
    globalQos - true for a channel-wide prefetch.
    
    Since:
    
    2.2.17
    
    See Also:
    
    Channel.basicQos(int, boolean)
  - setMessageAckListener
```
public void setMessageAckListener(MessageAckListener messageAckListener)
```
    Set a MessageAckListener to use when ack a message(messages) in AcknowledgeMode.AUTO mode.
    
    Parameters:
    
    messageAckListener - the messageAckListener.
    
    Since:
    
    2.4.6
  - setForceStop
```
public void setForceStop(boolean forceStop)
```
    Set to true to stop the container after the current message(s) are processed and requeue any prefetched. Useful when using exclusive or single-active consumers.
    
    Parameters:
    
    forceStop - true to stop when current messsage(s) are processed.
    
    Since:
    
    2.4.15
  - createListenerContainer
```
public C createListenerContainer(RabbitListenerEndpoint endpoint)
```
    Description copied from interface: RabbitListenerContainerFactory
    
    Create a MessageListenerContainer for the given RabbitListenerEndpoint.
    
    Specified by:
    
    createListenerContainer in interface RabbitListenerContainerFactory<C extends AbstractMessageListenerContainer>
    
    Specified by:
    
    createListenerContainer in class BaseRabbitListenerContainerFactory<C extends AbstractMessageListenerContainer>
    
    Parameters:
    
    endpoint - the endpoint to configure.
    
    Returns:
    
    the created container.
  - createContainerInstance
```
protected abstract C createContainerInstance()
```
    Create an empty container instance.
    
    Returns:
    
    the new container instance.
  - initializeContainer
```
protected void initializeContainer(C instance,
                                   RabbitListenerEndpoint endpoint)
```
    Further initialize the specified container.
    Subclasses can inherit from this method to apply extra configuration if necessary.
    
    Parameters:
    
    instance - the container instance to configure.
    
    endpoint - the endpoint.

Modifier and Type	Field	Description
`protected java.util.concurrent.atomic.AtomicInteger`	`counter`
`protected org.apache.commons.logging.Log`	`logger`

Class AbstractRabbitListenerContainerFactory<C extends AbstractMessageListenerContainer>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.springframework.amqp.rabbit.config.BaseRabbitListenerContainerFactory

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory

Field Detail

logger

counter

Constructor Detail

AbstractRabbitListenerContainerFactory

Method Detail

setConnectionFactory

setErrorHandler

setMessageConverter

setAcknowledgeMode

setChannelTransacted

setTaskExecutor

setTransactionManager

setPrefetchCount

setRecoveryInterval

setRecoveryBackOff

setMissingQueuesFatal

setMismatchedQueuesFatal

setConsumerTagStrategy

setIdleEventInterval

setFailedDeclarationRetryInterval

setApplicationEventPublisher

setApplicationContext

setAutoStartup

setPhase

setAfterReceivePostProcessors

setContainerCustomizer

setBatchListener

setBatchingStrategy

setDeBatchingEnabled

setGlobalQos

setMessageAckListener

setForceStop

createListenerContainer

createContainerInstance

initializeContainer