RabbitMQEndpoint (Camel :: RabbitMQ 3.4.2 API)

java.lang.Object
- org.apache.camel.support.service.BaseService
- - org.apache.camel.support.service.ServiceSupport
  - - org.apache.camel.support.DefaultEndpoint
    - - org.apache.camel.component.rabbitmq.RabbitMQEndpoint

All Implemented Interfaces:

AutoCloseable, org.apache.camel.AsyncEndpoint, org.apache.camel.CamelContextAware, org.apache.camel.Endpoint, org.apache.camel.IsSingleton, org.apache.camel.Service, org.apache.camel.ShutdownableService, org.apache.camel.spi.HasId, org.apache.camel.StatefulService, org.apache.camel.SuspendableService
```
@UriEndpoint(firstVersion="2.12.0",
             scheme="rabbitmq",
             title="RabbitMQ",
             syntax="rabbitmq:exchangeName",
             category=MESSAGING)
public class RabbitMQEndpoint
extends org.apache.camel.support.DefaultEndpoint
implements org.apache.camel.AsyncEndpoint
```
Send and receive messages from RabbitMQ instances.

Field Summary

Fields
Modifier and Type Field and Description

static String SERIALIZE_HEADER
- Fields inherited from class org.apache.camel.support.service.BaseService
  BUILDED, FAILED, INITIALIZED, INITIALIZING, lock, NEW, SHUTDOWN, SHUTTINGDOWN, STARTED, STARTING, status, STOPPED, STOPPING, SUSPENDED, SUSPENDING

Fields
Modifier and Type	Field and Description
`static String`	`SERIALIZE_HEADER`

Constructor Summary

Constructors
Constructor and Description
`RabbitMQEndpoint()`
`RabbitMQEndpoint(String endpointUri, RabbitMQComponent component)`
`RabbitMQEndpoint(String endpointUri, RabbitMQComponent component, com.rabbitmq.client.ConnectionFactory connectionFactory)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`com.rabbitmq.client.Connection`	`connect(ExecutorService executor)`
`org.apache.camel.Consumer`	`createConsumer(org.apache.camel.Processor processor)`
`protected ExecutorService`	`createExecutor()`
`org.apache.camel.Producer`	`createProducer()`
`org.apache.camel.Exchange`	`createRabbitExchange(com.rabbitmq.client.Envelope envelope, com.rabbitmq.client.AMQP.BasicProperties properties, byte[] body)`
`void`	`declareExchangeAndQueue(com.rabbitmq.client.Channel channel)` If needed, declare Exchange, declare Queue and bind them with Routing Key
`String`	`getAddresses()`
`Map<String,Object>`	`getArgs()`
`Boolean`	`getAutomaticRecoveryEnabled()`
`Map<String,Object>`	`getBindingArgs()`
`int`	`getChannelPoolMaxSize()` Get maximum number of opened channel in pool
`long`	`getChannelPoolMaxWait()`
`Map<String,Object>`	`getClientProperties()`
`int`	`getConcurrentConsumers()`
`com.rabbitmq.client.ConnectionFactory`	`getConnectionFactory()`
`com.rabbitmq.client.ExceptionHandler`	`getConnectionFactoryExceptionHandler()`
`int`	`getConnectionTimeout()`
`String`	`getConsumerTag()`
`String`	`getDeadLetterExchange()`
`String`	`getDeadLetterExchangeType()`
`String`	`getDeadLetterQueue()`
`String`	`getDeadLetterRoutingKey()`
`Map<String,Object>`	`getExchangeArgs()`
`String`	`getExchangeName()`
`String`	`getExchangeType()`
`String`	`getHostname()`
`protected RabbitMQMessageConverter`	`getMessageConverter()` Gets the message converter to convert between rabbit and camel
`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
`String`	`getQueue()`
`Map<String,Object>`	`getQueueArgs()`
`String`	`getReplyTo()` Gets the Queue to reply to if you dont want to use temporary reply queues
`String`	`getReplyToType()` Get replyToType for inOut exchange
`int`	`getRequestedChannelMax()`
`int`	`getRequestedFrameMax()`
`int`	`getRequestedHeartbeat()`
`long`	`getRequestTimeout()`
`long`	`getRequestTimeoutCheckerInterval()`
`String`	`getRoutingKey()`
`String`	`getSslProtocol()`
`int`	`getThreadPoolSize()`
`Boolean`	`getTopologyRecoveryEnabled()`
`TrustManager`	`getTrustManager()`
`String`	`getUsername()`
`String`	`getVhost()`
`boolean`	`isAllowCustomHeaders()`
`boolean`	`isAllowMessageBodySerialization()`
`boolean`	`isAllowNullHeaders()` Allow pass null values to header
`boolean`	`isAutoAck()`
`boolean`	`isAutoDelete()`
`boolean`	`isBridgeEndpoint()`
`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`	`isSkipExchangeDeclare()`
`boolean`	`isSkipQueueBind()` If true the queue will not be bound to the exchange after declaring it
`boolean`	`isSkipQueueDeclare()`
`boolean`	`isTransferException()`
`boolean`	`isUseMessageIDAsCorrelationID()` Get useMessageIDAsCorrelationID for inOut exchange
`com.rabbitmq.client.Address[]`	`parseAddresses()`
`void`	`publishExchangeToChannel(org.apache.camel.Exchange camelExchange, com.rabbitmq.client.Channel channel, String routingKey)` Sends the body that is on the exchange
`void`	`setAddresses(String addresses)` If this option is set, camel-rabbitmq will try to create connection based on the setting of option addresses.
`void`	`setAllowCustomHeaders(boolean allowCustomHeaders)` Allow pass custom values to header
`void`	`setAllowMessageBodySerialization(boolean allowMessageBodySerialization)` Whether to allow Java serialization of the message body or not.
`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. 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`	`setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled)` Enables connection automatic recovery (uses connection implementation that performs automatic recovery when existing connection has failures)
`void`	`setBridgeEndpoint(boolean bridgeEndpoint)` If the bridgeEndpoint is true, the producer will ignore the message header of "rabbitmq.EXCHANGE_NAME" and "rabbitmq.ROUTING_KEY"
`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`	`setConcurrentConsumers(int concurrentConsumers)` Number of concurrent consumers when consuming from broker.
`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`	`setConsumerTag(String consumerTag)` Specify a client-generated consumer tag to establish context when invoking the consume operation
`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`	`setExchangeName(String exchangeName)` The exchange name determines the exchange to which the produced messages will be sent to.
`void`	`setExchangeType(String exchangeType)` The exchange type such as direct or topic.
`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`	`setQueue(String queue)` The queue to receive messages from
`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`	`setRoutingKey(String routingKey)` The routing key to use when binding a consumer queue to the 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.DefaultEndpoint
configureConsumer, configurePollingConsumer, configureProperties, createAsyncProducer, createEndpointUri, createExchange, createExchange, createPollingConsumer, doInit, doStart, doStop, equals, getCamelContext, getComponent, getEndpointKey, getEndpointUri, getExceptionHandler, getExchangePattern, getId, getPollingConsumerBlockTimeout, getPollingConsumerQueueSize, hashCode, isBasicPropertyBinding, isBridgeErrorHandler, isLazyStartProducer, isLenientProperties, isPollingConsumerBlockWhenFull, isSingleton, isSynchronous, setBasicPropertyBinding, setBridgeErrorHandler, setCamelContext, setComponent, setEndpointUri, setEndpointUriIfNotSpecified, setExceptionHandler, setExchangePattern, setLazyStartProducer, setPollingConsumerBlockTimeout, setPollingConsumerBlockWhenFull, setPollingConsumerQueueSize, setProperties, setSynchronous, toString

Methods inherited from class org.apache.camel.support.service.BaseService
build, doBuild, 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, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.camel.Endpoint
configureProperties, createAsyncProducer, createExchange, createExchange, createPollingConsumer, getCamelContext, getEndpointBaseUri, getEndpointKey, getEndpointUri, isLenientProperties, isSingletonProducer, setCamelContext

Methods inherited from interface org.apache.camel.IsSingleton
isSingleton

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

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

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
  - SERIALIZE_HEADER
```
public static final String SERIALIZE_HEADER
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RabbitMQEndpoint
```
public RabbitMQEndpoint()
```
  - RabbitMQEndpoint
```
public RabbitMQEndpoint(String endpointUri,
                        RabbitMQComponent component)
```
  - RabbitMQEndpoint
```
public RabbitMQEndpoint(String endpointUri,
                        RabbitMQComponent component,
                        com.rabbitmq.client.ConnectionFactory connectionFactory)
```
- Method Detail
  - createRabbitExchange
```
public org.apache.camel.Exchange createRabbitExchange(com.rabbitmq.client.Envelope envelope,
                                                      com.rabbitmq.client.AMQP.BasicProperties properties,
                                                      byte[] body)
```
  - getMessageConverter
```
protected RabbitMQMessageConverter getMessageConverter()
```
    Gets the message converter to convert between rabbit and camel
  - publishExchangeToChannel
```
public void publishExchangeToChannel(org.apache.camel.Exchange camelExchange,
                                     com.rabbitmq.client.Channel channel,
                                     String routingKey)
                              throws IOException
```
    Sends the body that is on the exchange
    
    Throws:
    
    IOException
  - createConsumer
```
public org.apache.camel.Consumer createConsumer(org.apache.camel.Processor processor)
                                         throws Exception
```
    Specified by:
    
    createConsumer in interface org.apache.camel.Endpoint
    
    Throws:
    
    Exception
  - connect
```
public com.rabbitmq.client.Connection connect(ExecutorService executor)
                                       throws IOException,
                                              TimeoutException
```
    Throws:
    
    IOException
    
    TimeoutException
  - declareExchangeAndQueue
```
public void declareExchangeAndQueue(com.rabbitmq.client.Channel channel)
                             throws IOException
```
    If needed, declare Exchange, declare Queue and bind them with Routing Key
    
    Throws:
    
    IOException
  - createProducer
```
public org.apache.camel.Producer createProducer()
                                         throws Exception
```
    Specified by:
    
    createProducer in interface org.apache.camel.Endpoint
    
    Throws:
    
    Exception
  - createExecutor
```
protected ExecutorService createExecutor()
```
  - 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
  - getHostname
```
public String getHostname()
```
  - setHostname
```
public void setHostname(String hostname)
```
    The hostname of the running rabbitmq instance or cluster.
  - 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.
  - getPortNumber
```
public int getPortNumber()
```
  - setPortNumber
```
public void setPortNumber(int portNumber)
```
    Port number for the host with the running rabbitmq instance or cluster. Default value is 5672.
  - 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)
  - getQueue
```
public String getQueue()
```
  - setQueue
```
public void setQueue(String queue)
```
    The queue to receive messages from
  - getExchangeName
```
public String getExchangeName()
```
  - setExchangeName
```
public void setExchangeName(String exchangeName)
```
    The exchange name determines the exchange to which the produced messages will be sent to. In the case of consumers, the exchange name determines the exchange the queue will be bound to.
  - getExchangeType
```
public String getExchangeType()
```
  - setExchangeType
```
public void setExchangeType(String exchangeType)
```
    The exchange type such as direct or topic.
  - getRoutingKey
```
public String getRoutingKey()
```
  - setRoutingKey
```
public void setRoutingKey(String routingKey)
```
    The routing key to use when binding a consumer queue to the exchange. For producer routing keys, you set the header rabbitmq.ROUTING_KEY.
  - 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()
```
  - setBridgeEndpoint
```
public void setBridgeEndpoint(boolean bridgeEndpoint)
```
    If the bridgeEndpoint is true, the producer will ignore the message header of "rabbitmq.EXCHANGE_NAME" and "rabbitmq.ROUTING_KEY"
  - isBridgeEndpoint
```
public boolean isBridgeEndpoint()
```
  - 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()
```
  - parseAddresses
```
public com.rabbitmq.client.Address[] parseAddresses()
```
  - 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)
  - getSslProtocol
```
public String getSslProtocol()
```
  - setSslProtocol
```
public void setSslProtocol(String sslProtocol)
```
    Enables SSL on connection, accepted value are `true`, `TLS` and 'SSLv3`
  - 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
  - getTrustManager
```
public TrustManager getTrustManager()
```
  - setTrustManager
```
public void setTrustManager(TrustManager trustManager)
```
    Configure SSL trust manager, SSL should be enabled for this option to be effective
  - 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)
  - getAutomaticRecoveryEnabled
```
public Boolean getAutomaticRecoveryEnabled()
```
  - setAutomaticRecoveryEnabled
```
public void setAutomaticRecoveryEnabled(Boolean automaticRecoveryEnabled)
```
    Enables connection automatic recovery (uses connection implementation that performs automatic recovery when existing connection has failures)
  - isAllowMessageBodySerialization
```
public boolean isAllowMessageBodySerialization()
```
  - setAllowMessageBodySerialization
```
public void setAllowMessageBodySerialization(boolean allowMessageBodySerialization)
```
    Whether to allow Java serialization of the message body or not. If this value is true, the message body will be serialized on the producer side using Java serialization, if no type converter can handle the message body. On the consumer side, it will deserialize the message body if this value is true and the message contains a CamelSerialize header. Setting this value to true may introduce a security vulnerability as it allows an attacker to attempt to deserialize to a gadget object which could result in a RCE or other security vulnerability.
  - 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()
```
  - getConcurrentConsumers
```
public int getConcurrentConsumers()
```
  - setConcurrentConsumers
```
public void setConcurrentConsumers(int concurrentConsumers)
```
    Number of concurrent consumers when consuming from broker. (eg similar as to the same option for the JMS component).
  - 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
  - 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
  - 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.
    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()
```
  - getExchangeArgs
```
public Map<String,Object> getExchangeArgs()
```
  - getQueueArgs
```
public Map<String,Object> getQueueArgs()
```
  - getBindingArgs
```
public Map<String,Object> getBindingArgs()
```
  - 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()
```
  - isUseMessageIDAsCorrelationID
```
public boolean isUseMessageIDAsCorrelationID()
```
    Get useMessageIDAsCorrelationID for inOut exchange
  - 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)
```
  - getReplyToType
```
public String getReplyToType()
```
    Get replyToType for inOut exchange
  - getReplyTo
```
public String getReplyTo()
```
    Gets the Queue to reply to if you dont want to use temporary reply queues
  - 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.
  - isAllowNullHeaders
```
public boolean isAllowNullHeaders()
```
    Allow pass null values to header
  - setAllowNullHeaders
```
public void setAllowNullHeaders(boolean allowNullHeaders)
```
  - isPassive
```
public boolean isPassive()
```
  - setPassive
```
public void setPassive(boolean passive)
```
    Passive queues depend on the queue already to be available at RabbitMQ.
  - getConsumerTag
```
public String getConsumerTag()
```
  - setConsumerTag
```
public void setConsumerTag(String consumerTag)
```
    Specify a client-generated consumer tag to establish context when invoking the consume operation
  - isAllowCustomHeaders
```
public boolean isAllowCustomHeaders()
```
  - setAllowCustomHeaders
```
public void setAllowCustomHeaders(boolean allowCustomHeaders)
```
    Allow pass custom values to header
  - getConnectionFactoryExceptionHandler
```
public com.rabbitmq.client.ExceptionHandler getConnectionFactoryExceptionHandler()
```
  - setConnectionFactoryExceptionHandler
```
public void setConnectionFactoryExceptionHandler(com.rabbitmq.client.ExceptionHandler connectionFactoryExceptionHandler)
```
    Custom rabbitmq ExceptionHandler for ConnectionFactory

Class RabbitMQEndpoint

Field Summary

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.camel.Endpoint

Methods inherited from interface org.apache.camel.IsSingleton

Methods inherited from interface org.apache.camel.Service

Methods inherited from interface org.apache.camel.CamelContextAware

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

SERIALIZE_HEADER

Constructor Detail

RabbitMQEndpoint

RabbitMQEndpoint

RabbitMQEndpoint

Method Detail

createRabbitExchange

getMessageConverter

publishExchangeToChannel

createConsumer

connect

declareExchangeAndQueue

createProducer

createExecutor

getUsername

setUsername

getPassword

setPassword

getVhost

setVhost

getHostname

setHostname

getThreadPoolSize

setThreadPoolSize

getPortNumber

setPortNumber

isAutoAck

setAutoAck

isAutoDelete

setAutoDelete

isDurable

setDurable

getQueue

setQueue

getExchangeName

setExchangeName

getExchangeType

setExchangeType

getRoutingKey

setRoutingKey

setSkipQueueDeclare

isSkipQueueDeclare

isSkipQueueBind

setSkipQueueBind

setSkipExchangeDeclare

isSkipExchangeDeclare

setBridgeEndpoint

isBridgeEndpoint

setAddresses

getAddresses

parseAddresses

getConnectionTimeout

setConnectionTimeout

getRequestedChannelMax

setRequestedChannelMax

getRequestedFrameMax

setRequestedFrameMax

getRequestedHeartbeat

setRequestedHeartbeat

getSslProtocol

setSslProtocol

getConnectionFactory

setConnectionFactory

getTrustManager