public interface RabbitMQClient
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
|
void |
restartConnect(int attempts,
Handler<AsyncResult<Void>> resultHandler)
restart the rabbitMQ connect.
|
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.
|
static RabbitMQClient create(Vertx vertx)
vertx
- the vertx instancestatic RabbitMQClient create(Vertx vertx, RabbitMQOptions config)
vertx
- the vertx instanceconfig
- the client configvoid addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)
connectionEstablishedCallback
- callback to be called whenever a new connection is established.static RabbitMQClient create(Vertx vertx, JsonObject config)
create(Vertx, RabbitMQOptions)
but with a JsonObject
config object.void basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<Void>> resultHandler)
Channel.basicAck(long, boolean)
Future<Void> basicAck(long deliveryTag, boolean multiple)
basicAck(long, boolean, Handler)
but returns a Future
of the asynchronous resultvoid basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<Void>> resultHandler)
Channel.basicNack(long, boolean, boolean)
Future<Void> basicNack(long deliveryTag, boolean multiple, boolean requeue)
basicNack(long, boolean, boolean, Handler)
but returns a Future
of the asynchronous resultvoid basicGet(String queue, boolean autoAck, Handler<AsyncResult<RabbitMQMessage>> resultHandler)
Channel.basicGet(String, boolean)
Future<RabbitMQMessage> basicGet(String queue, boolean autoAck)
basicGet(String, boolean, Handler)
but returns a Future
of the asynchronous resultdefault void basicConsumer(String queue, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
Channel.basicConsume(String, Consumer)
,
basicConsumer(String, Handler)
default Future<RabbitMQConsumer> basicConsumer(String queue)
basicConsumer(String, Handler)
but returns a Future
of the asynchronous resultvoid basicConsumer(String queue, QueueOptions options, Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
options
.queue
- the name of a queueoptions
- options for queueresultHandler
- 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
Channel.basicConsume(String, boolean, String, Consumer)
Future<RabbitMQConsumer> basicConsumer(String queue, QueueOptions options)
basicConsumer(String, QueueOptions, Handler)
but returns a Future
of the asynchronous resultvoid basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)
Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
Future<Void> basicPublish(String exchange, String routingKey, Buffer body)
basicPublish(String, String, Buffer, Handler)
but returns a Future
of the asynchronous resultvoid basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)
Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
Future<Void> basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)
basicPublish(String, String, BasicProperties, Buffer, Handler)
but returns a Future
of the asynchronous resultvoid basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)
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.Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
Future<Void> basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)
deliveryTagHandler
- callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client.Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
void addConfirmListener(int maxQueueSize, Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)
maxQueueSize
- maximum size of the queue of confirmationsresultHandler
- 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
Channel.addConfirmListener(ConfirmListener)
Future<ReadStream<RabbitMQConfirmation>> addConfirmListener(int maxQueueSize)
#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.maxQueueSize
- maximum size of the queue of confirmationsRabbitMQConfirmListener
Channel.addConfirmListener(ConfirmListener)
void confirmSelect(Handler<AsyncResult<Void>> resultHandler)
Channel.confirmSelect()
Future<Void> confirmSelect()
confirmSelect(Handler)
but returns a Future
of the asynchronous resultvoid waitForConfirms(Handler<AsyncResult<Void>> resultHandler)
IOException
- Throws an IOException if the message was not written to the queue.Channel.waitForConfirms()
Future<Void> waitForConfirms()
waitForConfirms(Handler)
but returns a Future
of the asynchronous resultvoid waitForConfirms(long timeout, Handler<AsyncResult<Void>> resultHandler)
timeout
- IOException
- Throws an IOException if the message was not written to the queue.RabbitMQClientImpl.waitForConfirms(Handler)
Future<Void> waitForConfirms(long timeout)
waitForConfirms(long, Handler)
but returns a Future
of the asynchronous resultdefault void basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)
prefetchCount
- maximum number of messages that the server
will deliver, 0 if unlimitedresultHandler
- handler called when operation is done with a result of the operationbasicQos(int, int, boolean, Handler)
default Future<Void> basicQos(int prefetchCount)
basicQos(int, Handler)
but returns a Future
of the asynchronous resultdefault void basicQos(int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)
prefetchCount
- maximum number of messages that the server
will deliver, 0 if unlimitedglobal
- true if the settings should be applied to the
entire channel rather than each consumerresultHandler
- handler called when operation is done with a result of the operationbasicQos(int, int, boolean, Handler)
default Future<Void> basicQos(int prefetchCount, boolean global)
basicQos(int, boolean, Handler)
but returns a Future
of the asynchronous resultvoid basicQos(int prefetchSize, int prefetchCount, boolean global, Handler<AsyncResult<Void>> resultHandler)
prefetchSize
- maximum amount of content (measured in
octets) that the server will deliver, 0 if unlimitedprefetchCount
- maximum number of messages that the server
will deliver, 0 if unlimitedglobal
- true if the settings should be applied to the
entire channel rather than each consumerresultHandler
- handler called when operation is done with a result of the operationAMQP.Basic.Qos
Future<Void> basicQos(int prefetchSize, int prefetchCount, boolean global)
basicQos(int, int, boolean, Handler)
but returns a Future
of the asynchronous resultvoid exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)
Channel.exchangeDeclare(String, String, boolean, boolean, Map)
Future<Void> exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)
exchangeDeclare(String, String, boolean, boolean, Handler)
but returns a Future
of the asynchronous resultvoid exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config, Handler<AsyncResult<Void>> resultHandler)
Channel.exchangeDeclare(String, String, boolean, boolean, Map)
Future<Void> exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)
exchangeDeclare(String, String, boolean, boolean, JsonObject, Handler)
but returns a Future
of the asynchronous resultvoid exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)
Channel.exchangeDelete(String)
Future<Void> exchangeDelete(String exchange)
exchangeDelete(String, Handler)
but returns a Future
of the asynchronous resultvoid exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)
Channel.exchangeBind(String, String, String)
Future<Void> exchangeBind(String destination, String source, String routingKey)
exchangeBind(String, String, String, Handler)
but returns a Future
of the asynchronous resultvoid exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)
com.rabbitmq.client.Channel#exchangeBind(String, String, String, Map)
Future<Void> exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)
exchangeBind(String, String, String, Map, Handler)
but returns a Future
of the asynchronous resultvoid exchangeUnbind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)
Channel.exchangeUnbind(String, String, String)
Future<Void> exchangeUnbind(String destination, String source, String routingKey)
exchangeUnbind(String, String, String, Handler)
but returns a Future
of the asynchronous resultvoid exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)
com.rabbitmq.client.Channel#exchangeUnbind(String, String, String, Map)
Future<Void> exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)
exchangeUnbind(String, String, String, Map, Handler)
but returns a Future
of the asynchronous resultvoid queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Channel.queueDeclare()
Future<JsonObject> queueDeclareAuto()
queueDeclareAuto(Handler)
but returns a Future
of the asynchronous resultvoid queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)
queueDeclare(String, boolean, boolean, boolean, Handler)
but returns a Future
of the asynchronous resultvoid queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)
queueDeclare(String, boolean, boolean, boolean, JsonObject, Handler)
but returns a Future
of the asynchronous resultvoid queueDelete(String queue, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Channel.queueDelete(String)
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDelete(String queue)
queueDelete(String, Handler)
but returns a Future
of the asynchronous resultvoid queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Channel.queueDelete(String, boolean, boolean)
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)
queueDeleteIf(String, boolean, boolean, Handler)
but returns a Future
of the asynchronous resultvoid queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)
Channel.queueBind(String, String, String)
Future<Void> queueBind(String queue, String exchange, String routingKey)
queueBind(String, String, String, Handler)
but returns a Future
of the asynchronous resultvoid queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)
com.rabbitmq.client.Channel#queueBind(String, String, String, Map)
Future<Void> queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)
queueBind(String, String, String, Map, Handler)
but returns a Future
of the asynchronous resultvoid queueUnbind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)
Channel.queueUnbind(String, String, String)
Future<Void> queueUnbind(String queue, String exchange, String routingKey)
queueUnbind(String, String, String, Handler)
but returns a Future
of the asynchronous resultvoid queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments, Handler<AsyncResult<Void>> resultHandler)
com.rabbitmq.client.Channel#queueUnbind(String, String, String, Map)
Future<Void> queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)
queueUnbind(String, String, String, Map, Handler)
but returns a Future
of the asynchronous resultvoid messageCount(String queue, Handler<AsyncResult<Long>> resultHandler)
Channel.messageCount(String)
Future<Long> messageCount(String queue)
messageCount(String, Handler)
but returns a Future
of the asynchronous resultvoid start(Handler<AsyncResult<Void>> resultHandler)
Connection.createChannel()
Future<Void> start()
start(Handler)
but returns a Future
of the asynchronous resultvoid stop(Handler<AsyncResult<Void>> resultHandler)
Connection.close()
Future<Void> stop()
stop(Handler)
but returns a Future
of the asynchronous resultboolean isConnected()
ShutdownNotifier.isOpen()
void restartConnect(int attempts, Handler<AsyncResult<Void>> resultHandler)
attempts
- number of attemptsresultHandler
- handler called when operation is done with a result of the operationboolean isOpenChannel()
ShutdownNotifier.isOpen()
Copyright © 2023 Eclipse. All rights reserved.