Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.rabbitmq.client
Interface Channel

All Superinterfaces:
  ShutdownNotifier

All Known Implementing Classes:
  ChannelN

    public interface Channel

extends ShutdownNotifier

Public API: Interface to an AMQ channel. See the spec for details.

To open a channel,

     Connection conn = ...;
     Channel channel = conn.createChannel();

Public API:

- getChannelNumber
- close

`Channel` instances are safe for use by multiple threads. Requests into a `Channel` are serialized, with only one thread running commands at a time. As such, applications may prefer using a `Channel` per thread instead of sharing the same `Channel` across multiple threads. An important caveat to this is that confirms are not handled properly when a `Channel` is shared between multiple threads. In that scenario, it is therefore important to ensure that the `Channel` instance is not accessed concurrently by multiple threads.

Method Summary
`void` | `abort()` Abort this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'.
`void` | `abort(int closeCode, java.lang.String closeMessage)` Abort this channel.
`void` | `addConfirmListener(ConfirmListener listener)` Add a `ConfirmListener`.
`void` | `addFlowListener(FlowListener listener)` Add a `FlowListener`.
`void` | `addReturnListener(ReturnListener listener)` Add a `ReturnListener`.
`void` | `asyncRpc(Method method)` Asynchronously send a method over this channel.
`void` | `basicAck(long deliveryTag, boolean multiple)` Acknowledge one or several received messages.
`void` | `basicCancel(java.lang.String consumerTag)` Cancel a consumer.
`java.lang.String` | `basicConsume(java.lang.String queue, boolean autoAck, Consumer callback)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
`java.lang.String` | `basicConsume(java.lang.String queue, boolean autoAck, java.lang.String consumerTag, boolean noLocal, boolean exclusive, java.util.Map<java.lang.String,java.lang.Object> arguments, Consumer callback)` Start a consumer.
`java.lang.String` | `basicConsume(java.lang.String queue, boolean autoAck, java.lang.String consumerTag, Consumer callback)` Start a non-nolocal, non-exclusive consumer.
`java.lang.String` | `basicConsume(java.lang.String queue, Consumer callback)` Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
`GetResponse` | `basicGet(java.lang.String queue, boolean autoAck)` Retrieve a message from a queue using `AMQP.Basic.Get`
`void` | `basicNack(long deliveryTag, boolean multiple, boolean requeue)` Reject one or several received messages.
`void` | `basicPublish(java.lang.String exchange, java.lang.String routingKey, AMQP.BasicProperties props, byte[] body)` Publish a message
`void` | `basicPublish(java.lang.String exchange, java.lang.String routingKey, boolean mandatory, AMQP.BasicProperties props, byte[] body)` Publish a message
`void` | `basicPublish(java.lang.String exchange, java.lang.String routingKey, boolean mandatory, boolean immediate, AMQP.BasicProperties props, byte[] body)` Publish a message
`void` | `basicQos(int prefetchCount)` Request a specific prefetchCount "quality of service" settings for this channel.
`void` | `basicQos(int prefetchSize, int prefetchCount, boolean global)` Request specific "quality of service" settings.
`AMQP.Basic.RecoverOk` | `basicRecover()` Ask the broker to resend unacknowledged messages.
`AMQP.Basic.RecoverOk` | `basicRecover(boolean requeue)` Ask the broker to resend unacknowledged messages.
`void` | `basicRecoverAsync(boolean requeue)` Deprecated.
`void` | `basicReject(long deliveryTag, boolean requeue)` Reject a message.
`void` | `clearConfirmListeners()` Remove all `ConfirmListener`s.
`void` | `clearFlowListeners()` Remove all `FlowListener`s.
`void` | `clearReturnListeners()` Remove all `ReturnListener`s.
`void` | `close()` Close this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'.
`void` | `close(int closeCode, java.lang.String closeMessage)` Close this channel.
`AMQP.Confirm.SelectOk` | `confirmSelect()` Enables publisher acknowledgements on this channel.
`AMQP.Exchange.BindOk` | `exchangeBind(java.lang.String destination, java.lang.String source, java.lang.String routingKey)` Bind an exchange to an exchange, with no extra arguments.
`AMQP.Exchange.BindOk` | `exchangeBind(java.lang.String destination, java.lang.String source, java.lang.String routingKey, java.util.Map<java.lang.String,java.lang.Object> arguments)` Bind an exchange to an exchange.
`AMQP.Exchange.DeclareOk` | `exchangeDeclare(java.lang.String exchange, java.lang.String type)` Actively declare a non-autodelete, non-durable exchange with no extra arguments
`AMQP.Exchange.DeclareOk` | `exchangeDeclare(java.lang.String exchange, java.lang.String type, boolean durable)` Actively declare a non-autodelete exchange with no extra arguments
`AMQP.Exchange.DeclareOk` | `exchangeDeclare(java.lang.String exchange, java.lang.String type, boolean durable, boolean autoDelete, boolean internal, java.util.Map<java.lang.String,java.lang.Object> arguments)` Declare an exchange, via an interface that allows the complete set of arguments.
`AMQP.Exchange.DeclareOk` | `exchangeDeclare(java.lang.String exchange, java.lang.String type, boolean durable, boolean autoDelete, java.util.Map<java.lang.String,java.lang.Object> arguments)` Declare an exchange.
`AMQP.Exchange.DeclareOk` | `exchangeDeclarePassive(java.lang.String name)` Declare an exchange passively; that is, check if the named exchange exists.
`AMQP.Exchange.DeleteOk` | `exchangeDelete(java.lang.String exchange)` Delete an exchange, without regard for whether it is in use or not
`AMQP.Exchange.DeleteOk` | `exchangeDelete(java.lang.String exchange, boolean ifUnused)` Delete an exchange
`AMQP.Exchange.UnbindOk` | `exchangeUnbind(java.lang.String destination, java.lang.String source, java.lang.String routingKey)` Unbind an exchange from an exchange, with no extra arguments.
`AMQP.Exchange.UnbindOk` | `exchangeUnbind(java.lang.String destination, java.lang.String source, java.lang.String routingKey, java.util.Map<java.lang.String,java.lang.Object> arguments)` Unbind an exchange from an exchange.
`AMQP.Channel.FlowOk` | `flow(boolean active)` Set flow on the channel
`int` | `getChannelNumber()` Retrieve this channel's channel number.
`Connection` | `getConnection()` Retrieve the connection which carries this channel.
`Consumer` | `getDefaultConsumer()` Get the current default consumer.
`AMQP.Channel.FlowOk` | `getFlow()` Return the current Channel.Flow settings.
`long` | `getNextPublishSeqNo()` When in confirm mode, returns the sequence number of the next message to be published.
`AMQP.Queue.BindOk` | `queueBind(java.lang.String queue, java.lang.String exchange, java.lang.String routingKey)` Bind a queue to an exchange, with no extra arguments.
`AMQP.Queue.BindOk` | `queueBind(java.lang.String queue, java.lang.String exchange, java.lang.String routingKey, java.util.Map<java.lang.String,java.lang.Object> arguments)` Bind a queue to an exchange.
`AMQP.Queue.DeclareOk` | `queueDeclare()` Actively declare a server-named exclusive, autodelete, non-durable queue.
`AMQP.Queue.DeclareOk` | `queueDeclare(java.lang.String queue, boolean durable, boolean exclusive, boolean autoDelete, java.util.Map<java.lang.String,java.lang.Object> arguments)` Declare a queue
`AMQP.Queue.DeclareOk` | `queueDeclarePassive(java.lang.String queue)` Declare a queue passively; i.e., check if it exists.
`AMQP.Queue.DeleteOk` | `queueDelete(java.lang.String queue)` Delete a queue, without regard for whether it is in use or has messages on it
`AMQP.Queue.DeleteOk` | `queueDelete(java.lang.String queue, boolean ifUnused, boolean ifEmpty)` Delete a queue
`AMQP.Queue.PurgeOk` | `queuePurge(java.lang.String queue)` Purges the contents of the given queue.
`AMQP.Queue.UnbindOk` | `queueUnbind(java.lang.String queue, java.lang.String exchange, java.lang.String routingKey)` Unbinds a queue from an exchange, with no extra arguments.
`AMQP.Queue.UnbindOk` | `queueUnbind(java.lang.String queue, java.lang.String exchange, java.lang.String routingKey, java.util.Map<java.lang.String,java.lang.Object> arguments)` Unbind a queue from an exchange.
`boolean` | `removeConfirmListener(ConfirmListener listener)` Remove a `ConfirmListener`.
`boolean` | `removeFlowListener(FlowListener listener)` Remove a `FlowListener`.
`boolean` | `removeReturnListener(ReturnListener listener)` Remove a `ReturnListener`.
`Command` | `rpc(Method method)` Synchronously send a method over this channel.
`void` | `setDefaultConsumer(Consumer consumer)` Set the current default consumer.
`AMQP.Tx.CommitOk` | `txCommit()` Commits a TX transaction on this channel.
`AMQP.Tx.RollbackOk` | `txRollback()` Rolls back a TX transaction on this channel.
`AMQP.Tx.SelectOk` | `txSelect()` Enables TX mode on this channel.
`boolean` | `waitForConfirms()` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
`boolean` | `waitForConfirms(long timeout)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.
`void` | `waitForConfirmsOrDie()` Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
`void` | `waitForConfirmsOrDie(long timeout)` Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

Methods inherited from interface com.rabbitmq.client.ShutdownNotifier
`addShutdownListener, getCloseReason, isOpen, notifyListeners, removeShutdownListener`

Method Detail

### getChannelNumber

    int getChannelNumber()

  Retrieve this channel's channel number.

  Returns:
    the channel number

### getConnection

    Connection getConnection()

  Retrieve the connection which carries this channel.

  Returns:
    the underlying `Connection`

### close

    void close()
               throws java.io.IOException

  Close this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'.

  Throws:
    `java.io.IOException` - if an error is encountered

### close

    void close(int closeCode,
               java.lang.String closeMessage)
               throws java.io.IOException

  Close this channel.

  Parameters:
    `closeCode` - the close code (See under "Reply Codes" in the AMQP specification)
    `closeMessage` - a message indicating the reason for closing the connection
  Throws:
    `java.io.IOException` - if an error is encountered

### flow

    AMQP.Channel.FlowOk flow(boolean active)
                             throws java.io.IOException

  Set flow on the channel

  Parameters:
    `active` - if true, the server is asked to start sending. If false, the server is asked to stop sending.
  Throws:
    `java.io.IOException`

### getFlow

    AMQP.Channel.FlowOk getFlow()

  Return the current Channel.Flow settings.

### abort

    void abort()
               throws java.io.IOException

  Abort this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'. Forces the channel to close and waits for the close operation to complete. Any encountered exceptions in the close operation are silently discarded.

  Throws:
    `java.io.IOException`

### abort

    void abort(int closeCode,
               java.lang.String closeMessage)
               throws java.io.IOException

  Abort this channel. Forces the channel to close and waits for the close operation to complete. Any encountered exceptions in the close operation are silently discarded.

  Throws:
    `java.io.IOException`

### addReturnListener

    void addReturnListener(ReturnListener listener)

  Add a `ReturnListener`.

  Parameters:
    `listener` - the listener to add

### removeReturnListener

    boolean removeReturnListener(ReturnListener listener)

  Remove a `ReturnListener`.

  Parameters:
    `listener` - the listener to remove
  Returns:
    `true` if the listener was found and removed, `false` otherwise

### clearReturnListeners

    void clearReturnListeners()

  Remove all `ReturnListener`s.

### addFlowListener

    void addFlowListener(FlowListener listener)

  Add a `FlowListener`.

  Parameters:
    `listener` - the listener to add

### removeFlowListener

    boolean removeFlowListener(FlowListener listener)

  Remove a `FlowListener`.

  Parameters:
    `listener` - the listener to remove
  Returns:
    `true` if the listener was found and removed, `false` otherwise

### clearFlowListeners

    void clearFlowListeners()

  Remove all `FlowListener`s.

### addConfirmListener

    void addConfirmListener(ConfirmListener listener)

  Add a `ConfirmListener`.

  Parameters:
    `listener` - the listener to add

### removeConfirmListener

    boolean removeConfirmListener(ConfirmListener listener)

  Remove a `ConfirmListener`.

  Parameters:
    `listener` - the listener to remove
  Returns:
    `true` if the listener was found and removed, `false` otherwise

### clearConfirmListeners

    void clearConfirmListeners()

  Remove all `ConfirmListener`s.

### getDefaultConsumer

    Consumer getDefaultConsumer()

  Get the current default consumer. @see setDefaultConsumer for rationale.

  Returns:
    an interface to the current default consumer.

### setDefaultConsumer

    void setDefaultConsumer(Consumer consumer)

  Set the current default consumer. Under certain circumstances it is possible for a channel to receive a message delivery which does not match any consumer which is currently set up via basicConsume(). This will occur after the following sequence of events: ctag = basicConsume(queue, consumer); // i.e. with explicit acks // some deliveries take place but are not acked basicCancel(ctag); basicRecover(false); Since requeue is specified to be false in the basicRecover, the spec states that the message must be redelivered to "the original recipient" - i.e. the same channel / consumer-tag. But the consumer is no longer active. In these circumstances, you can register a default consumer to handle such deliveries. If no default consumer is registered an IllegalStateException will be thrown when such a delivery arrives. Most people will not need to use this.

  Parameters:
    `consumer` - the consumer to use, or null indicating "don't use one".

### basicQos

    void basicQos(int prefetchSize,
                  int prefetchCount,
                  boolean global)
                  throws java.io.IOException

  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 connection rather than just the current channel
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Qos`

### basicQos

    void basicQos(int prefetchCount)
                  throws java.io.IOException

  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
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `basicQos(int, int, boolean)`

### basicPublish

    void basicPublish(java.lang.String exchange,
                      java.lang.String routingKey,
                      AMQP.BasicProperties props,
                      byte[] body)
                      throws java.io.IOException

  Publish a message

  Parameters:
    `exchange` - the exchange to publish the message to
    `routingKey` - the routing key
    `props` - other properties for the message - routing headers etc
    `body` - the message body
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Publish`

### basicPublish

    void basicPublish(java.lang.String exchange,
                      java.lang.String routingKey,
                      boolean mandatory,
                      AMQP.BasicProperties props,
                      byte[] body)
                      throws java.io.IOException

  Publish a message

  Parameters:
    `exchange` - the exchange to publish the message to
    `routingKey` - the routing key
    `mandatory` - true if the 'mandatory' flag is to be set
    `props` - other properties for the message - routing headers etc
    `body` - the message body
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Publish`

### basicPublish

    void basicPublish(java.lang.String exchange,
                      java.lang.String routingKey,
                      boolean mandatory,
                      boolean immediate,
                      AMQP.BasicProperties props,
                      byte[] body)
                      throws java.io.IOException

  Publish a message

  Parameters:
    `exchange` - the exchange to publish the message to
    `routingKey` - the routing key
    `mandatory` - true if the 'mandatory' flag is to be set
    `immediate` - true if the 'immediate' flag is to be set. Note that the RabbitMQ server does not support this flag.
    `props` - other properties for the message - routing headers etc
    `body` - the message body
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Publish`

### exchangeDeclare

    AMQP.Exchange.DeclareOk exchangeDeclare(java.lang.String exchange,
                                            java.lang.String type)
                                            throws java.io.IOException

  Actively declare a non-autodelete, non-durable exchange with no extra arguments

  Parameters:
    `exchange` - the name of the exchange
    `type` - the exchange type
  Returns:
    a declaration-confirm method to indicate the exchange was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Declare`, `AMQP.Exchange.DeclareOk`

### exchangeDeclare

    AMQP.Exchange.DeclareOk exchangeDeclare(java.lang.String exchange,
                                            java.lang.String type,
                                            boolean durable)
                                            throws java.io.IOException

  Actively declare a non-autodelete exchange with no extra arguments

  Parameters:
    `exchange` - the name of the exchange
    `type` - the exchange type
    `durable` - true if we are declaring a durable exchange (the exchange will survive a server restart)
  Returns:
    a declaration-confirm method to indicate the exchange was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Declare`, `AMQP.Exchange.DeclareOk`

### exchangeDeclare

    AMQP.Exchange.DeclareOk exchangeDeclare(java.lang.String exchange,
                                            java.lang.String type,
                                            boolean durable,
                                            boolean autoDelete,
                                            java.util.Map<java.lang.String,java.lang.Object> arguments)
                                            throws java.io.IOException

  Declare an exchange.

  Parameters:
    `exchange` - the name of the exchange
    `type` - the exchange type
    `durable` - true if we are declaring a durable exchange (the exchange will survive a server restart)
    `autoDelete` - true if the server should delete the exchange when it is no longer in use
    `arguments` - other properties (construction arguments) for the exchange
  Returns:
    a declaration-confirm method to indicate the exchange was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Declare`, `AMQP.Exchange.DeclareOk`

### exchangeDeclare

    AMQP.Exchange.DeclareOk exchangeDeclare(java.lang.String exchange,
                                            java.lang.String type,
                                            boolean durable,
                                            boolean autoDelete,
                                            boolean internal,
                                            java.util.Map<java.lang.String,java.lang.Object> arguments)
                                            throws java.io.IOException

  Declare an exchange, via an interface that allows the complete set of arguments.

  Parameters:
    `exchange` - the name of the exchange
    `type` - the exchange type
    `durable` - true if we are declaring a durable exchange (the exchange will survive a server restart)
    `autoDelete` - true if the server should delete the exchange when it is no longer in use
    `internal` - true if the exchange is internal, i.e. can't be directly published to by a client.
    `arguments` - other properties (construction arguments) for the exchange
  Returns:
    a declaration-confirm method to indicate the exchange was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Declare`, `AMQP.Exchange.DeclareOk`

### exchangeDeclarePassive

    AMQP.Exchange.DeclareOk exchangeDeclarePassive(java.lang.String name)
                                                   throws java.io.IOException

  Declare an exchange passively; that is, check if the named exchange exists.

  Parameters:
    `name` - check the existence of an exchange named this
  Throws:
    `java.io.IOException` - the server will raise a 404 channel exception if the named exchange does not exist.

### exchangeDelete

    AMQP.Exchange.DeleteOk exchangeDelete(java.lang.String exchange,
                                          boolean ifUnused)
                                          throws java.io.IOException

  Delete an exchange

  Parameters:
    `exchange` - the name of the exchange
    `ifUnused` - true to indicate that the exchange is only to be deleted if it is unused
  Returns:
    a deletion-confirm method to indicate the exchange was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Delete`, `AMQP.Exchange.DeleteOk`

### exchangeDelete

    AMQP.Exchange.DeleteOk exchangeDelete(java.lang.String exchange)
                                          throws java.io.IOException

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

  Parameters:
    `exchange` - the name of the exchange
  Returns:
    a deletion-confirm method to indicate the exchange was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Delete`, `AMQP.Exchange.DeleteOk`

### exchangeBind

    AMQP.Exchange.BindOk exchangeBind(java.lang.String destination,
                                      java.lang.String source,
                                      java.lang.String routingKey)
                                      throws java.io.IOException

  Bind an exchange to an exchange, with no extra arguments.

  Parameters:
    `destination` - the name of the exchange to which messages flow across the binding
    `source` - the name of the exchange from which messages flow across the binding
    `routingKey` - the routine key to use for the binding
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Bind`, `AMQP.Exchange.BindOk`

### exchangeBind

    AMQP.Exchange.BindOk exchangeBind(java.lang.String destination,
                                      java.lang.String source,
                                      java.lang.String routingKey,
                                      java.util.Map<java.lang.String,java.lang.Object> arguments)
                                      throws java.io.IOException

  Bind an exchange to an exchange.

  Parameters:
    `destination` - the name of the exchange to which messages flow across the binding
    `source` - the name of the exchange from which messages flow across the binding
    `routingKey` - the routine key to use for the binding
    `arguments` - other properties (binding parameters)
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Bind`, `AMQP.Exchange.BindOk`

### exchangeUnbind

    AMQP.Exchange.UnbindOk exchangeUnbind(java.lang.String destination,
                                          java.lang.String source,
                                          java.lang.String routingKey)
                                          throws java.io.IOException

  Unbind an exchange from an exchange, with no extra arguments.

  Parameters:
    `destination` - the name of the exchange to which messages flow across the binding
    `source` - the name of the exchange from which messages flow across the binding
    `routingKey` - the routine key to use for the binding
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Bind`, `AMQP.Exchange.BindOk`

### exchangeUnbind

    AMQP.Exchange.UnbindOk exchangeUnbind(java.lang.String destination,
                                          java.lang.String source,
                                          java.lang.String routingKey,
                                          java.util.Map<java.lang.String,java.lang.Object> arguments)
                                          throws java.io.IOException

  Unbind an exchange from an exchange.

  Parameters:
    `destination` - the name of the exchange to which messages flow across the binding
    `source` - the name of the exchange from which messages flow across the binding
    `routingKey` - the routine key to use for the binding
    `arguments` - other properties (binding parameters)
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Exchange.Bind`, `AMQP.Exchange.BindOk`

### queueDeclare

    AMQP.Queue.DeclareOk queueDeclare()
                                      throws java.io.IOException

  Actively declare a server-named exclusive, autodelete, non-durable queue. The name of the new queue is held in the "queue" field of the `AMQP.Queue.DeclareOk` result.

  Returns:
    a declaration-confirm method to indicate the queue was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Declare`, `AMQP.Queue.DeclareOk`

### queueDeclare

    AMQP.Queue.DeclareOk queueDeclare(java.lang.String queue,
                                      boolean durable,
                                      boolean exclusive,
                                      boolean autoDelete,
                                      java.util.Map<java.lang.String,java.lang.Object> arguments)
                                      throws java.io.IOException

  Declare a queue

  Parameters:
    `queue` - the name of the queue
    `durable` - true if we are declaring a durable queue (the queue will survive a server restart)
    `exclusive` - true if we are declaring an exclusive queue (restricted to this connection)
    `autoDelete` - true if we are declaring an autodelete queue (server will delete it when no longer in use)
    `arguments` - other properties (construction arguments) for the queue
  Returns:
    a declaration-confirm method to indicate the queue was successfully declared
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Declare`, `AMQP.Queue.DeclareOk`

### queueDeclarePassive

    AMQP.Queue.DeclareOk queueDeclarePassive(java.lang.String queue)
                                             throws java.io.IOException

  Declare a queue passively; i.e., check if it exists. In AMQP 0-9-1, all arguments aside from nowait are ignored; and sending nowait makes this method a no-op, so we default it to false.

  Parameters:
    `queue` - the name of the queue
  Returns:
    a declaration-confirm method to indicate the queue exists
  Throws:
    `java.io.IOException` - if an error is encountered, including if the queue does not exist and if the queue is exclusively owned by another connection.
  See Also:
    `AMQP.Queue.Declare`, `AMQP.Queue.DeclareOk`

### queueDelete

    AMQP.Queue.DeleteOk queueDelete(java.lang.String queue)
                                    throws java.io.IOException

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

  Parameters:
    `queue` - the name of the queue
  Returns:
    a deletion-confirm method to indicate the queue was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Delete`, `AMQP.Queue.DeleteOk`

### queueDelete

    AMQP.Queue.DeleteOk queueDelete(java.lang.String queue,
                                    boolean ifUnused,
                                    boolean ifEmpty)
                                    throws java.io.IOException

  Delete a queue

  Parameters:
    `queue` - the name of the queue
    `ifUnused` - true if the queue should be deleted only if not in use
    `ifEmpty` - true if the queue should be deleted only if empty
  Returns:
    a deletion-confirm method to indicate the queue was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Delete`, `AMQP.Queue.DeleteOk`

### queueBind

    AMQP.Queue.BindOk queueBind(java.lang.String queue,
                                java.lang.String exchange,
                                java.lang.String routingKey)
                                throws java.io.IOException

  Bind a queue to an exchange, with no extra arguments.

  Parameters:
    `queue` - the name of the queue
    `exchange` - the name of the exchange
    `routingKey` - the routine key to use for the binding
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Bind`, `AMQP.Queue.BindOk`

### queueBind

    AMQP.Queue.BindOk queueBind(java.lang.String queue,
                                java.lang.String exchange,
                                java.lang.String routingKey,
                                java.util.Map<java.lang.String,java.lang.Object> arguments)
                                throws java.io.IOException

  Bind a queue to an exchange.

  Parameters:
    `queue` - the name of the queue
    `exchange` - the name of the exchange
    `routingKey` - the routine key to use for the binding
    `arguments` - other properties (binding parameters)
  Returns:
    a binding-confirm method if the binding was successfully created
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Bind`, `AMQP.Queue.BindOk`

### queueUnbind

    AMQP.Queue.UnbindOk queueUnbind(java.lang.String queue,
                                    java.lang.String exchange,
                                    java.lang.String routingKey)
                                    throws java.io.IOException

  Unbinds a queue from an exchange, with no extra arguments.

  Parameters:
    `queue` - the name of the queue
    `exchange` - the name of the exchange
    `routingKey` - the routine key to use for the binding
  Returns:
    an unbinding-confirm method if the binding was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Unbind`, `AMQP.Queue.UnbindOk`

### queueUnbind

    AMQP.Queue.UnbindOk queueUnbind(java.lang.String queue,
                                    java.lang.String exchange,
                                    java.lang.String routingKey,
                                    java.util.Map<java.lang.String,java.lang.Object> arguments)
                                    throws java.io.IOException

  Unbind a queue from an exchange.

  Parameters:
    `queue` - the name of the queue
    `exchange` - the name of the exchange
    `routingKey` - the routine key to use for the binding
    `arguments` - other properties (binding parameters)
  Returns:
    an unbinding-confirm method if the binding was successfully deleted
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Unbind`, `AMQP.Queue.UnbindOk`

### queuePurge

    AMQP.Queue.PurgeOk queuePurge(java.lang.String queue)
                                  throws java.io.IOException

  Purges the contents of the given queue.

  Parameters:
    `queue` - the name of the queue
  Returns:
    a purge-confirm method if the purge was executed succesfully
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Queue.Purge`, `AMQP.Queue.PurgeOk`

### basicGet

    GetResponse basicGet(java.lang.String queue,
                         boolean autoAck)
                         throws java.io.IOException

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

  Parameters:
    `queue` - the name of the queue
    `autoAck` - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
  Returns:
    a `GetResponse` containing the retrieved message data
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Get`, `AMQP.Basic.GetOk`, `AMQP.Basic.GetEmpty`

### basicAck

    void basicAck(long deliveryTag,
                  boolean multiple)
                  throws java.io.IOException

  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.

  Parameters:
    `deliveryTag` - the tag from the received `AMQP.Basic.GetOk` or `AMQP.Basic.Deliver`
    `multiple` - true to acknowledge all messages up to and including the supplied delivery tag; false to acknowledge just the supplied delivery tag.
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Ack`

### basicNack

    void basicNack(long deliveryTag,
                   boolean multiple,
                   boolean requeue)
                   throws java.io.IOException

  Reject one or several received messages. Supply the `deliveryTag` from the `AMQP.Basic.GetOk` or `AMQP.Basic.GetOk` method containing the message to be rejected.

  Parameters:
    `deliveryTag` - the tag from the received `AMQP.Basic.GetOk` or `AMQP.Basic.Deliver`
    `multiple` - true to reject all messages up to and including the supplied delivery tag; false to reject just the supplied delivery tag.
    `requeue` - true if the rejected message(s) should be requeued rather than discarded/dead-lettered
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Nack`

### basicReject

    void basicReject(long deliveryTag,
                     boolean requeue)
                     throws java.io.IOException

  Reject a message. Supply the deliveryTag from the `AMQP.Basic.GetOk` or `AMQP.Basic.Deliver` method containing the received message being rejected.

  Parameters:
    `deliveryTag` - the tag from the received `AMQP.Basic.GetOk` or `AMQP.Basic.Deliver`
    `requeue` - true if the rejected message should be requeued rather than discarded/dead-lettered
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Reject`

### basicConsume

    java.lang.String basicConsume(java.lang.String queue,
                                  Consumer callback)
                                  throws java.io.IOException

  Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.

  Parameters:
    `queue` - the name of the queue
    `callback` - an interface to the consumer object
  Returns:
    the consumerTag generated by the server
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Consume`, `AMQP.Basic.ConsumeOk`, `basicAck(long, boolean)`, `basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)`

### basicConsume

    java.lang.String basicConsume(java.lang.String queue,
                                  boolean autoAck,
                                  Consumer callback)
                                  throws java.io.IOException

  Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

  Parameters:
    `queue` - the name of the queue
    `autoAck` - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
    `callback` - an interface to the consumer object
  Returns:
    the consumerTag generated by the server
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Consume`, `AMQP.Basic.ConsumeOk`, `basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)`

### basicConsume

    java.lang.String basicConsume(java.lang.String queue,
                                  boolean autoAck,
                                  java.lang.String consumerTag,
                                  Consumer callback)
                                  throws java.io.IOException

  Start a non-nolocal, non-exclusive consumer.

  Parameters:
    `queue` - the name of the queue
    `autoAck` - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
    `consumerTag` - a client-generated consumer tag to establish context
    `callback` - an interface to the consumer object
  Returns:
    the consumerTag associated with the new consumer
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Consume`, `AMQP.Basic.ConsumeOk`, `basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)`

### basicConsume

    java.lang.String basicConsume(java.lang.String queue,
                                  boolean autoAck,
                                  java.lang.String consumerTag,
                                  boolean noLocal,
                                  boolean exclusive,
                                  java.util.Map<java.lang.String,java.lang.Object> arguments,
                                  Consumer callback)
                                  throws java.io.IOException

  Start a consumer. Calls the consumer's `Consumer.handleConsumeOk(java.lang.String)` method.

  Parameters:
    `queue` - the name of the queue
    `autoAck` - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
    `consumerTag` - a client-generated consumer tag to establish context
    `noLocal` - true if the server should not deliver to this consumer messages published on this channel's connection
    `exclusive` - true if this is an exclusive consumer
    `callback` - an interface to the consumer object
    `arguments` - a set of arguments for the consume
  Returns:
    the consumerTag associated with the new consumer
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Basic.Consume`, `AMQP.Basic.ConsumeOk`

### basicCancel

    void basicCancel(java.lang.String consumerTag)
                     throws java.io.IOException

  Cancel a consumer. Calls the consumer's `Consumer.handleCancelOk(java.lang.String)` method.

  Parameters:
    `consumerTag` - a client- or server-generated consumer tag to establish context
  Throws:
    `java.io.IOException` - if an error is encountered, or if the consumerTag is unknown
  See Also:
    `AMQP.Basic.Cancel`, `AMQP.Basic.CancelOk`

### basicRecover

    AMQP.Basic.RecoverOk basicRecover()
                                      throws java.io.IOException

  Ask the broker to resend unacknowledged messages. In 0-8 basic.recover is asynchronous; in 0-9-1 it is synchronous, and the new, deprecated method basic.recover_async is asynchronous.

  Equivalent to calling `basicRecover(true)`, messages will be requeued and possibly delivered to a different consumer.

  Throws:
    `java.io.IOException`
  See Also:
    `basicRecover(boolean)`

### basicRecover

    AMQP.Basic.RecoverOk basicRecover(boolean requeue)
                                      throws java.io.IOException

  Ask the broker to resend unacknowledged messages. In 0-8 basic.recover is asynchronous; in 0-9-1 it is synchronous, and the new, deprecated method basic.recover_async is asynchronous.

  Parameters:
    `requeue` - If true, messages will be requeued and possibly delivered to a different consumer. If false, messages will be redelivered to the same consumer.
  Throws:
    `java.io.IOException`

### basicRecoverAsync

    @Deprecated
    void basicRecoverAsync(boolean requeue)
                           throws java.io.IOException

  Deprecated.

  Ask the broker to resend unacknowledged messages. In 0-8 basic.recover is asynchronous; in 0-9-1 it is synchronous, and the new, deprecated method basic.recover_async is asynchronous and deprecated.

  Parameters:
    `requeue` - If true, messages will be requeued and possibly delivered to a different consumer. If false, messages will be redelivered to the same consumer.
  Throws:
    `java.io.IOException`

### txSelect

    AMQP.Tx.SelectOk txSelect()
                              throws java.io.IOException

  Enables TX mode on this channel.

  Returns:
    a transaction-selection method to indicate the transaction was successfully initiated
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Tx.Select`, `AMQP.Tx.SelectOk`

### txCommit

    AMQP.Tx.CommitOk txCommit()
                              throws java.io.IOException

  Commits a TX transaction on this channel.

  Returns:
    a transaction-commit method to indicate the transaction was successfully committed
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Tx.Commit`, `AMQP.Tx.CommitOk`

### txRollback

    AMQP.Tx.RollbackOk txRollback()
                                  throws java.io.IOException

  Rolls back a TX transaction on this channel.

  Returns:
    a transaction-rollback method to indicate the transaction was successfully rolled back
  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Tx.Rollback`, `AMQP.Tx.RollbackOk`

### confirmSelect

    AMQP.Confirm.SelectOk confirmSelect()
                                        throws java.io.IOException

  Enables publisher acknowledgements on this channel.

  Throws:
    `java.io.IOException` - if an error is encountered
  See Also:
    `AMQP.Confirm.Select`

### getNextPublishSeqNo

    long getNextPublishSeqNo()

  When in confirm mode, returns the sequence number of the next message to be published.

  Returns:
    the sequence number of the next message to be published

### waitForConfirms

    boolean waitForConfirms()
                            throws java.lang.InterruptedException

  Wait until all messages published since the last call have been either ack'd or nack'd by the broker. Note, when called on a non-Confirm channel, waitForConfirms returns true immediately.

  Returns:
    whether all the messages were ack'd (and none were nack'd)
  Throws:
    `java.lang.InterruptedException`

### waitForConfirms

    boolean waitForConfirms(long timeout)
                            throws java.lang.InterruptedException,
                                   java.util.concurrent.TimeoutException

  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. When called on a non-Confirm channel, waitForConfirms returns true immediately.

  Returns:
    whether all the messages were ack'd (and none were nack'd)
  Throws:
    `java.lang.InterruptedException`
    `java.util.concurrent.TimeoutException`

### waitForConfirmsOrDie

    void waitForConfirmsOrDie()
                              throws java.io.IOException,
                                     java.lang.InterruptedException

  Wait until all messages published since the last call have been either ack'd or nack'd by the broker. If any of the messages were nack'd, waitForConfirmsOrDie will throw an IOException. When called on a non-Confirm channel, it will return immediately.

  Throws:
    `java.io.IOException`
    `java.lang.InterruptedException`

### waitForConfirmsOrDie

    void waitForConfirmsOrDie(long timeout)
                              throws java.io.IOException,
                                     java.lang.InterruptedException,
                                     java.util.concurrent.TimeoutException

  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. If any of the messages were nack'd, waitForConfirmsOrDie will throw an IOException. When called on a non-Confirm channel, it will return immediately.

  Throws:
    `java.io.IOException`
    `java.lang.InterruptedException`
    `java.util.concurrent.TimeoutException`

### asyncRpc

    void asyncRpc(Method method)
                  throws java.io.IOException

  Asynchronously send a method over this channel.

  Parameters:
    `method` - method to transmit over this channel.
  Throws:
    `java.io.IOException` - Problem transmitting method.

### rpc

    Command rpc(Method method)
                throws java.io.IOException

  Synchronously send a method over this channel.

  Parameters:
    `method` - method to transmit over this channel.
  Returns:
    command response to method. Caller should cast as appropriate.
  Throws:
    `java.io.IOException` - Problem transmitting method.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD