RabbitMQComponent (Camel :: RabbitMQ 3.13.0 API)

java.lang.Object
- org.apache.camel.support.service.BaseService
- - org.apache.camel.support.service.ServiceSupport
  - - org.apache.camel.support.DefaultComponent
    - - org.apache.camel.component.rabbitmq.RabbitMQComponent

All Implemented Interfaces:

AutoCloseable, org.apache.camel.CamelContextAware, org.apache.camel.Component, org.apache.camel.Service, org.apache.camel.ShutdownableService, org.apache.camel.StatefulService, org.apache.camel.SuspendableService
```
@Component(value="rabbitmq")
public class RabbitMQComponent
extends org.apache.camel.support.DefaultComponent
```

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ARG_PREFIX`
`static String`	`BINDING_ARG_PREFIX`
`static String`	`DLQ_ARG_PREFIX`
`static String`	`DLQ_BINDING_PREFIX`
`static String`	`EXCHANGE_ARG_PREFIX`
`static String`	`QUEUE_ARG_PREFIX`

Fields inherited from class org.apache.camel.support.service.BaseService
BUILT, FAILED, INITIALIZED, INITIALIZING, lock, NEW, SHUTDOWN, SHUTTING_DOWN, STARTED, STARTING, status, STOPPED, STOPPING, SUSPENDED, SUSPENDING

Constructor Summary

Constructors
Constructor and Description

RabbitMQComponent()

RabbitMQComponent(org.apache.camel.CamelContext context)

Constructors
Constructor and Description
`RabbitMQComponent()`
`RabbitMQComponent(org.apache.camel.CamelContext context)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected RabbitMQEndpoint`	`createEndpoint(String uri, String remaining, Map<String,Object> params)`
`Map<String,Object>`	`getAdditionalHeaders()`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getAddresses()`
`Map<String,Object>`	`getArgs()`
`Boolean`	`getAutomaticRecoveryEnabled()`
`int`	`getChannelPoolMaxSize()` Get maximum number of opened channel in pool
`long`	`getChannelPoolMaxWait()`
`Map<String,Object>`	`getClientProperties()`
`com.rabbitmq.client.ConnectionFactory`	`getConnectionFactory()`
`com.rabbitmq.client.ExceptionHandler`	`getConnectionFactoryExceptionHandler()`
`int`	`getConnectionTimeout()`
`String`	`getDeadLetterExchange()`
`String`	`getDeadLetterExchangeType()`
`String`	`getDeadLetterQueue()`
`String`	`getDeadLetterRoutingKey()`
`String`	`getHostname()`
`Integer`	`getNetworkRecoveryInterval()`
`String`	`getPassword()`
`int`	`getPortNumber()`
`int`	`getPrefetchCount()`
`int`	`getPrefetchSize()`
`long`	`getPublisherAcknowledgementsTimeout()` The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server
`int`	`getRequestedChannelMax()`
`int`	`getRequestedFrameMax()`
`int`	`getRequestedHeartbeat()`
`long`	`getRequestTimeout()`
`long`	`getRequestTimeoutCheckerInterval()`
`String`	`getSslProtocol()`
`int`	`getThreadPoolSize()`
`Boolean`	`getTopologyRecoveryEnabled()`
`TrustManager`	`getTrustManager()`
`String`	`getUsername()`
`String`	`getVhost()`
`boolean`	`isAllowNullHeaders()` Allow pass null values to header
`boolean`	`isAutoAck()`
`boolean`	`isAutoDelete()`
`boolean`	`isAutoDetectConnectionFactory()`
`boolean`	`isDeclare()`
`boolean`	`isDurable()`
`boolean`	`isExclusive()`
`boolean`	`isExclusiveConsumer()`
`boolean`	`isGuaranteedDeliveries()` When true, an exception will be thrown when the message cannot be delivered (basic.return) and the message is marked as mandatory.
`boolean`	`isImmediate()`
`boolean`	`isMandatory()`
`boolean`	`isPassive()`
`boolean`	`isPrefetchEnabled()`
`boolean`	`isPrefetchGlobal()`
`boolean`	`isPublisherAcknowledgements()` When true, the message will be published with publisher acknowledgements turned on
`boolean`	`isRecoverFromDeclareException()`
`boolean`	`isSkipExchangeDeclare()`
`boolean`	`isSkipQueueBind()` If true the queue will not be bound to the exchange after declaring it
`boolean`	`isSkipQueueDeclare()`
`boolean`	`isTransferException()`
`void`	`setAdditionalHeaders(Map<String,Object> additionalHeaders)` Map of additional headers.
`void`	`setAdditionalProperties(Map<String,Object> additionalProperties)` Map of additional properties.
`void`	`setAddresses(String addresses)` If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses.
`void`	`setAllowNullHeaders(boolean allowNullHeaders)`
`void`	`setArgs(Map<String,Object> args)` Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each: Exchange: arg.exchange. Queue: arg.queue. Binding: arg.binding. DLQ: arg.dlq.queue. DLQ Binding: arg.dlq.binding. For example to declare a queue with message ttl argument: http://localhost:5672/exchange/queue?args=arg.queue.x-message-ttl=60000
`void`	`setAutoAck(boolean autoAck)` If messages should be auto acknowledged
`void`	`setAutoDelete(boolean autoDelete)` If it is true, the exchange will be deleted when it is no longer in use
`void`	`setAutoDetectConnectionFactory(boolean autoDetectConnectionFactory)` Whether to auto-detect looking up RabbitMQ connection factory from the registry.
`void`	`setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled)` Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application)
`void`	`setChannelPoolMaxSize(int channelPoolMaxSize)`
`void`	`setChannelPoolMaxWait(long channelPoolMaxWait)` Set the maximum number of milliseconds to wait for a channel from the pool
`void`	`setClientProperties(Map<String,Object> clientProperties)` Connection client properties (client info used in negotiating with the server)
`void`	`setConnectionFactory(com.rabbitmq.client.ConnectionFactory connectionFactory)` To use a custom RabbitMQ connection factory.
`void`	`setConnectionFactoryExceptionHandler(com.rabbitmq.client.ExceptionHandler connectionFactoryExceptionHandler)` Custom rabbitmq ExceptionHandler for ConnectionFactory
`void`	`setConnectionTimeout(int connectionTimeout)` Connection timeout
`void`	`setDeadLetterExchange(String deadLetterExchange)` The name of the dead letter exchange
`void`	`setDeadLetterExchangeType(String deadLetterExchangeType)` The type of the dead letter exchange
`void`	`setDeadLetterQueue(String deadLetterQueue)` The name of the dead letter queue
`void`	`setDeadLetterRoutingKey(String deadLetterRoutingKey)` The routing key for the dead letter exchange
`void`	`setDeclare(boolean declare)` If the option is true, camel declare the exchange and queue name and bind them together.
`void`	`setDurable(boolean durable)` If we are declaring a durable exchange (the exchange will survive a server restart)
`void`	`setExclusive(boolean exclusive)` Exclusive queues may only be accessed by the current connection, and are deleted when that connection closes.
`void`	`setExclusiveConsumer(boolean exclusiveConsumer)` Request exclusive access to the queue (meaning only this consumer can access the queue).
`void`	`setGuaranteedDeliveries(boolean guaranteedDeliveries)`
`void`	`setHostname(String hostname)` The hostname of the running RabbitMQ instance or cluster.
`void`	`setImmediate(boolean immediate)` This flag tells the server how to react if the message cannot be routed to a queue consumer immediately.
`void`	`setMandatory(boolean mandatory)` This flag tells the server how to react if the message cannot be routed to a queue.
`void`	`setNetworkRecoveryInterval(Integer networkRecoveryInterval)` Network recovery interval in milliseconds (interval used when recovering from network failure)
`void`	`setPassive(boolean passive)` Passive queues depend on the queue already to be available at RabbitMQ.
`void`	`setPassword(String password)` Password for authenticated access
`void`	`setPortNumber(int portNumber)` Port number for the host with the running rabbitmq instance or cluster.
`void`	`setPrefetchCount(int prefetchCount)` The maximum number of messages that the server will deliver, 0 if unlimited.
`void`	`setPrefetchEnabled(boolean prefetchEnabled)` Enables the quality of service on the RabbitMQConsumer side.
`void`	`setPrefetchGlobal(boolean prefetchGlobal)` If the settings should be applied to the entire channel rather than each consumer You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
`void`	`setPrefetchSize(int prefetchSize)` The maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited.
`void`	`setPublisherAcknowledgements(boolean publisherAcknowledgements)`
`void`	`setPublisherAcknowledgementsTimeout(long publisherAcknowledgementsTimeout)`
`void`	`setRecoverFromDeclareException(boolean recoverFromDeclareException)` Decides whether an exception during declaration of exchanges or queues is recoverable or not.
`void`	`setRequestedChannelMax(int requestedChannelMax)` Connection requested channel max (max number of channels offered)
`void`	`setRequestedFrameMax(int requestedFrameMax)` Connection requested frame max (max size of frame offered)
`void`	`setRequestedHeartbeat(int requestedHeartbeat)` Connection requested heartbeat (heart-beat in seconds offered)
`void`	`setRequestTimeout(long requestTimeout)` Set timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds)
`void`	`setRequestTimeoutCheckerInterval(long requestTimeoutCheckerInterval)` Set requestTimeoutCheckerInterval for inOut exchange
`void`	`setSkipExchangeDeclare(boolean skipExchangeDeclare)` This can be used if we need to declare the queue but not the exchange
`void`	`setSkipQueueBind(boolean skipQueueBind)`
`void`	`setSkipQueueDeclare(boolean skipQueueDeclare)` If true the producer will not declare and bind a queue.
`void`	`setSslProtocol(String sslProtocol)` Enables SSL on connection, accepted value are `true`, `TLS` and 'SSLv3`
`void`	`setThreadPoolSize(int threadPoolSize)` The consumer uses a Thread Pool Executor with a fixed number of threads.
`void`	`setTopologyRecoveryEnabled(Boolean topologyRecoveryEnabled)` Enables connection topology recovery (should topology recovery be performed?)
`void`	`setTransferException(boolean transferException)` When true and an inOut Exchange failed on the consumer side send the caused Exception back in the response
`void`	`setTrustManager(TrustManager trustManager)` Configure SSL trust manager, SSL should be enabled for this option to be effective
`void`	`setUsername(String username)` Username in case of authenticated access
`void`	`setVhost(String vhost)` The vhost for the channel

Methods inherited from class org.apache.camel.support.DefaultComponent
afterConfiguration, createEndpoint, createEndpoint, doBuild, doInit, doStart, doStop, getAndRemoveOrResolveReferenceParameter, getAndRemoveOrResolveReferenceParameter, getAndRemoveParameter, getAndRemoveParameter, getCamelContext, getComponentPropertyConfigurer, getDefaultName, getEndpointPropertyConfigurer, getExtension, getSupportedExtensions, ifStartsWithReturnRemainder, isAutowiredEnabled, isBridgeErrorHandler, isLazyStartProducer, registerExtension, registerExtension, resolveAndRemoveReferenceListParameter, resolveAndRemoveReferenceListParameter, resolveAndRemoveReferenceParameter, resolveAndRemoveReferenceParameter, resolveRawParameterValues, setAutowiredEnabled, setBridgeErrorHandler, setCamelContext, setLazyStartProducer, setProperties, setProperties, setProperties, useIntrospectionOnEndpoint, useRawUri, validateParameters, validateURI

Methods inherited from class org.apache.camel.support.service.BaseService
build, doFail, doLifecycleChange, doResume, doShutdown, doSuspend, fail, getStatus, init, isBuild, isInit, isNew, isRunAllowed, isShutdown, isStarted, isStarting, isStartingOrStarted, isStopped, isStopping, isStoppingOrStopped, isSuspended, isSuspending, isSuspendingOrSuspended, resume, shutdown, start, stop, suspend

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

Methods inherited from interface org.apache.camel.Component
trySetComponent

Methods inherited from interface org.apache.camel.CamelContextAware
trySetCamelContext

Methods inherited from interface org.apache.camel.Service
build, close, init, start, stop

Methods inherited from interface org.apache.camel.StatefulService
getStatus, isRunAllowed, isStarted, isStarting, isStopped, isStopping, isSuspending

Methods inherited from interface org.apache.camel.SuspendableService
isSuspended, resume, suspend

Methods inherited from interface org.apache.camel.ShutdownableService
shutdown

- Field Detail
  - ARG_PREFIX
```
public static final String ARG_PREFIX
```
    See Also:
    
    Constant Field Values
  - EXCHANGE_ARG_PREFIX
```
public static final String EXCHANGE_ARG_PREFIX
```
    See Also:
    
    Constant Field Values
  - QUEUE_ARG_PREFIX
```
public static final String QUEUE_ARG_PREFIX
```
    See Also:
    
    Constant Field Values
  - DLQ_ARG_PREFIX
```
public static final String DLQ_ARG_PREFIX
```
    See Also:
    
    Constant Field Values
  - DLQ_BINDING_PREFIX
```
public static final String DLQ_BINDING_PREFIX
```
    See Also:
    
    Constant Field Values
  - BINDING_ARG_PREFIX
```
public static final String BINDING_ARG_PREFIX
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RabbitMQComponent
```
public RabbitMQComponent()
```
  - RabbitMQComponent
```
public RabbitMQComponent(org.apache.camel.CamelContext context)
```
- Method Detail
  - createEndpoint
```
protected RabbitMQEndpoint createEndpoint(String uri,
                                          String remaining,
                                          Map<String,Object> params)
                                   throws Exception
```
    Specified by:
    
    createEndpoint in class org.apache.camel.support.DefaultComponent
    
    Throws:
    
    Exception
  - getHostname
```
public String getHostname()
```
  - setHostname
```
public void setHostname(String hostname)
```
    The hostname of the running RabbitMQ instance or cluster.
  - getPortNumber
```
public int getPortNumber()
```
  - setPortNumber
```
public void setPortNumber(int portNumber)
```
    Port number for the host with the running rabbitmq instance or cluster.
  - getUsername
```
public String getUsername()
```
  - setUsername
```
public void setUsername(String username)
```
    Username in case of authenticated access
  - getPassword
```
public String getPassword()
```
  - setPassword
```
public void setPassword(String password)
```
    Password for authenticated access
  - getVhost
```
public String getVhost()
```
  - setVhost
```
public void setVhost(String vhost)
```
    The vhost for the channel
  - setAddresses
```
public void setAddresses(String addresses)
```
    If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses. The addresses value is a string which looks like "server1:12345, server2:12345"
  - getAddresses
```
public String getAddresses()
```
  - getConnectionFactory
```
public com.rabbitmq.client.ConnectionFactory getConnectionFactory()
```
  - setConnectionFactory
```
public void setConnectionFactory(com.rabbitmq.client.ConnectionFactory connectionFactory)
```
    To use a custom RabbitMQ connection factory. When this option is set, all connection options (connectionTimeout, requestedChannelMax...) set on URI are not used
  - getThreadPoolSize
```
public int getThreadPoolSize()
```
  - setThreadPoolSize
```
public void setThreadPoolSize(int threadPoolSize)
```
    The consumer uses a Thread Pool Executor with a fixed number of threads. This setting allows you to set that number of threads.
  - isAutoDetectConnectionFactory
```
public boolean isAutoDetectConnectionFactory()
```
  - setAutoDetectConnectionFactory
```
public void setAutoDetectConnectionFactory(boolean autoDetectConnectionFactory)
```
    Whether to auto-detect looking up RabbitMQ connection factory from the registry. When enabled and a single instance of the connection factory is found then it will be used. An explicit connection factory can be configured on the component or endpoint level which takes precedence.
  - getConnectionTimeout
```
public int getConnectionTimeout()
```
  - setConnectionTimeout
```
public void setConnectionTimeout(int connectionTimeout)
```
    Connection timeout
  - getRequestedChannelMax
```
public int getRequestedChannelMax()
```
  - setRequestedChannelMax
```
public void setRequestedChannelMax(int requestedChannelMax)
```
    Connection requested channel max (max number of channels offered)
  - getRequestedFrameMax
```
public int getRequestedFrameMax()
```
  - setRequestedFrameMax
```
public void setRequestedFrameMax(int requestedFrameMax)
```
    Connection requested frame max (max size of frame offered)
  - getRequestedHeartbeat
```
public int getRequestedHeartbeat()
```
  - setRequestedHeartbeat
```
public void setRequestedHeartbeat(int requestedHeartbeat)
```
    Connection requested heartbeat (heart-beat in seconds offered)
  - getAutomaticRecoveryEnabled
```
public Boolean getAutomaticRecoveryEnabled()
```
  - setAutomaticRecoveryEnabled
```
public void setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled)
```
    Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application)
  - getNetworkRecoveryInterval
```
public Integer getNetworkRecoveryInterval()
```
  - setNetworkRecoveryInterval
```
public void setNetworkRecoveryInterval(Integer networkRecoveryInterval)
```
    Network recovery interval in milliseconds (interval used when recovering from network failure)
  - getTopologyRecoveryEnabled
```
public Boolean getTopologyRecoveryEnabled()
```
  - setTopologyRecoveryEnabled
```
public void setTopologyRecoveryEnabled(Boolean topologyRecoveryEnabled)
```
    Enables connection topology recovery (should topology recovery be performed?)
  - isPrefetchEnabled
```
public boolean isPrefetchEnabled()
```
  - setPrefetchEnabled
```
public void setPrefetchEnabled(boolean prefetchEnabled)
```
    Enables the quality of service on the RabbitMQConsumer side. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
  - setPrefetchSize
```
public void setPrefetchSize(int prefetchSize)
```
    The maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
  - getPrefetchSize
```
public int getPrefetchSize()
```
  - setPrefetchCount
```
public void setPrefetchCount(int prefetchCount)
```
    The maximum number of messages that the server will deliver, 0 if unlimited. You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
  - getPrefetchCount
```
public int getPrefetchCount()
```
  - setPrefetchGlobal
```
public void setPrefetchGlobal(boolean prefetchGlobal)
```
    If the settings should be applied to the entire channel rather than each consumer You need to specify the option of prefetchSize, prefetchCount, prefetchGlobal at the same time
  - isPrefetchGlobal
```
public boolean isPrefetchGlobal()
```
  - getChannelPoolMaxSize
```
public int getChannelPoolMaxSize()
```
    Get maximum number of opened channel in pool
  - setChannelPoolMaxSize
```
public void setChannelPoolMaxSize(int channelPoolMaxSize)
```
  - getChannelPoolMaxWait
```
public long getChannelPoolMaxWait()
```
  - setChannelPoolMaxWait
```
public void setChannelPoolMaxWait(long channelPoolMaxWait)
```
    Set the maximum number of milliseconds to wait for a channel from the pool
  - setRequestTimeout
```
public void setRequestTimeout(long requestTimeout)
```
    Set timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds)
  - getRequestTimeout
```
public long getRequestTimeout()
```
  - setRequestTimeoutCheckerInterval
```
public void setRequestTimeoutCheckerInterval(long requestTimeoutCheckerInterval)
```
    Set requestTimeoutCheckerInterval for inOut exchange
  - getRequestTimeoutCheckerInterval
```
public long getRequestTimeoutCheckerInterval()
```
  - setTransferException
```
public void setTransferException(boolean transferException)
```
    When true and an inOut Exchange failed on the consumer side send the caused Exception back in the response
  - isTransferException
```
public boolean isTransferException()
```
  - isPublisherAcknowledgements
```
public boolean isPublisherAcknowledgements()
```
    When true, the message will be published with publisher acknowledgements turned on
  - setPublisherAcknowledgements
```
public void setPublisherAcknowledgements(boolean publisherAcknowledgements)
```
  - getPublisherAcknowledgementsTimeout
```
public long getPublisherAcknowledgementsTimeout()
```
    The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server
  - setPublisherAcknowledgementsTimeout
```
public void setPublisherAcknowledgementsTimeout(long publisherAcknowledgementsTimeout)
```
  - isGuaranteedDeliveries
```
public boolean isGuaranteedDeliveries()
```
    When true, an exception will be thrown when the message cannot be delivered (basic.return) and the message is marked as mandatory. PublisherAcknowledgement will also be activated in this case. See also publisher acknowledgements - When will messages be confirmed.
  - setGuaranteedDeliveries
```
public void setGuaranteedDeliveries(boolean guaranteedDeliveries)
```
  - isMandatory
```
public boolean isMandatory()
```
  - setMandatory
```
public void setMandatory(boolean mandatory)
```
    This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
    If the header is present rabbitmq.MANDATORY it will override this option.
  - isImmediate
```
public boolean isImmediate()
```
  - setImmediate
```
public void setImmediate(boolean immediate)
```
    This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.
    If the header is present rabbitmq.IMMEDIATE it will override this option.
  - setArgs
```
public void setArgs(Map<String,Object> args)
```
    Specify arguments for configuring the different RabbitMQ concepts, a different prefix is required for each:
    - Exchange: arg.exchange.
    - Queue: arg.queue.
    - Binding: arg.binding.
    - DLQ: arg.dlq.queue.
    - DLQ Binding: arg.dlq.binding.
    For example to declare a queue with message ttl argument: http://localhost:5672/exchange/queue?args=arg.queue.x-message-ttl=60000
  - getArgs
```
public Map<String,Object> getArgs()
```
  - getClientProperties
```
public Map<String,Object> getClientProperties()
```
  - setClientProperties
```
public void setClientProperties(Map<String,Object> clientProperties)
```
    Connection client properties (client info used in negotiating with the server)
  - getSslProtocol
```
public String getSslProtocol()
```
  - setSslProtocol
```
public void setSslProtocol(String sslProtocol)
```
    Enables SSL on connection, accepted value are `true`, `TLS` and 'SSLv3`
  - getTrustManager
```
public TrustManager getTrustManager()
```
  - setTrustManager
```
public void setTrustManager(TrustManager trustManager)
```
    Configure SSL trust manager, SSL should be enabled for this option to be effective
  - isAutoAck
```
public boolean isAutoAck()
```
  - setAutoAck
```
public void setAutoAck(boolean autoAck)
```
    If messages should be auto acknowledged
  - isAutoDelete
```
public boolean isAutoDelete()
```
  - setAutoDelete
```
public void setAutoDelete(boolean autoDelete)
```
    If it is true, the exchange will be deleted when it is no longer in use
  - isDurable
```
public boolean isDurable()
```
  - setDurable
```
public void setDurable(boolean durable)
```
    If we are declaring a durable exchange (the exchange will survive a server restart)
  - isExclusive
```
public boolean isExclusive()
```
  - setExclusive
```
public void setExclusive(boolean exclusive)
```
    Exclusive queues may only be accessed by the current connection, and are deleted when that connection closes.
  - isExclusiveConsumer
```
public boolean isExclusiveConsumer()
```
  - setExclusiveConsumer
```
public void setExclusiveConsumer(boolean exclusiveConsumer)
```
    Request exclusive access to the queue (meaning only this consumer can access the queue). This is useful when you want a long-lived shared queue to be temporarily accessible by just one consumer.
  - isPassive
```
public boolean isPassive()
```
  - setPassive
```
public void setPassive(boolean passive)
```
    Passive queues depend on the queue already to be available at RabbitMQ.
  - setSkipQueueDeclare
```
public void setSkipQueueDeclare(boolean skipQueueDeclare)
```
    If true the producer will not declare and bind a queue. This can be used for directing messages via an existing routing key.
  - isSkipQueueDeclare
```
public boolean isSkipQueueDeclare()
```
  - isSkipQueueBind
```
public boolean isSkipQueueBind()
```
    If true the queue will not be bound to the exchange after declaring it
  - setSkipQueueBind
```
public void setSkipQueueBind(boolean skipQueueBind)
```
  - setSkipExchangeDeclare
```
public void setSkipExchangeDeclare(boolean skipExchangeDeclare)
```
    This can be used if we need to declare the queue but not the exchange
  - isSkipExchangeDeclare
```
public boolean isSkipExchangeDeclare()
```
  - isDeclare
```
public boolean isDeclare()
```
  - setDeclare
```
public void setDeclare(boolean declare)
```
    If the option is true, camel declare the exchange and queue name and bind them together. If the option is false, camel won't declare the exchange and queue name on the server.
  - getDeadLetterExchange
```
public String getDeadLetterExchange()
```
  - setDeadLetterExchange
```
public void setDeadLetterExchange(String deadLetterExchange)
```
    The name of the dead letter exchange
  - getDeadLetterQueue
```
public String getDeadLetterQueue()
```
  - setDeadLetterQueue
```
public void setDeadLetterQueue(String deadLetterQueue)
```
    The name of the dead letter queue
  - getDeadLetterRoutingKey
```
public String getDeadLetterRoutingKey()
```
  - setDeadLetterRoutingKey
```
public void setDeadLetterRoutingKey(String deadLetterRoutingKey)
```
    The routing key for the dead letter exchange
  - getDeadLetterExchangeType
```
public String getDeadLetterExchangeType()
```
  - setDeadLetterExchangeType
```
public void setDeadLetterExchangeType(String deadLetterExchangeType)
```
    The type of the dead letter exchange
  - isAllowNullHeaders
```
public boolean isAllowNullHeaders()
```
    Allow pass null values to header
  - setAllowNullHeaders
```
public void setAllowNullHeaders(boolean allowNullHeaders)
```
  - setAdditionalHeaders
```
public void setAdditionalHeaders(Map<String,Object> additionalHeaders)
```
    Map of additional headers. These headers will be set only when the 'allowCustomHeaders' is set to true
  - getAdditionalHeaders
```
public Map<String,Object> getAdditionalHeaders()
```
  - setAdditionalProperties
```
public void setAdditionalProperties(Map<String,Object> additionalProperties)
```
    Map of additional properties. These are standard RabbitMQ properties as defined in AMQP.BasicProperties The map keys should be from RabbitMQConstants. Any other keys will be ignored. When the message already contains these headers they will be given precedence over these properties.
  - getAdditionalProperties
```
public Map<String,Object> getAdditionalProperties()
```
  - getConnectionFactoryExceptionHandler
```
public com.rabbitmq.client.ExceptionHandler getConnectionFactoryExceptionHandler()
```
  - setConnectionFactoryExceptionHandler
```
public void setConnectionFactoryExceptionHandler(com.rabbitmq.client.ExceptionHandler connectionFactoryExceptionHandler)
```
    Custom rabbitmq ExceptionHandler for ConnectionFactory
  - isRecoverFromDeclareException
```
public boolean isRecoverFromDeclareException()
```
  - setRecoverFromDeclareException
```
public void setRecoverFromDeclareException(boolean recoverFromDeclareException)
```
    Decides whether an exception during declaration of exchanges or queues is recoverable or not. If the option is false, camel will throw an exception when starting the consumer, which will interrupt application startup (e.g. in the case when the exchange / queue is already declared in RabbitMQ and has incompatible configuration). If set to true, the consumer will try to reconnect periodically.

Class RabbitMQComponent

Field Summary

Fields inherited from class org.apache.camel.support.service.BaseService

Constructor Summary

Method Summary

Methods inherited from class org.apache.camel.support.DefaultComponent

Methods inherited from class org.apache.camel.support.service.BaseService

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.camel.Component

Methods inherited from interface org.apache.camel.CamelContextAware

Methods inherited from interface org.apache.camel.Service

Methods inherited from interface org.apache.camel.StatefulService

Methods inherited from interface org.apache.camel.SuspendableService

Methods inherited from interface org.apache.camel.ShutdownableService

Field Detail

ARG_PREFIX

EXCHANGE_ARG_PREFIX

QUEUE_ARG_PREFIX

DLQ_ARG_PREFIX

DLQ_BINDING_PREFIX

BINDING_ARG_PREFIX

Constructor Detail

RabbitMQComponent

RabbitMQComponent

Method Detail

createEndpoint

getHostname

setHostname

getPortNumber

setPortNumber

getUsername

setUsername

getPassword

setPassword

getVhost

setVhost

setAddresses

getAddresses

getConnectionFactory

setConnectionFactory

getThreadPoolSize

setThreadPoolSize

isAutoDetectConnectionFactory

setAutoDetectConnectionFactory

getConnectionTimeout

setConnectionTimeout

getRequestedChannelMax

setRequestedChannelMax

getRequestedFrameMax

setRequestedFrameMax

getRequestedHeartbeat

setRequestedHeartbeat

getAutomaticRecoveryEnabled

setAutomaticRecoveryEnabled

getNetworkRecoveryInterval

setNetworkRecoveryInterval

getTopologyRecoveryEnabled

setTopologyRecoveryEnabled

isPrefetchEnabled

setPrefetchEnabled

setPrefetchSize

getPrefetchSize

setPrefetchCount

getPrefetchCount

setPrefetchGlobal

isPrefetchGlobal

getChannelPoolMaxSize

setChannelPoolMaxSize

getChannelPoolMaxWait

setChannelPoolMaxWait

setRequestTimeout

getRequestTimeout

setRequestTimeoutCheckerInterval

getRequestTimeoutCheckerInterval

setTransferException

isTransferException

isPublisherAcknowledgements

setPublisherAcknowledgements

getPublisherAcknowledgementsTimeout

setPublisherAcknowledgementsTimeout