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, 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).
    `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` | `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` | `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.

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

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

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

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

    - #### 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 © 2016. All rights reserved.