RabbitMQ Component

Table of Contents

URI format
Options
Custom connection factory
Message Body
Samples
See Also

Available as of Camel 2.12

The rabbitmq: component allows you produce and consume messages from RabbitMQ instances. Using the RabbitMQ AMQP client, this component offers a pure RabbitMQ approach over the generic AMQP component.

Maven users will need to add the following dependency to their pom.xml for this component:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-rabbitmq</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>

URI format

rabbitmq://hostname[:port]/exchangeName?[options]

Where hostname is the hostname of the running rabbitmq instance or cluster. Port is optional and if not specified then defaults to the RabbitMQ client default (5672). The exchange name determines which exchange produced messages will sent to. In the case of consumers, the exchange name determines which exchange the queue will bind to.

Options

The RabbitMQ component has no options.

The RabbitMQ component supports 56 endpoint options which are listed below:

{% raw %}

Name	Group	Default	Java Type	Description
hostname	common		`String`	Required The hostname of the running rabbitmq instance or cluster.
portNumber	common	`5672`	`int`	Required Port number for the host with the running rabbitmq instance or cluster. Default value is 5672.
exchangeName	common		`String`	Required The exchange name determines which exchange produced messages will sent to. In the case of consumers the exchange name determines which exchange the queue will bind to.
autoDelete	common	`true`	`boolean`	If it is true the exchange will be deleted when it is no longer in use
connectionTimeout	common	`60000`	`int`	Connection timeout
deadLetterExchange	common		`String`	The name of the dead letter exchange
deadLetterExchangeType	common	`direct`	`String`	The type of the dead letter exchange
deadLetterQueue	common		`String`	The name of the dead letter queue
deadLetterRoutingKey	common		`String`	The routing key for the dead letter exchange
declare	common	`true`	`boolean`	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.
durable	common	`true`	`boolean`	If we are declaring a durable exchange (the exchange will survive a server restart)
exchangeType	common	`direct`	`String`	The exchange type such as direct or topic.
exclusive	common	`false`	`boolean`	Exclusive queues may only be accessed by the current connection and are deleted when that connection closes.
queue	common		`String`	The queue to receive messages from
routingKey	common		`String`	The routing key to use when binding a consumer queue to the exchange. For producer routing keys you set the header rabbitmq.ROUTING_KEY.
skipExchangeDeclare	common	`false`	`boolean`	This can be used if we need to declare the queue but not the exchange
skipQueueBind	common	`false`	`boolean`	If true the queue will not be bound to the exchange after declaring it
skipQueueDeclare	common	`false`	`boolean`	If true the producer will not declare and bind a queue. This can be used for directing messages via an existing routing key.
vhost	common	`/`	`String`	The vhost for the channel
autoAck	consumer	`true`	`boolean`	If messages should be auto acknowledged
bridgeErrorHandler	consumer	`false`	`boolean`	Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
concurrentConsumers	consumer	`1`	`int`	Number of concurrent consumers when consuming from broker. (eg similar as to the same option for the JMS component).
prefetchCount	consumer		`int`	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
prefetchEnabled	consumer	`false`	`boolean`	Enables the quality of service on the RabbitMQConsumer side. You need to specify the option of prefetchSize prefetchCount prefetchGlobal at the same time
prefetchGlobal	consumer	`false`	`boolean`	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
prefetchSize	consumer		`int`	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
exceptionHandler	consumer (advanced)		`ExceptionHandler`	To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
exchangePattern	consumer (advanced)		`ExchangePattern`	Sets the exchange pattern when the consumer creates an exchange.
threadPoolSize	consumer (advanced)	`10`	`int`	The consumer uses a Thread Pool Executor with a fixed number of threads. This setting allows you to set that number of threads.
bridgeEndpoint	producer	`false`	`boolean`	If the bridgeEndpoint is true the producer will ignore the message header of rabbitmq.EXCHANGE_NAME and rabbitmq.ROUTING_KEY
channelPoolMaxSize	producer	`10`	`int`	Get maximum number of opened channel in pool
channelPoolMaxWait	producer	`1000`	`long`	Set the maximum number of milliseconds to wait for a channel from the pool
guaranteedDeliveries	producer	`false`	`boolean`	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
immediate	producer	`false`	`boolean`	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.
mandatory	producer	`false`	`boolean`	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.
publisherAcknowledgements	producer	`false`	`boolean`	When true the message will be published with publisher acknowledgements turned on
publisherAcknowledgementsTimeout	producer		`long`	The amount of time in milliseconds to wait for a basic.ack response from RabbitMQ server
addresses	advanced		`Address[]`	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
automaticRecoveryEnabled	advanced		`Boolean`	Enables connection automatic recovery (uses connection implementation that performs automatic recovery when connection shutdown is not initiated by the application)
clientProperties	advanced		`Map`	Connection client properties (client info used in negotiating with the server)
connectionFactory	advanced		`ConnectionFactory`	To use a custom RabbitMQ connection factory. When this option is set all connection options (connectionTimeout requestedChannelMax…) set on URI are not used
exchangeArgsConfigurer	advanced		`ArgsConfigurer`	Set the configurer for setting the exchange args in Channel.exchangeDeclare
networkRecoveryInterval	advanced		`Integer`	Network recovery interval in milliseconds (interval used when recovering from network failure)
queueArgsConfigurer	advanced		`ArgsConfigurer`	Set the configurer for setting the queue args in Channel.queueDeclare
requestedChannelMax	advanced	`0`	`int`	Connection requested channel max (max number of channels offered)
requestedFrameMax	advanced	`0`	`int`	Connection requested frame max (max size of frame offered)
requestedHeartbeat	advanced	`60`	`int`	Connection requested heartbeat (heart-beat in seconds offered)
requestTimeout	advanced		`long`	Set timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds)
requestTimeoutCheckerInterval	advanced		`long`	Set requestTimeoutCheckerInterval for inOut exchange
synchronous	advanced	`false`	`boolean`	Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
topologyRecoveryEnabled	advanced		`Boolean`	Enables connection topology recovery (should topology recovery be performed)
transferException	advanced	`false`	`boolean`	When true and an inOut Exchange failed on the consumer side send the caused Exception back in the response
password	security	`guest`	`String`	Password for authenticated access
sslProtocol	security		`String`	Enables SSL on connection accepted value are true TLS and 'SSLv3
trustManager	security		`TrustManager`	Configure SSL trust manager SSL should be enabled for this option to be effective
username	security	`guest`	`String`	Username in case of authenticated access

{% endraw %}

See http://www.rabbitmq.com/releases/rabbitmq-java-client/current-javadoc/com/rabbitmq/client/ConnectionFactory.html and the AMQP specification for more information on connection options.

Custom connection factory

<bean id="customConnectionFactory" class="com.rabbitmq.client.ConnectionFactory">
  <property name="host" value="localhost"/>
  <property name="port" value="5672"/>
  <property name="username" value="camel"/>
  <property name="password" value="bugsbunny"/>
</bean>
<camelContext>
  <route>
    <from uri="direct:rabbitMQEx2"/>
    <to uri="rabbitmq://localhost:5672/ex2?connectionFactory=#customConnectionFactory"/>
  </route>
</camelContext>

Headers

The following headers are set on exchanges when consuming messages.

Property	Value
`rabbitmq.ROUTING_KEY`	The routing key that was used to receive the message, or the routing key that will be used when producing a message
`rabbitmq.EXCHANGE_NAME`	The exchange the message was received from
`rabbitmq.DELIVERY_TAG`	The rabbitmq delivery tag of the received message
`rabbitmq.REQUEUE`	Camel 2.14.2: This is used by the consumer to control rejection of the message. When the consumer is complete processing the exchange, and if the exchange failed, then the consumer is going to reject the message from the RabbitMQ broker. The value of this header controls this behavior. If the value is false (by default) then the message is discarded/dead-lettered. If the value is true, then the message is re-queued.

The following headers are used by the producer. If these are set on the camel exchange then they will be set on the RabbitMQ message.

Property	Value
`rabbitmq.ROUTING_KEY`	The routing key that will be used when sending the message
`rabbitmq.EXCHANGE_NAME`	The exchange the message was received from, or sent to
`rabbitmq.CONTENT_TYPE`	The contentType to set on the RabbitMQ message
`rabbitmq.PRIORITY`	The priority header to set on the RabbitMQ message
`rabbitmq.CORRELATIONID`	The correlationId to set on the RabbitMQ message
`rabbitmq.MESSAGE_ID`	The message id to set on the RabbitMQ message
`rabbitmq.DELIVERY_MODE`	If the message should be persistent or not
`rabbitmq.USERID`	The userId to set on the RabbitMQ message
`rabbitmq.CLUSTERID`	The clusterId to set on the RabbitMQ message
`rabbitmq.REPLY_TO`	The replyTo to set on the RabbitMQ message
`rabbitmq.CONTENT_ENCODING`	The contentEncoding to set on the RabbitMQ message
`rabbitmq.TYPE`	The type to set on the RabbitMQ message
`rabbitmq.EXPIRATION`	The expiration to set on the RabbitMQ message
`rabbitmq.TIMESTAMP`	The timestamp to set on the RabbitMQ message
`rabbitmq.APP_ID`	The appId to set on the RabbitMQ message

Headers are set by the consumer once the message is received. The producer will also set the headers for downstream processors once the exchange has taken place. Any headers set prior to production that the producer sets will be overriden.

Message Body

The component will use the camel exchange in body as the rabbit mq message body. The camel exchange in object must be convertible to a byte array. Otherwise the producer will throw an exception of unsupported body type.

Samples

To receive messages from a queue that is bound to an exchange A with the routing key B,

from("rabbitmq://localhost/A?routingKey=B")

To receive messages from a queue with a single thread with auto acknowledge disabled.

from("rabbitmq://localhost/A?routingKey=B&threadPoolSize=1&autoAck=false")

To send messages to an exchange called C

...to("rabbitmq://localhost/B")