io.vertx.rabbitmq

## Interface RabbitMQClient

-     public interface RabbitMQClient

  Author:
    Nick Scavelli

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `basicAck(long deliveryTag, boolean multiple, Handler<AsyncResult<JsonObject>> resultHandler)` Acknowledge one or several received messages.
    `void` | `basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<Void>> resultHandler)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
    `void` | `basicConsume(String queue, String address, boolean autoAck, Handler<AsyncResult<Void>> resultHandler, Handler<Throwable> errorHandler)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
    `void` | `basicConsume(String queue, String address, Handler<AsyncResult<Void>> resultHandler)` Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
    `void` | `basicGet(String queue, boolean autoAck, Handler<AsyncResult<JsonObject>> resultHandler)` Retrieve a message from a queue using AMQP.Basic.Get
    `void` | `basicNack(long deliveryTag, boolean multiple, boolean requeue, Handler<AsyncResult<JsonObject>> resultHandler)` Reject one or several received messages.
    `void` | `basicPublish(String exchange, String routingKey, JsonObject message, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | `basicQos(int prefetchCount, Handler<AsyncResult<Void>> resultHandler)` Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).
    `void` | `confirmSelect(Handler<AsyncResult<Void>> resultHandler)` Enables publisher acknowledgements on this channel.
    `static RabbitMQClient` | `create(Vertx vertx, JsonObject config)`
    `void` | `exchangeBind(String destination, String source, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind an exchange to an exchange.
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange.
    `void` | `exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String,String> config, Handler<AsyncResult<Void>> resultHandler)` Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.
    `void` | `exchangeDelete(String exchange, Handler<AsyncResult<Void>> resultHandler)` Delete an exchange, without regard for whether it is in use or not.
    `void` | `exchangeUnbind(String destination, String source, String routingKey, 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
    `void` | `messageCount(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Returns the number of messages in a queue ready to be delivered.
    `void` | `queueBind(String queue, String exchange, String routingKey, Handler<AsyncResult<Void>> resultHandler)` Bind a queue to an exchange
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue
    `void` | `queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,String> config, Handler<AsyncResult<JsonObject>> resultHandler)` Declare a queue with config options
    `void` | `queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)` Actively declare a server-named exclusive, autodelete, non-durable queue.
    `void` | `queueDelete(String queue, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue, without regard for whether it is in use or has messages on it
    `void` | `queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty, Handler<AsyncResult<JsonObject>> resultHandler)` Delete a queue
    `void` | `start(Handler<AsyncResult<Void>> resultHandler)` Start the rabbitMQ client.
    `void` | `stop(Handler<AsyncResult<Void>> resultHandler)` Stop the rabbitMQ client.
    `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.
    `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,
                                       JsonObject config)

    - #### basicAck

          void basicAck(long deliveryTag,
                        boolean multiple,
                        Handler<AsyncResult<JsonObject>> 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)`

    - #### basicNack

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

      Reject one or several received messages.
      See Also:
        `Channel.basicNack(long, boolean, boolean)`

    - #### basicGet

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

      Retrieve a message from a queue using AMQP.Basic.Get
      See Also:
        `Channel.basicGet(String, boolean)`

    - #### basicConsume

          void basicConsume(String queue,
                            String address,
                            Handler<AsyncResult<Void>> resultHandler)

      Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
      See Also:
        `Channel.basicConsume(String, Consumer)`

    - #### basicConsume

          void basicConsume(String queue,
                            String address,
                            boolean autoAck,
                            Handler<AsyncResult<Void>> resultHandler)

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
      See Also:
        `Channel.basicConsume(String, boolean, String, Consumer)`

    - #### basicConsume

          void basicConsume(String queue,
                            String address,
                            boolean autoAck,
                            Handler<AsyncResult<Void>> resultHandler,
                            Handler<Throwable> errorHandler)

      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler
      See Also:
        `Channel.basicConsume(String, boolean, String, Consumer)`

    - #### basicPublish

          void basicPublish(String exchange,
                            String routingKey,
                            JsonObject message,
                            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[])`

    - #### 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()`, `http://www.rabbitmq.com/confirms.html`

    - #### 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()`, `http://www.rabbitmq.com/confirms.html`

    - #### 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)`, `http://www.rabbitmq.com/confirms.html`

    - #### basicQos

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

      Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.
      See Also:
        `Channel.basicQos(int)`

    - #### 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

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

      Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.
      See Also:
        `Channel.exchangeDeclare(String, String, boolean, boolean, Map)`

    - #### 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)`

    - #### 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)`

    - #### 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)`

    - #### queueDeclareAuto

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

      Actively declare a server-named exclusive, autodelete, non-durable queue.
      See Also:
        `Channel.queueDeclare()`

    - #### queueDeclare

          void queueDeclare(String queue,
                            boolean durable,
                            boolean exclusive,
                            boolean autoDelete,
                            Handler<AsyncResult<JsonObject>> resultHandler)

      Declare a queue
      See Also:
        `Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)`

    - #### queueDeclare

          void queueDeclare(String queue,
                            boolean durable,
                            boolean exclusive,
                            boolean autoDelete,
                            Map<String,String> config,
                            Handler<AsyncResult<JsonObject>> resultHandler)

      Declare a queue with config options
      See Also:
        `Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)`

    - #### queueDelete

          void queueDelete(String queue,
                           Handler<AsyncResult<JsonObject>> resultHandler)

      Delete a queue, without regard for whether it is in use or has messages on it
      See Also:
        `Channel.queueDelete(String)`

    - #### queueDeleteIf

          void queueDeleteIf(String queue,
                             boolean ifUnused,
                             boolean ifEmpty,
                             Handler<AsyncResult<JsonObject>> resultHandler)

      Delete a queue
      See Also:
        `Channel.queueDelete(String, boolean, boolean)`

    - #### 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)`

    - #### messageCount

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

      Returns the number of messages in a queue ready to be delivered.
      See Also:
        `Channel.messageCount(String)`

    - #### start

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

      Start the rabbitMQ client. Create the connection and the chanel.
      See Also:
        `Connection.createChannel()`

    - #### stop

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

      Stop the rabbitMQ client. Close the connection and its chanel.
      See Also:
        `Connection.close()`

    - #### 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()`

Copyright © 2017. All rights reserved.