io.vertx.rabbitmq

Interface RabbitMQClient

public interface RabbitMQClient

Author:

Nick Scavelli

Method Summary

Modifier and Type	Method and Description
Future<ReadStream<RabbitMQConfirmation>>	addConfirmListener(int maxQueueSize) Add a Confirm Listener to the channel.
void	addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler) Add a Confirm Listener to the channel.
void	addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback) Set a callback to be called whenever a new connection is established.
Future<Void>	basicAck(long deliveryTag, boolean multiple) Like basicAck(long, boolean, Handler) but returns a Future of the asynchronous result
void	basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler) Acknowledge one or several received messages.
default Future<RabbitMQConsumer>	basicConsumer(String queue) Like basicConsumer(String, Handler) but returns a Future of the asynchronous result
default void	basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
Future<RabbitMQConsumer>	basicConsumer(String queue, QueueOptions options) Like basicConsumer(String, QueueOptions, Handler) but returns a Future of the asynchronous result
void	basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler) Create a consumer with the given options.
Future<RabbitMQMessage>	basicGet(String queue, boolean autoAck) Like basicGet(String, boolean, Handler) but returns a Future of the asynchronous result
void	basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler) Retrieve a message from a queue using AMQP.Basic.Get
Future<Void>	basicNack(long deliveryTag, boolean multiple, boolean requeue) Like basicNack(long, boolean, boolean, Handler) but returns a Future of the asynchronous result
void	basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler) Reject one or several received messages.
Future<Void>	basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body) Like basicPublish(String, String, BasicProperties, Buffer, Handler) but returns a Future of the asynchronous result
void	basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler) Publish a message.
Future<Void>	basicPublish(String exchange, String routingKey, Buffer body) Like basicPublish(String, String, Buffer, Handler) but returns a Future of the asynchronous result
void	basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler) Publish a message.
Future<Void>	basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler) Publish a message.
void	basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler) Publish a message.
default Future<Void>	basicQos(int prefetchCount) Like basicQos(int, Handler) but returns a Future of the asynchronous result
default Future<Void>	basicQos(int prefetchCount, boolean global) Like basicQos(int, boolean, Handler) but returns a Future of the asynchronous result
default void	basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler) Request a specific prefetchCount "quality of service" settings for this channel.
default void	basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler) Request a specific prefetchCount "quality of service" settings for this channel.
Future<Void>	basicQos(int prefetchSize, int prefetchCount, boolean global) Like basicQos(int, int, boolean, Handler) but returns a Future of the asynchronous result
void	basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler) Request specific "quality of service" settings.
Future<Void>	confirmSelect() Like confirmSelect(Handler) but returns a Future of the asynchronous result
void	confirmSelect(Handler<AsyncResult<Void>> resultHandler) Enables publisher acknowledgements on this channel.
static RabbitMQClient	create(Vertx vertx) Create and return a client configured with the default options.
static RabbitMQClient	create(Vertx vertx, JsonObject config) Like create(Vertx, RabbitMQOptions) but with a JsonObject config object.
static RabbitMQClient	create(Vertx vertx, RabbitMQOptions config) Create and return a client.
Future<Void>	exchangeBind(String destination, String source, String routingKey) Like exchangeBind(String, String, String, Handler) but returns a Future of the asynchronous result
void	exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler) Bind an exchange to an exchange.
Future<Void>	exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments) Like exchangeBind(String, String, String, Map, Handler) but returns a Future of the asynchronous result
void	exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler) Bind an exchange to an exchange.
Future<Void>	exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete) Like exchangeDeclare(String, String, boolean, boolean, Handler) but returns a Future of the asynchronous result
void	exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler) Declare an exchange.
Future<Void>	exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config) Like exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler) but returns a Future of the asynchronous result
void	exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler) Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Future<Void>	exchangeDelete(String exchange) Like exchangeDelete(String, Handler) but returns a Future of the asynchronous result
void	exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler) Delete an exchange, without regard for whether it is in use or not.
Future<Void>	exchangeUnbind(String destination, String source, String routingKey) Like exchangeUnbind(String, String, String, Handler) but returns a Future of the asynchronous result
void	exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler) Unbind an exchange from an exchange.
Future<Void>	exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments) Like exchangeUnbind(String, String, String, Map, Handler) but returns a Future of the asynchronous result
void	exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler) Unbind an exchange from an exchange.
boolean	isConnected() Check if a connection is open
boolean	isOpenChannel() Check if a channel is open
Future<Long>	messageCount(String queue) Like messageCount(String, Handler) but returns a Future of the asynchronous result
void	messageCount(String queue, Handler<AsyncResult<Long>> resultHandler) Returns the number of messages in a queue ready to be delivered.
Future<Void>	queueBind(String queue, String exchange, String routingKey) Like queueBind(String, String, String, Handler) but returns a Future of the asynchronous result
void	queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler) Bind a queue to an exchange
Future<Void>	queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments) Like queueBind(String, String, String, Map, Handler) but returns a Future of the asynchronous result
void	queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler) Bind a queue to an exchange
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete) Like queueDeclare(String, boolean, boolean, boolean, Handler) but returns a Future of the asynchronous result
void	queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler) Declare a queue
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config) Like queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler) but returns a Future of the asynchronous result
void	queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler) Declare a queue with config options
Future<JsonObject>	queueDeclareAuto() Like queueDeclareAuto(Handler) but returns a Future of the asynchronous result
void	queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler) Actively declare a server-named exclusive, autodelete, non-durable queue.
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	queueDelete(String queue) Like queueDelete(String, Handler) but returns a Future of the asynchronous result
void	queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler) Delete a queue, without regard for whether it is in use or has messages on it
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty) Like queueDeleteIf(String, boolean, boolean, Handler) but returns a Future of the asynchronous result
void	queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler) Delete a queue
Future<Void>	queueUnbind(String queue, String exchange, String routingKey) Like queueUnbind(String, String, String, Handler) but returns a Future of the asynchronous result
void	queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler) Unbind a queue from an exchange
Future<Void>	queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments) Like queueUnbind(String, String, String, Map, Handler) but returns a Future of the asynchronous result
void	queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler) Unbind a queue from an exchange
Future<Void>	start() Like start(Handler) but returns a Future of the asynchronous result
void	start(Handler<AsyncResult<Void>> resultHandler) Start the rabbitMQ client.
Future<Void>	stop() Like stop(Handler) but returns a Future of the asynchronous result
void	stop(Handler<AsyncResult<Void>> resultHandler) Stop the rabbitMQ client.
Future<Void>	waitForConfirms() Like waitForConfirms(Handler) but returns a Future of the asynchronous result
void	waitForConfirms(Handler<AsyncResult<Void>> resultHandler) Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
Future<Void>	waitForConfirms(long timeout) Like waitForConfirms(long, Handler) but returns a Future of the asynchronous result
void	waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler) Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

Method Detail

create

static RabbitMQClient create(Vertx vertx)

Create and return a client configured with the default options.

Parameters:

vertx - the vertx instance

Returns:

the client

create

static RabbitMQClient create(Vertx vertx,
                             RabbitMQOptions config)

Create and return a client.

Parameters:

vertx - the vertx instance

config - the client config

Returns:

the client

addConnectionEstablishedCallback

void addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)

Set a callback to be called whenever a new connection is established. This callback must be idempotent - it will be called each time a connection is established, which may be multiple times against the same instance. Callbacks will be added to a list and called in the order they were added, the only way to remove callbacks is to create a new client. These callbacks should be used to establish any Rabbit MQ server objects that are required - exchanges, queues, bindings, etc. Each callback will receive a Promise that it must complete in order to pass control to the next callback (or back to the RabbitMQClient). If the callback fails the promise the RabbitMQClient will be unable to make a connection (it will attempt to connect again according to its retry configuration). If the promise is not completed or failed by a callback the RabbitMQClient will not start (it will hang indefinitely). Other methods on the client may be used in the callback - it is specifically expected that RabbitMQ objects will be declared, but the publish and consume methods must not be used. The connection established callbacks are particularly important with the RabbitMQPublisher and RabbitMQConsumer when they are used with servers that may failover to another instance of the server that does not have the same exchanges/queues configured on it. In this situation these callbacks are the only opportunity to create exchanges, queues and bindings before the client will attempt to use them when it re-establishes connection. If your failover cluster is guaranteed to have the appropriate objects already configured then it is not necessary to use the callbacks.

Parameters:

connectionEstablishedCallback - callback to be called whenever a new connection is established.

create

static RabbitMQClient create(Vertx vertx,
                             JsonObject config)

Like create(Vertx, RabbitMQOptions) but with a JsonObject config object.

basicAck

void basicAck(long deliveryTag,
              boolean multiple,
              Handler<AsyncResult<Void>> resultHandler)

Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.

See Also:

Channel.basicAck(long, boolean)

basicAck

Future<Void> basicAck(long deliveryTag,
                      boolean multiple)

Like basicAck(long, boolean, Handler) but returns a Future of the asynchronous result

basicNack

void basicNack(long deliveryTag,
               boolean multiple,
               boolean requeue,
               Handler<AsyncResult<Void>> resultHandler)

Reject one or several received messages.

See Also:

Channel.basicNack(long, boolean, boolean)

basicNack

Future<Void> basicNack(long deliveryTag,
                       boolean multiple,
                       boolean requeue)

Like basicNack(long, boolean, boolean, Handler) but returns a Future of the asynchronous result

basicGet

void basicGet(String queue,
              boolean autoAck,
              Handler<AsyncResult<RabbitMQMessage>> resultHandler)

Retrieve a message from a queue using AMQP.Basic.Get

See Also:

Channel.basicGet(String, boolean)

basicGet

Future<RabbitMQMessage> basicGet(String queue,
                                 boolean autoAck)

Like basicGet(String, boolean, Handler) but returns a Future of the asynchronous result

basicConsumer

default void basicConsumer(String queue,
                           Handler<AsyncResult<RabbitMQConsumer>> resultHandler)

See Also:

Channel.basicConsume(String, Consumer), basicConsumer(String, Handler)

basicConsumer

default Future<RabbitMQConsumer> basicConsumer(String queue)

Like basicConsumer(String, Handler) but returns a Future of the asynchronous result

basicConsumer

void basicConsumer(String queue,
                   QueueOptions options,
                   Handler<AsyncResult<RabbitMQConsumer>> resultHandler)

Create a consumer with the given options.

Parameters:

queue - the name of a queue

options - options for queue

resultHandler - a handler through which you can find out the operation status; if the operation succeeds you can begin to receive messages through an instance of RabbitMQConsumer

See Also:

Channel.basicConsume(String, boolean, String, Consumer)

basicConsumer

Future<RabbitMQConsumer> basicConsumer(String queue,
                                       QueueOptions options)

Like basicConsumer(String, QueueOptions, Handler) but returns a Future of the asynchronous result

basicPublish

void basicPublish(String exchange,
                  String routingKey,
                  Buffer body,
                  Handler<AsyncResult<Void>> resultHandler)

Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

See Also:

Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])

basicPublish

Future<Void> basicPublish(String exchange,
                          String routingKey,
                          Buffer body)

Like basicPublish(String, String, Buffer, Handler) but returns a Future of the asynchronous result

basicPublish

void basicPublish(String exchange,
                  String routingKey,
                  com.rabbitmq.client.BasicProperties properties,
                  Buffer body,
                  Handler<AsyncResult<Void>> resultHandler)

Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

See Also:

Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])

basicPublish

Future<Void> basicPublish(String exchange,
                          String routingKey,
                          com.rabbitmq.client.BasicProperties properties,
                          Buffer body)

Like basicPublish(String, String, BasicProperties, Buffer, Handler) but returns a Future of the asynchronous result

basicPublishWithDeliveryTag

void basicPublishWithDeliveryTag(String exchange,
                                 String routingKey,
                                 com.rabbitmq.client.BasicProperties properties,
                                 Buffer body,
                                 Handler<Long> deliveryTagHandler,
                                 Handler<AsyncResult<Void>> resultHandler)

Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect. The deliveryTagHandler will be called before the message is sent, which is necessary because the confirmation may arrive asynchronously before the resultHandler is called.

Parameters:

deliveryTagHandler - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client before the result is known.

See Also:

Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])

basicPublishWithDeliveryTag

Future<Void> basicPublishWithDeliveryTag(String exchange,
                                         String routingKey,
                                         com.rabbitmq.client.BasicProperties properties,
                                         Buffer body,
                                         Handler<Long> deliveryTagHandler)

Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

Parameters:

deliveryTagHandler - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client.

See Also:

Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])

addConfirmListener

void addConfirmListener(int maxQueueSize,
                        Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)

Add a Confirm Listener to the channel. Note that this will automatically call confirmSelect, it is not necessary to call that too.

Parameters:

maxQueueSize - maximum size of the queue of confirmations

resultHandler - a handler through which you can find out the operation status; if the operation succeeds you can begin to receive confirmations through an instance of RabbitMQConfirmListener

See Also:

Channel.addConfirmListener(ConfirmListener)

addConfirmListener

Future<ReadStream<RabbitMQConfirmation>> addConfirmListener(int maxQueueSize)

Add a Confirm Listener to the channel. Like #addConfirmListener(Handler) but returns a Future of the asynchronous result Note that this will automatically call confirmSelect, it is not necessary to call that too.

Parameters:

maxQueueSize - maximum size of the queue of confirmations

Returns:

a future through which you can find out the operation status; if the operation succeeds you can begin to receive confirmations through an instance of RabbitMQConfirmListener

See Also:

Channel.addConfirmListener(ConfirmListener)

confirmSelect

void confirmSelect(Handler<AsyncResult<Void>> resultHandler)

Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

See Also:

Channel.confirmSelect()

confirmSelect

Future<Void> confirmSelect()

Like confirmSelect(Handler) but returns a Future of the asynchronous result

waitForConfirms

void waitForConfirms(Handler<AsyncResult<Void>> resultHandler)

Wait until all messages published since the last call have been either ack'd or nack'd by the broker. This will incur slight performance loss at the expense of higher write consistency. If desired, multiple calls to basicPublish() can be batched before confirming.

Throws:

IOException - Throws an IOException if the message was not written to the queue.

See Also:

Channel.waitForConfirms()

waitForConfirms

Future<Void> waitForConfirms()

Like waitForConfirms(Handler) but returns a Future of the asynchronous result

waitForConfirms

void waitForConfirms(long timeout,
                     Handler<AsyncResult<Void>> resultHandler)

Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.

Parameters:

timeout -

Throws:

IOException - Throws an IOException if the message was not written to the queue.

See Also:

RabbitMQClientImpl.waitForConfirms(Handler)

waitForConfirms

Future<Void> waitForConfirms(long timeout)

Like waitForConfirms(long, Handler) but returns a Future of the asynchronous result

basicQos

default void basicQos(int prefetchCount,
                      Handler<AsyncResult<Void>> resultHandler)

Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

resultHandler - handler called when operation is done with a result of the operation

See Also:

basicQos(int, int, boolean, Handler)

basicQos

default Future<Void> basicQos(int prefetchCount)

Like basicQos(int, Handler) but returns a Future of the asynchronous result

basicQos

default void basicQos(int prefetchCount,
                      boolean global,
                      Handler<AsyncResult<Void>> resultHandler)

Request a specific prefetchCount "quality of service" settings for this channel.

Parameters:

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

resultHandler - handler called when operation is done with a result of the operation

See Also:

basicQos(int, int, boolean, Handler)

basicQos

default Future<Void> basicQos(int prefetchCount,
                              boolean global)

Like basicQos(int, boolean, Handler) but returns a Future of the asynchronous result

basicQos

void basicQos(int prefetchSize,
              int prefetchCount,
              boolean global,
              Handler<AsyncResult<Void>> resultHandler)

Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

Parameters:

prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited

prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited

global - true if the settings should be applied to the entire channel rather than each consumer

resultHandler - handler called when operation is done with a result of the operation

See Also:

AMQP.Basic.Qos

basicQos

Future<Void> basicQos(int prefetchSize,
                      int prefetchCount,
                      boolean global)

Like basicQos(int, int, boolean, Handler) but returns a Future of the asynchronous result

exchangeDeclare

void exchangeDeclare(String exchange,
                     String type,
                     boolean durable,
                     boolean autoDelete,
                     Handler<AsyncResult<Void>> resultHandler)

Declare an exchange.

See Also:

Channel.exchangeDeclare(String, String, boolean, boolean, Map)

exchangeDeclare

Future<Void> exchangeDeclare(String exchange,
                             String type,
                             boolean durable,
                             boolean autoDelete)

Like exchangeDeclare(String, String, boolean, boolean, Handler) but returns a Future of the asynchronous result

exchangeDeclare

void exchangeDeclare(String exchange,
                     String type,
                     boolean durable,
                     boolean autoDelete,
                     JsonObject config,
                     Handler<AsyncResult<Void>> resultHandler)

Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

See Also:

Channel.exchangeDeclare(String, String, boolean, boolean, Map)

exchangeDeclare

Future<Void> exchangeDeclare(String exchange,
                             String type,
                             boolean durable,
                             boolean autoDelete,
                             JsonObject config)

Like exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler) but returns a Future of the asynchronous result

exchangeDelete

void exchangeDelete(String exchange,
                    Handler<AsyncResult<Void>> resultHandler)

Delete an exchange, without regard for whether it is in use or not.

See Also:

Channel.exchangeDelete(String)

exchangeDelete

Future<Void> exchangeDelete(String exchange)

Like exchangeDelete(String, Handler) but returns a Future of the asynchronous result

exchangeBind

void exchangeBind(String destination,
                  String source,
                  String routingKey,
                  Handler<AsyncResult<Void>> resultHandler)

Bind an exchange to an exchange.

See Also:

Channel.exchangeBind(String, String, String)

exchangeBind

Future<Void> exchangeBind(String destination,
                          String source,
                          String routingKey)

Like exchangeBind(String, String, String, Handler) but returns a Future of the asynchronous result

exchangeBind

void exchangeBind(String destination,
                  String source,
                  String routingKey,
                  Map<String,Object> arguments,
                  Handler<AsyncResult<Void>> resultHandler)

Bind an exchange to an exchange.

See Also:

com.rabbitmq.client.Channel#exchangeBind(String, String, String, Map)

exchangeBind

Future<Void> exchangeBind(String destination,
                          String source,
                          String routingKey,
                          Map<String,Object> arguments)

Like exchangeBind(String, String, String, Map, Handler) but returns a Future of the asynchronous result

exchangeUnbind

void exchangeUnbind(String destination,
                    String source,
                    String routingKey,
                    Handler<AsyncResult<Void>> resultHandler)

Unbind an exchange from an exchange.

See Also:

Channel.exchangeUnbind(String, String, String)

exchangeUnbind

Future<Void> exchangeUnbind(String destination,
                            String source,
                            String routingKey)

Like exchangeUnbind(String, String, String, Handler) but returns a Future of the asynchronous result

exchangeUnbind

void exchangeUnbind(String destination,
                    String source,
                    String routingKey,
                    Map<String,Object> arguments,
                    Handler<AsyncResult<Void>> resultHandler)

Unbind an exchange from an exchange.

See Also:

com.rabbitmq.client.Channel#exchangeUnbind(String, String, String, Map)

exchangeUnbind

Future<Void> exchangeUnbind(String destination,
                            String source,
                            String routingKey,
                            Map<String,Object> arguments)

Like exchangeUnbind(String, String, String, Map, Handler) but returns a Future of the asynchronous result

queueDeclareAuto

void queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)

Actively declare a server-named exclusive, autodelete, non-durable queue.

See Also:

Channel.queueDeclare()

queueDeclareAuto

Future<JsonObject> queueDeclareAuto()

Like queueDeclareAuto(Handler) but returns a Future of the asynchronous result

queueDeclare

void queueDeclare(String queue,
                  boolean durable,
                  boolean exclusive,
                  boolean autoDelete,
                  Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)

Declare a queue

See Also:

Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)

queueDeclare

Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue,
                                                              boolean durable,
                                                              boolean exclusive,
                                                              boolean autoDelete)

Like queueDeclare(String, boolean, boolean, boolean, Handler) but returns a Future of the asynchronous result

queueDeclare

void queueDeclare(String queue,
                  boolean durable,
                  boolean exclusive,
                  boolean autoDelete,
                  JsonObject config,
                  Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)

Declare a queue with config options

See Also:

Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)

queueDeclare

Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue,
                                                              boolean durable,
                                                              boolean exclusive,
                                                              boolean autoDelete,
                                                              JsonObject config)

Like queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler) but returns a Future of the asynchronous result

queueDelete

void queueDelete(String queue,
                 Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)

Delete a queue, without regard for whether it is in use or has messages on it

See Also:

Channel.queueDelete(String)

queueDelete

Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDelete(String queue)

Like queueDelete(String, Handler) but returns a Future of the asynchronous result

queueDeleteIf

void queueDeleteIf(String queue,
                   boolean ifUnused,
                   boolean ifEmpty,
                   Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)

Delete a queue

See Also:

Channel.queueDelete(String, boolean, boolean)

queueDeleteIf

Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDeleteIf(String queue,
                                                              boolean ifUnused,
                                                              boolean ifEmpty)

Like queueDeleteIf(String, boolean, boolean, Handler) but returns a Future of the asynchronous result

queueBind

void queueBind(String queue,
               String exchange,
               String routingKey,
               Handler<AsyncResult<Void>> resultHandler)

Bind a queue to an exchange

See Also:

Channel.queueBind(String, String, String)

queueBind

Future<Void> queueBind(String queue,
                       String exchange,
                       String routingKey)

Like queueBind(String, String, String, Handler) but returns a Future of the asynchronous result

queueBind

void queueBind(String queue,
               String exchange,
               String routingKey,
               Map<String,Object> arguments,
               Handler<AsyncResult<Void>> resultHandler)

Bind a queue to an exchange

See Also:

com.rabbitmq.client.Channel#queueBind(String, String, String, Map)

queueBind

Future<Void> queueBind(String queue,
                       String exchange,
                       String routingKey,
                       Map<String,Object> arguments)

Like queueBind(String, String, String, Map, Handler) but returns a Future of the asynchronous result

queueUnbind

void queueUnbind(String queue,
                 String exchange,
                 String routingKey,
                 Handler<AsyncResult<Void>> resultHandler)

Unbind a queue from an exchange

See Also:

Channel.queueUnbind(String, String, String)

queueUnbind

Future<Void> queueUnbind(String queue,
                         String exchange,
                         String routingKey)

Like queueUnbind(String, String, String, Handler) but returns a Future of the asynchronous result

queueUnbind

void queueUnbind(String queue,
                 String exchange,
                 String routingKey,
                 Map<String,Object> arguments,
                 Handler<AsyncResult<Void>> resultHandler)

Unbind a queue from an exchange

See Also:

com.rabbitmq.client.Channel#queueUnbind(String, String, String, Map)

queueUnbind

Future<Void> queueUnbind(String queue,
                         String exchange,
                         String routingKey,
                         Map<String,Object> arguments)

Like queueUnbind(String, String, String, Map, Handler) but returns a Future of the asynchronous result

messageCount

void messageCount(String queue,
                  Handler<AsyncResult<Long>> resultHandler)

Returns the number of messages in a queue ready to be delivered.

See Also:

Channel.messageCount(String)

messageCount

Future<Long> messageCount(String queue)

Like messageCount(String, Handler) but returns a Future of the asynchronous result

start

void start(Handler<AsyncResult<Void>> resultHandler)

Start the rabbitMQ client. Create the connection and the channel.

See Also:

Connection.createChannel()

start

Future<Void> start()

Like start(Handler) but returns a Future of the asynchronous result

stop

void stop(Handler<AsyncResult<Void>> resultHandler)

Stop the rabbitMQ client. Close the connection and its channel.

See Also:

Connection.close()

stop

Future<Void> stop()

Like stop(Handler) but returns a Future of the asynchronous result

isConnected

boolean isConnected()

Check if a connection is open

Returns:

true when the connection is open, false otherwise

See Also:

ShutdownNotifier.isOpen()

isOpenChannel

boolean isOpenChannel()

Check if a channel is open

Returns:

true when the connection is open, false otherwise

See Also:

ShutdownNotifier.isOpen()