ChannelN (RabbitMQ Java Client 5.13.0 API)

java.lang.Object
- com.rabbitmq.client.impl.ShutdownNotifierComponent
- - com.rabbitmq.client.impl.AMQChannel
  - - com.rabbitmq.client.impl.ChannelN

All Implemented Interfaces:

Channel, ShutdownNotifier, AutoCloseable

Direct Known Subclasses:

RecoveryAwareChannelN
```
public class ChannelN
extends AMQChannel
implements Channel
```
Main interface to AMQP protocol functionality. Public API - Implementation of all AMQChannels except channel zero.
To open a channel,
```
 Connection conn = ...;
 ChannelN ch1 = conn.createChannel();
 
```

Nested Class Summary
- Nested classes/interfaces inherited from class com.rabbitmq.client.impl.AMQChannel
  AMQChannel.BlockingRpcContinuation<T>, AMQChannel.RpcContinuation, AMQChannel.SimpleBlockingRpcContinuation

Field Summary

Fields
Modifier and Type Field and Description

protected MetricsCollector metricsCollector
- Fields inherited from class com.rabbitmq.client.impl.AMQChannel
  _blockContent, _channelMutex, _rpcTimeout, NO_RPC_TIMEOUT

Fields
Modifier and Type	Field and Description
`protected MetricsCollector`	`metricsCollector`

Constructor Summary

Constructors
Constructor and Description
`ChannelN(AMQConnection connection, int channelNumber, ConsumerWorkService workService)` Construct a new channel on the given connection with the given channel number.
`ChannelN(AMQConnection connection, int channelNumber, ConsumerWorkService workService, MetricsCollector metricsCollector)` Construct a new channel on the given connection with the given channel number.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort()` Public API - Abort this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'.
`void`	`abort(int closeCode, String closeMessage)` Public API - Abort this channel.
`ConfirmListener`	`addConfirmListener(ConfirmCallback ackCallback, ConfirmCallback nackCallback)` Add a lambda-based `ConfirmListener`.
`void`	`addConfirmListener(ConfirmListener listener)` Add a `ConfirmListener`.
`ReturnListener`	`addReturnListener(ReturnCallback returnCallback)` Add a lambda-based `ReturnListener`.
`void`	`addReturnListener(ReturnListener listener)` Add a `ReturnListener`.
`CompletableFuture<Command>`	`asyncCompletableRpc(Method method)` Asynchronously send a method over this channel.
`void`	`asyncRpc(Method method)` Asynchronously send a method over this channel.
`void`	`basicAck(long deliveryTag, boolean multiple)` Public API - Acknowledge one or several received messages.
`void`	`basicCancel(String consumerTag)` Public API - Cancel a consumer.
`String`	`basicConsume(String queue, boolean autoAck, Consumer callback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
`String`	`basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
`String`	`basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
`String`	`basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
`String`	`basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, Consumer callback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
`String`	`basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
`String`	`basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
`String`	`basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, Consumer callback)` Public API - Start a consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback)` Public API - Start a consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Start a consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, Consumer callback)` Public API - Start a non-nolocal, non-exclusive consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback)` Public API - Start a non-nolocal, non-exclusive consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer.
`String`	`basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer.
`String`	`basicConsume(String queue, Consumer callback)` Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
`String`	`basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
`String`	`basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
`String`	`basicConsume(String queue, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)` Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
`GetResponse`	`basicGet(String queue, boolean autoAck)` Public API - Retrieve a message from a queue using `AMQP.Basic.Get`
`void`	`basicNack(long deliveryTag, boolean multiple, boolean requeue)` Public API - Reject one or several received messages.
`void`	`basicPublish(String exchange, String routingKey, AMQP.BasicProperties props, byte[] body)` Public API - Publish a message.
`void`	`basicPublish(String exchange, String routingKey, boolean mandatory, AMQP.BasicProperties props, byte[] body)` Public API - Publish a message.
`void`	`basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, AMQP.BasicProperties props, byte[] body)` Public API - Publish a message.
`void`	`basicQos(int prefetchCount)` Public API - Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`basicQos(int prefetchCount, boolean global)` Public API - Request a specific prefetchCount "quality of service" settings for this channel.
`void`	`basicQos(int prefetchSize, int prefetchCount, boolean global)` Public API - Request specific "quality of service" settings.
`AMQImpl.Basic.RecoverOk`	`basicRecover()` Public API - Ask the broker to resend unacknowledged messages.
`AMQImpl.Basic.RecoverOk`	`basicRecover(boolean requeue)` Public API - Ask the broker to resend unacknowledged messages.
`void`	`basicReject(long deliveryTag, boolean requeue)` Public API - Reject a message.
`void`	`clearConfirmListeners()` Remove all `ConfirmListener`s.
`void`	`clearReturnListeners()` Remove all `ReturnListener`s.
`void`	`close()` Public API - Close this channel with the `AMQP.REPLY_SUCCESS` close code and message 'OK'.
`void`	`close(int closeCode, String closeMessage)` Public API - Close this channel.
`protected void`	`close(int closeCode, String closeMessage, boolean initiatedByApplication, Throwable cause, boolean abort)` Protected API - Close channel with code and message, indicating the source of the closure and a causing exception (null if none).
`AMQImpl.Confirm.SelectOk`	`confirmSelect()` Public API - Enables publisher acknowledgements on this channel.
`long`	`consumerCount(String queue)` Public API - Returns the number of consumers on a queue.
`void`	`enqueueRpc(AMQChannel.RpcContinuation k)`
`AMQImpl.Exchange.BindOk`	`exchangeBind(String destination, String source, String routingKey)` Public API - Bind an exchange to an exchange, with no extra arguments.
`AMQImpl.Exchange.BindOk`	`exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)` Public API - Bind an exchange to an exchange.
`void`	`exchangeBindNoWait(String destination, String source, String routingKey, Map<String,Object> arguments)` Public API - Like `Channel.exchangeBind(String, String, String, java.util.Map)` but sets nowait parameter to true and returns void (as there will be no response from the server).
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, BuiltinExchangeType type)` Public API - Actively declare a non-autodelete, non-durable exchange with no extra arguments
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable)` Public API - Actively declare a non-autodelete exchange with no extra arguments
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments)` Public API - Declare an exchange, via an interface that allows the complete set of arguments.
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, Map<String,Object> arguments)` Public API - Declare an exchange.
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, String type)` Public API - Actively declare a non-autodelete, non-durable exchange with no extra arguments
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, String type, boolean durable)` Public API - Actively declare a non-autodelete exchange with no extra arguments
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments)` Public API - Declare an exchange, via an interface that allows the complete set of arguments.
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String,Object> arguments)` Public API - Declare an exchange.
`void`	`exchangeDeclareNoWait(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments)` Like `Channel.exchangeDeclare(String, String, boolean, boolean, java.util.Map)` but sets nowait parameter to true and returns nothing (as there will be no response from the server).
`void`	`exchangeDeclareNoWait(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments)` Like `Channel.exchangeDeclare(String, String, boolean, boolean, java.util.Map)` but sets nowait parameter to true and returns nothing (as there will be no response from the server).
`AMQImpl.Exchange.DeclareOk`	`exchangeDeclarePassive(String exchange)` Public API - Declare an exchange passively; that is, check if the named exchange exists.
`AMQImpl.Exchange.DeleteOk`	`exchangeDelete(String exchange)` Public API - Delete an exchange, without regard for whether it is in use or not
`AMQImpl.Exchange.DeleteOk`	`exchangeDelete(String exchange, boolean ifUnused)` Public API - Delete an exchange
`void`	`exchangeDeleteNoWait(String exchange, boolean ifUnused)` Public API - Like `Channel.exchangeDelete(String, boolean)` but sets nowait parameter to true and returns void (as there will be no response from the server).
`AMQImpl.Exchange.UnbindOk`	`exchangeUnbind(String destination, String source, String routingKey)` Public API - Unbind an exchange from an exchange, with no extra arguments.
`AMQImpl.Exchange.UnbindOk`	`exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)` Public API - Unbind an exchange from an exchange.
`void`	`exchangeUnbindNoWait(String destination, String source, String routingKey, Map<String,Object> arguments)` Public API - Same as `Channel.exchangeUnbind(String, String, String, java.util.Map)` but sets no-wait parameter to true and returns nothing (as there will be no response from the server).
`Consumer`	`getDefaultConsumer()` Returns the current default consumer.
`long`	`getNextPublishSeqNo()` Public API - When in confirm mode, returns the sequence number of the next message to be published.
`protected void`	`markRpcFinished()`
`long`	`messageCount(String queue)` Public API - Returns the number of messages in a queue ready to be delivered to consumers.
`void`	`open()` Package method: open the channel.
`boolean`	`processAsync(Command command)` Protected API - Filters the inbound command stream, processing Basic.Deliver, Basic.Return and Channel.Close specially.
`protected void`	`processDelivery(Command command, AMQImpl.Basic.Deliver method)`
`void`	`processShutdownSignal(ShutdownSignalException signal, boolean ignoreClosed, boolean notifyRpc)` Protected API - overridden to quiesce consumer work and broadcast the signal to all consumers after calling the superclass's method.
`AMQImpl.Queue.BindOk`	`queueBind(String queue, String exchange, String routingKey)` Public API - Bind a queue to an exchange, with no extra arguments.
`AMQImpl.Queue.BindOk`	`queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Public API - Bind a queue to an exchange.
`void`	`queueBindNoWait(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Public API - Same as `Channel.queueBind(String, String, String, java.util.Map)` but sets nowait parameter to true and returns void (as there will be no response from the server).
`AMQP.Queue.DeclareOk`	`queueDeclare()` Public API - Actively declare a server-named exclusive, autodelete, non-durable queue.
`AMQImpl.Queue.DeclareOk`	`queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,Object> arguments)` Public API - Declare a queue
`void`	`queueDeclareNoWait(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,Object> arguments)` Public API - Like `Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)` but sets nowait flag to true and returns no result (as there will be no response from the server).
`AMQImpl.Queue.DeclareOk`	`queueDeclarePassive(String queue)` Public API - Declare a queue passively; i.e., check if it exists.
`AMQImpl.Queue.DeleteOk`	`queueDelete(String queue)` Public API - Delete a queue, without regard for whether it is in use or has messages on it
`AMQImpl.Queue.DeleteOk`	`queueDelete(String queue, boolean ifUnused, boolean ifEmpty)` Public API - Delete a queue
`void`	`queueDeleteNoWait(String queue, boolean ifUnused, boolean ifEmpty)` Like `Channel.queueDelete(String, boolean, boolean)` but sets nowait parameter to true and returns nothing (as there will be no response from the server).
`AMQImpl.Queue.PurgeOk`	`queuePurge(String queue)` Public API - Purges the contents of the given queue.
`AMQImpl.Queue.UnbindOk`	`queueUnbind(String queue, String exchange, String routingKey)` Public API - Unbinds a queue from an exchange, with no extra arguments.
`AMQImpl.Queue.UnbindOk`	`queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)` Public API - Unbind a queue from an exchange.
`boolean`	`removeConfirmListener(ConfirmListener listener)` Remove a `ConfirmListener`.
`boolean`	`removeReturnListener(ReturnListener listener)` Remove a `ReturnListener`.
`AMQCommand`	`rpc(Method method)` Protected API - sends a `Method` to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!
`void`	`setDefaultConsumer(Consumer consumer)` Sets the current default consumer.
`AMQImpl.Tx.CommitOk`	`txCommit()` Public API - Commits a TX transaction on this channel.
`AMQImpl.Tx.RollbackOk`	`txRollback()` Public API - Rolls back a TX transaction on this channel.
`AMQImpl.Tx.SelectOk`	`txSelect()` Public API - 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 class com.rabbitmq.client.impl.AMQChannel
asyncRpc, enqueueAsyncRpc, ensureIsOpen, exnWrappingAsyncRpc, exnWrappingRpc, getChannelNumber, getConnection, handleCompleteInboundCommand, handleFrame, isOutstandingRpc, nextOutstandingRpc, notifyOutstandingRpc, quiescingAsyncRpc, quiescingRpc, quiescingTransmit, quiescingTransmit, rpc, rpc, toString, transmit, transmit, wrap, wrap, wrapTimeoutException

Methods inherited from class com.rabbitmq.client.impl.ShutdownNotifierComponent
addShutdownListener, getCloseReason, isOpen, notifyListeners, removeShutdownListener, setShutdownCauseIfOpen

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.rabbitmq.client.Channel
getChannelNumber, getConnection

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

- Field Detail
  - metricsCollector
```
protected final MetricsCollector metricsCollector
```
- Constructor Detail
  - ChannelN
```
public ChannelN(AMQConnection connection,
                int channelNumber,
                ConsumerWorkService workService)
```
    Construct a new channel on the given connection with the given channel number. Usually not called directly - call Connection.createChannel instead.
    
    Parameters:
    
    connection - The connection associated with this channel
    
    channelNumber - The channel number to be associated with this channel
    
    workService - service for managing this channel's consumer callbacks
    
    See Also:
    
    Connection.createChannel()
  - ChannelN
```
public ChannelN(AMQConnection connection,
                int channelNumber,
                ConsumerWorkService workService,
                MetricsCollector metricsCollector)
```
    Construct a new channel on the given connection with the given channel number. Usually not called directly - call Connection.createChannel instead.
    
    Parameters:
    
    connection - The connection associated with this channel
    
    channelNumber - The channel number to be associated with this channel
    
    workService - service for managing this channel's consumer callbacks
    
    metricsCollector - service for managing metrics
    
    See Also:
    
    Connection.createChannel()
- Method Detail
  - open
```
public void open()
          throws IOException
```
    Package method: open the channel. This is only called from ChannelManager.
    
    Throws:
    
    IOException - if any problem is encountered
  - addReturnListener
```
public void addReturnListener(ReturnListener listener)
```
    Description copied from interface: Channel
    
    Add a ReturnListener.
    
    Specified by:
    
    addReturnListener in interface Channel
    
    Parameters:
    
    listener - the listener to add
  - addReturnListener
```
public ReturnListener addReturnListener(ReturnCallback returnCallback)
```
    Description copied from interface: Channel
    
    Add a lambda-based ReturnListener.
    
    Specified by:
    
    addReturnListener in interface Channel
    
    Parameters:
    
    returnCallback - the callback when the message is returned
    
    Returns:
    
    the listener that wraps the callback
    
    See Also:
    
    ReturnListener, ReturnCallback, Return
  - removeReturnListener
```
public boolean removeReturnListener(ReturnListener listener)
```
    Description copied from interface: Channel
    
    Remove a ReturnListener.
    
    Specified by:
    
    removeReturnListener in interface Channel
    
    Parameters:
    
    listener - the listener to remove
    
    Returns:
    
    true if the listener was found and removed, false otherwise
  - clearReturnListeners
```
public void clearReturnListeners()
```
    Description copied from interface: Channel
    
    Remove all ReturnListeners.
    
    Specified by:
    
    clearReturnListeners in interface Channel
  - addConfirmListener
```
public void addConfirmListener(ConfirmListener listener)
```
    Description copied from interface: Channel
    
    Add a ConfirmListener.
    
    Specified by:
    
    addConfirmListener in interface Channel
    
    Parameters:
    
    listener - the listener to add
  - addConfirmListener
```
public ConfirmListener addConfirmListener(ConfirmCallback ackCallback,
                                          ConfirmCallback nackCallback)
```
    Description copied from interface: Channel
    
    Add a lambda-based ConfirmListener.
    
    Specified by:
    
    addConfirmListener in interface Channel
    
    Parameters:
    
    ackCallback - callback on ack
    
    nackCallback - call on nack (negative ack)
    
    Returns:
    
    the listener that wraps the callbacks
    
    See Also:
    
    ConfirmListener, ConfirmCallback
  - removeConfirmListener
```
public boolean removeConfirmListener(ConfirmListener listener)
```
    Description copied from interface: Channel
    
    Remove a ConfirmListener.
    
    Specified by:
    
    removeConfirmListener in interface Channel
    
    Parameters:
    
    listener - the listener to remove
    
    Returns:
    
    true if the listener was found and removed, false otherwise
  - clearConfirmListeners
```
public void clearConfirmListeners()
```
    Description copied from interface: Channel
    
    Remove all ConfirmListeners.
    
    Specified by:
    
    clearConfirmListeners in interface Channel
  - waitForConfirms
```
public boolean waitForConfirms()
                        throws 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 throws an IllegalStateException.
    
    Specified by:
    
    waitForConfirms in interface Channel
    
    Returns:
    
    whether all the messages were ack'd (and none were nack'd)
    
    Throws:
    
    InterruptedException
  - waitForConfirms
```
public boolean waitForConfirms(long timeout)
                        throws InterruptedException,
                               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 throws an IllegalStateException.
    
    Specified by:
    
    waitForConfirms in interface Channel
    
    Returns:
    
    whether all the messages were ack'd (and none were nack'd)
    
    Throws:
    
    InterruptedException
    
    TimeoutException
  - waitForConfirmsOrDie
```
public void waitForConfirmsOrDie()
                          throws IOException,
                                 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 throw an IllegalStateException.
    
    Specified by:
    
    waitForConfirmsOrDie in interface Channel
    
    Throws:
    
    IOException
    
    InterruptedException
  - waitForConfirmsOrDie
```
public void waitForConfirmsOrDie(long timeout)
                          throws IOException,
                                 InterruptedException,
                                 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 throw an IllegalStateException.
    
    Specified by:
    
    waitForConfirmsOrDie in interface Channel
    
    Throws:
    
    IOException
    
    InterruptedException
    
    TimeoutException
  - getDefaultConsumer
```
public Consumer getDefaultConsumer()
```
    Returns the current default consumer.
    
    Specified by:
    
    getDefaultConsumer in interface Channel
    
    Returns:
    
    an interface to the current default consumer.
  - setDefaultConsumer
```
public void setDefaultConsumer(Consumer consumer)
```
    Sets the current default consumer. A null argument is interpreted to mean "do not use a default consumer".
    
    Specified by:
    
    setDefaultConsumer in interface Channel
    
    Parameters:
    
    consumer - the consumer to use, or null indicating "don't use one".
  - processShutdownSignal
```
public void processShutdownSignal(ShutdownSignalException signal,
                                  boolean ignoreClosed,
                                  boolean notifyRpc)
```
    Protected API - overridden to quiesce consumer work and broadcast the signal to all consumers after calling the superclass's method.
    
    Overrides:
    
    processShutdownSignal in class AMQChannel
    
    Parameters:
    
    signal - the signal to handle
    
    ignoreClosed - the flag indicating whether to ignore the AlreadyClosedException thrown when the channel is already closed
    
    notifyRpc - the flag indicating whether any remaining rpc continuation should be notified with the given signal
  - processAsync
```
public boolean processAsync(Command command)
                     throws IOException
```
    Protected API - Filters the inbound command stream, processing Basic.Deliver, Basic.Return and Channel.Close specially. If we're in quiescing mode, all inbound commands are ignored, except for Channel.Close and Channel.CloseOk.
    
    Specified by:
    
    processAsync in class AMQChannel
    
    Parameters:
    
    command - the command to handle asynchronously
    
    Returns:
    
    true if we handled the command; otherwise the caller should consider it "unhandled"
    
    Throws:
    
    IOException
  - processDelivery
```
protected void processDelivery(Command command,
                               AMQImpl.Basic.Deliver method)
```
  - close
```
public void close()
           throws IOException,
                  TimeoutException
```
    Public API - Close this channel with the AMQP.REPLY_SUCCESS close code and message 'OK'.
    
    Specified by:
    
    close in interface Channel
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException - if an error is encountered
    
    TimeoutException
  - close
```
public void close(int closeCode,
                  String closeMessage)
           throws IOException,
                  TimeoutException
```
    Public API - Close this channel.
    
    Specified by:
    
    close in interface 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:
    
    IOException - if an error is encountered
    
    TimeoutException
  - abort
```
public void abort()
           throws IOException
```
    Public API - 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.
    
    Specified by:
    
    abort in interface Channel
    
    Throws:
    
    IOException
  - abort
```
public void abort(int closeCode,
                  String closeMessage)
           throws IOException
```
    Public API - 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.
    
    Specified by:
    
    abort in interface Channel
    
    Throws:
    
    IOException
  - close
```
protected void close(int closeCode,
                     String closeMessage,
                     boolean initiatedByApplication,
                     Throwable cause,
                     boolean abort)
              throws IOException,
                     TimeoutException
```
    Protected API - Close channel with code and message, indicating the source of the closure and a causing exception (null if none).
    
    Parameters:
    
    closeCode - the close code (See under "Reply Codes" in the AMQP specification)
    
    closeMessage - a message indicating the reason for closing the connection
    
    initiatedByApplication - true if this comes from an API call, false otherwise
    
    cause - exception triggering close
    
    abort - true if we should close and ignore errors
    
    Throws:
    
    IOException - if an error is encountered
    
    TimeoutException
  - basicQos
```
public void basicQos(int prefetchSize,
                     int prefetchCount,
                     boolean global)
              throws IOException
```
    Public API - 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.
    Note the prefetch count must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
    
    Specified by:
    
    basicQos in interface Channel
    
    Parameters:
    
    prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
    
    prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
    
    global - true if the settings should be applied to the entire channel rather than each consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Qos
  - basicQos
```
public void basicQos(int prefetchCount,
                     boolean global)
              throws IOException
```
    Public API - Request a specific prefetchCount "quality of service" settings for this channel.
    Note the prefetch count must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
    
    Specified by:
    
    basicQos in interface Channel
    
    Parameters:
    
    prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
    
    global - true if the settings should be applied to the entire channel rather than each consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    Channel.basicQos(int, int, boolean)
  - basicQos
```
public void basicQos(int prefetchCount)
              throws IOException
```
    Public API - Request a specific prefetchCount "quality of service" settings for this channel.
    Note the prefetch count must be between 0 and 65535 (unsigned short in AMQP 0-9-1).
    
    Specified by:
    
    basicQos in interface Channel
    
    Parameters:
    
    prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    Channel.basicQos(int, int, boolean)
  - basicPublish
```
public void basicPublish(String exchange,
                         String routingKey,
                         AMQP.BasicProperties props,
                         byte[] body)
                  throws IOException
```
    Public API - 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.
    
    Specified by:
    
    basicPublish in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Publish, Resource-driven alarms
  - basicPublish
```
public void basicPublish(String exchange,
                         String routingKey,
                         boolean mandatory,
                         AMQP.BasicProperties props,
                         byte[] body)
                  throws IOException
```
    Public API - Publish a message. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
    
    Specified by:
    
    basicPublish in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Publish, Resource-driven alarms
  - basicPublish
```
public void basicPublish(String exchange,
                         String routingKey,
                         boolean mandatory,
                         boolean immediate,
                         AMQP.BasicProperties props,
                         byte[] body)
                  throws IOException
```
    Public API - 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.
    
    Specified by:
    
    basicPublish in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Publish, Resource-driven alarms
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  String type,
                                                  boolean durable,
                                                  boolean autoDelete,
                                                  Map<String,Object> arguments)
                                           throws IOException
```
    Public API - Declare an exchange.
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  BuiltinExchangeType type,
                                                  boolean durable,
                                                  boolean autoDelete,
                                                  Map<String,Object> arguments)
                                           throws IOException
```
    Public API - Declare an exchange.
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclareNoWait
```
public void exchangeDeclareNoWait(String exchange,
                                  String type,
                                  boolean durable,
                                  boolean autoDelete,
                                  boolean internal,
                                  Map<String,Object> arguments)
                           throws IOException
```
    Description copied from interface: Channel
    
    Like Channel.exchangeDeclare(String, String, boolean, boolean, java.util.Map) but sets nowait parameter to true and returns nothing (as there will be no response from the server).
    
    Specified by:
    
    exchangeDeclareNoWait in interface Channel
    
    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
    
    Throws:
    
    IOException - if an error is encountered
  - exchangeDeclareNoWait
```
public void exchangeDeclareNoWait(String exchange,
                                  BuiltinExchangeType type,
                                  boolean durable,
                                  boolean autoDelete,
                                  boolean internal,
                                  Map<String,Object> arguments)
                           throws IOException
```
    Description copied from interface: Channel
    
    Like Channel.exchangeDeclare(String, String, boolean, boolean, java.util.Map) but sets nowait parameter to true and returns nothing (as there will be no response from the server).
    
    Specified by:
    
    exchangeDeclareNoWait in interface Channel
    
    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
    
    Throws:
    
    IOException - if an error is encountered
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  String type,
                                                  boolean durable,
                                                  boolean autoDelete,
                                                  boolean internal,
                                                  Map<String,Object> arguments)
                                           throws IOException
```
    Public API - Declare an exchange, via an interface that allows the complete set of arguments.
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  BuiltinExchangeType type,
                                                  boolean durable,
                                                  boolean autoDelete,
                                                  boolean internal,
                                                  Map<String,Object> arguments)
                                           throws IOException
```
    Public API - Declare an exchange, via an interface that allows the complete set of arguments.
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  String type,
                                                  boolean durable)
                                           throws IOException
```
    Public API - Actively declare a non-autodelete exchange with no extra arguments
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  BuiltinExchangeType type,
                                                  boolean durable)
                                           throws IOException
```
    Public API - Actively declare a non-autodelete exchange with no extra arguments
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  String type)
                                           throws IOException
```
    Public API - Actively declare a non-autodelete, non-durable exchange with no extra arguments
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    Parameters:
    
    exchange - the name of the exchange
    
    type - the exchange type
    
    Returns:
    
    a declaration-confirm method to indicate the exchange was successfully declared
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclare
```
public AMQImpl.Exchange.DeclareOk exchangeDeclare(String exchange,
                                                  BuiltinExchangeType type)
                                           throws IOException
```
    Public API - Actively declare a non-autodelete, non-durable exchange with no extra arguments
    
    Specified by:
    
    exchangeDeclare in interface Channel
    
    Parameters:
    
    exchange - the name of the exchange
    
    type - the exchange type
    
    Returns:
    
    a declaration-confirm method to indicate the exchange was successfully declared
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Declare, AMQP.Exchange.DeclareOk
  - exchangeDeclarePassive
```
public AMQImpl.Exchange.DeclareOk exchangeDeclarePassive(String exchange)
                                                  throws IOException
```
    Public API - Declare an exchange passively; that is, check if the named exchange exists.
    
    Specified by:
    
    exchangeDeclarePassive in interface Channel
    
    Parameters:
    
    exchange - check the existence of an exchange named this
    
    Throws:
    
    IOException - the server will raise a 404 channel exception if the named exchange does not exist.
  - exchangeDelete
```
public AMQImpl.Exchange.DeleteOk exchangeDelete(String exchange,
                                                boolean ifUnused)
                                         throws IOException
```
    Public API - Delete an exchange
    
    Specified by:
    
    exchangeDelete in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Delete, AMQP.Exchange.DeleteOk
  - exchangeDeleteNoWait
```
public void exchangeDeleteNoWait(String exchange,
                                 boolean ifUnused)
                          throws IOException
```
    Public API - Like Channel.exchangeDelete(String, boolean) but sets nowait parameter to true and returns void (as there will be no response from the server).
    
    Specified by:
    
    exchangeDeleteNoWait in interface Channel
    
    Parameters:
    
    exchange - the name of the exchange
    
    ifUnused - true to indicate that the exchange is only to be deleted if it is unused
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Delete, AMQP.Exchange.DeleteOk
  - exchangeDelete
```
public AMQImpl.Exchange.DeleteOk exchangeDelete(String exchange)
                                         throws IOException
```
    Public API - Delete an exchange, without regard for whether it is in use or not
    
    Specified by:
    
    exchangeDelete in interface Channel
    
    Parameters:
    
    exchange - the name of the exchange
    
    Returns:
    
    a deletion-confirm method to indicate the exchange was successfully deleted
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Delete, AMQP.Exchange.DeleteOk
  - exchangeBind
```
public AMQImpl.Exchange.BindOk exchangeBind(String destination,
                                            String source,
                                            String routingKey,
                                            Map<String,Object> arguments)
                                     throws IOException
```
    Public API - Bind an exchange to an exchange.
    
    Specified by:
    
    exchangeBind in interface Channel
    
    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 routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Bind, AMQP.Exchange.BindOk
  - exchangeBindNoWait
```
public void exchangeBindNoWait(String destination,
                               String source,
                               String routingKey,
                               Map<String,Object> arguments)
                        throws IOException
```
    Public API - Like Channel.exchangeBind(String, String, String, java.util.Map) but sets nowait parameter to true and returns void (as there will be no response from the server).
    
    Specified by:
    
    exchangeBindNoWait in interface Channel
    
    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 routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Throws:
    
    IOException - if an error is encountered
  - exchangeBind
```
public AMQImpl.Exchange.BindOk exchangeBind(String destination,
                                            String source,
                                            String routingKey)
                                     throws IOException
```
    Public API - Bind an exchange to an exchange, with no extra arguments.
    
    Specified by:
    
    exchangeBind in interface Channel
    
    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 routing key to use for the binding
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Bind, AMQP.Exchange.BindOk
  - exchangeUnbind
```
public AMQImpl.Exchange.UnbindOk exchangeUnbind(String destination,
                                                String source,
                                                String routingKey,
                                                Map<String,Object> arguments)
                                         throws IOException
```
    Public API - Unbind an exchange from an exchange.
    
    Specified by:
    
    exchangeUnbind in interface Channel
    
    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 routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Bind, AMQP.Exchange.BindOk
  - exchangeUnbind
```
public AMQImpl.Exchange.UnbindOk exchangeUnbind(String destination,
                                                String source,
                                                String routingKey)
                                         throws IOException
```
    Public API - Unbind an exchange from an exchange, with no extra arguments.
    
    Specified by:
    
    exchangeUnbind in interface Channel
    
    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 routing key to use for the binding
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Exchange.Bind, AMQP.Exchange.BindOk
  - exchangeUnbindNoWait
```
public void exchangeUnbindNoWait(String destination,
                                 String source,
                                 String routingKey,
                                 Map<String,Object> arguments)
                          throws IOException
```
    Public API - Same as Channel.exchangeUnbind(String, String, String, java.util.Map) but sets no-wait parameter to true and returns nothing (as there will be no response from the server).
    
    Specified by:
    
    exchangeUnbindNoWait in interface Channel
    
    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 routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Throws:
    
    IOException - if an error is encountered
  - queueDeclare
```
public AMQImpl.Queue.DeclareOk queueDeclare(String queue,
                                            boolean durable,
                                            boolean exclusive,
                                            boolean autoDelete,
                                            Map<String,Object> arguments)
                                     throws IOException
```
    Public API - Declare a queue
    
    Specified by:
    
    queueDeclare in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Declare, AMQP.Queue.DeclareOk
  - queueDeclare
```
public AMQP.Queue.DeclareOk queueDeclare()
                                  throws IOException
```
    Public API - 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.
    
    Specified by:
    
    queueDeclare in interface Channel
    
    Returns:
    
    a declaration-confirm method to indicate the queue was successfully declared
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Declare, AMQP.Queue.DeclareOk
  - queueDeclareNoWait
```
public void queueDeclareNoWait(String queue,
                               boolean durable,
                               boolean exclusive,
                               boolean autoDelete,
                               Map<String,Object> arguments)
                        throws IOException
```
    Public API - Like Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map) but sets nowait flag to true and returns no result (as there will be no response from the server).
    
    Specified by:
    
    queueDeclareNoWait in interface Channel
    
    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
    
    Throws:
    
    IOException - if an error is encountered
  - queueDeclarePassive
```
public AMQImpl.Queue.DeclareOk queueDeclarePassive(String queue)
                                            throws IOException
```
    Public API - 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.
    
    Specified by:
    
    queueDeclarePassive in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    Returns:
    
    a declaration-confirm method to indicate the queue exists
    
    Throws:
    
    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
  - messageCount
```
public long messageCount(String queue)
                  throws IOException
```
    Public API - Returns the number of messages in a queue ready to be delivered to consumers. This method assumes the queue exists. If it doesn't, the channels will be closed with an exception.
    
    Specified by:
    
    messageCount in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    Returns:
    
    the number of messages in ready state
    
    Throws:
    
    IOException - Problem transmitting method.
  - consumerCount
```
public long consumerCount(String queue)
                   throws IOException
```
    Public API - Returns the number of consumers on a queue. This method assumes the queue exists. If it doesn't, the channel will be closed with an exception.
    
    Specified by:
    
    consumerCount in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    Returns:
    
    the number of consumers
    
    Throws:
    
    IOException - Problem transmitting method.
  - queueDelete
```
public AMQImpl.Queue.DeleteOk queueDelete(String queue,
                                          boolean ifUnused,
                                          boolean ifEmpty)
                                   throws IOException
```
    Public API - Delete a queue
    
    Specified by:
    
    queueDelete in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Delete, AMQP.Queue.DeleteOk
  - queueDeleteNoWait
```
public void queueDeleteNoWait(String queue,
                              boolean ifUnused,
                              boolean ifEmpty)
                       throws IOException
```
    Description copied from interface: Channel
    
    Like Channel.queueDelete(String, boolean, boolean) but sets nowait parameter to true and returns nothing (as there will be no response from the server).
    
    Specified by:
    
    queueDeleteNoWait in interface Channel
    
    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
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Delete, AMQP.Queue.DeleteOk
  - queueDelete
```
public AMQImpl.Queue.DeleteOk queueDelete(String queue)
                                   throws IOException
```
    Public API - Delete a queue, without regard for whether it is in use or has messages on it
    
    Specified by:
    
    queueDelete in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    Returns:
    
    a deletion-confirm method to indicate the queue was successfully deleted
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Delete, AMQP.Queue.DeleteOk
  - queueBind
```
public AMQImpl.Queue.BindOk queueBind(String queue,
                                      String exchange,
                                      String routingKey,
                                      Map<String,Object> arguments)
                               throws IOException
```
    Public API - Bind a queue to an exchange.
    
    Specified by:
    
    queueBind in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    exchange - the name of the exchange
    
    routingKey - the routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Bind, AMQP.Queue.BindOk
  - queueBind
```
public AMQImpl.Queue.BindOk queueBind(String queue,
                                      String exchange,
                                      String routingKey)
                               throws IOException
```
    Public API - Bind a queue to an exchange, with no extra arguments.
    
    Specified by:
    
    queueBind in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    exchange - the name of the exchange
    
    routingKey - the routing key to use for the binding
    
    Returns:
    
    a binding-confirm method if the binding was successfully created
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Bind, AMQP.Queue.BindOk
  - queueBindNoWait
```
public void queueBindNoWait(String queue,
                            String exchange,
                            String routingKey,
                            Map<String,Object> arguments)
                     throws IOException
```
    Public API - Same as Channel.queueBind(String, String, String, java.util.Map) but sets nowait parameter to true and returns void (as there will be no response from the server).
    
    Specified by:
    
    queueBindNoWait in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    exchange - the name of the exchange
    
    routingKey - the routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Throws:
    
    IOException - if an error is encountered
  - queueUnbind
```
public AMQImpl.Queue.UnbindOk queueUnbind(String queue,
                                          String exchange,
                                          String routingKey,
                                          Map<String,Object> arguments)
                                   throws IOException
```
    Public API - Unbind a queue from an exchange.
    
    Specified by:
    
    queueUnbind in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    exchange - the name of the exchange
    
    routingKey - the routing key to use for the binding
    
    arguments - other properties (binding parameters)
    
    Returns:
    
    an unbinding-confirm method if the binding was successfully deleted
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Unbind, AMQP.Queue.UnbindOk
  - queuePurge
```
public AMQImpl.Queue.PurgeOk queuePurge(String queue)
                                 throws IOException
```
    Public API - Purges the contents of the given queue.
    
    Specified by:
    
    queuePurge in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    Returns:
    
    a purge-confirm method if the purge was executed successfully
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Purge, AMQP.Queue.PurgeOk
  - queueUnbind
```
public AMQImpl.Queue.UnbindOk queueUnbind(String queue,
                                          String exchange,
                                          String routingKey)
                                   throws IOException
```
    Public API - Unbinds a queue from an exchange, with no extra arguments.
    
    Specified by:
    
    queueUnbind in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    exchange - the name of the exchange
    
    routingKey - the routing key to use for the binding
    
    Returns:
    
    an unbinding-confirm method if the binding was successfully deleted
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Queue.Unbind, AMQP.Queue.UnbindOk
  - basicGet
```
public GetResponse basicGet(String queue,
                            boolean autoAck)
                     throws IOException
```
    Public API - Retrieve a message from a queue using AMQP.Basic.Get
    
    Specified by:
    
    basicGet in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Get, AMQP.Basic.GetOk, AMQP.Basic.GetEmpty
  - basicAck
```
public void basicAck(long deliveryTag,
                     boolean multiple)
              throws IOException
```
    Public API - 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.
    
    Specified by:
    
    basicAck in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Ack
  - basicNack
```
public void basicNack(long deliveryTag,
                      boolean multiple,
                      boolean requeue)
               throws IOException
```
    Public API - 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.
    
    Specified by:
    
    basicNack in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Nack
  - basicReject
```
public void basicReject(long deliveryTag,
                        boolean requeue)
                 throws IOException
```
    Public API - Reject a message. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being rejected.
    
    Specified by:
    
    basicReject in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Reject
  - basicConsume
```
public String basicConsume(String queue,
                           Consumer callback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
    
    Specified by:
    
    basicConsume in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    callback - an interface to the consumer object
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag. Provide access only to basic.deliver and basic.cancel AMQP methods (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           DeliverCallback deliverCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag. Provide access only to basic.deliver and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    deliverCallback - callback when a message is delivered
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag. Provide access to basic.deliver, basic.cancel and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    Parameters:
    
    queue - the name of the queue
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           Consumer callback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           DeliverCallback deliverCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag. Provide access only to basic.deliver and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag. Provide access only to basic.deliver and basic.cancel AMQP methods (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Description copied from interface: Channel
    
    Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag. Provide access to basic.deliver, basic.cancel and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           Map<String,Object> arguments,
                           Consumer callback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    arguments - a set of arguments for the consume
    
    callback - an interface to the consumer object
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments. Provide access only to basic.deliver and basic.cancel AMQP methods (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments. Provide access only to basic.deliver and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments. Provide access to basic.deliver, basic.cancel and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag generated by the server
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicAck(long, boolean), Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           Consumer callback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer. Provide access only to basic.deliver and basic.cancel AMQP methods (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           DeliverCallback deliverCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer. Provide access only to basic.deliver and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a non-nolocal, non-exclusive consumer. Provide access to basic.deliver, basic.cancel and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk, Channel.basicConsume(String, boolean, String, boolean, boolean, Map, Consumer)
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           boolean noLocal,
                           boolean exclusive,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback)
                    throws IOException
```
    Public API - Start a consumer. Calls the consumer's Consumer.handleConsumeOk(java.lang.String) method. Provide access only to basic.deliver and basic.cancel AMQP methods (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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. Note that the RabbitMQ server does not support this flag.
    
    exclusive - true if this is an exclusive consumer
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           boolean noLocal,
                           boolean exclusive,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Public API - Start a consumer. Calls the consumer's Consumer.handleConsumeOk(java.lang.String) method. Provide access only to basic.deliver and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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. Note that the RabbitMQ server does not support this flag.
    
    exclusive - true if this is an exclusive consumer
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           boolean noLocal,
                           boolean exclusive,
                           Map<String,Object> arguments,
                           DeliverCallback deliverCallback,
                           CancelCallback cancelCallback,
                           ConsumerShutdownSignalCallback shutdownSignalCallback)
                    throws IOException
```
    Description copied from interface: Channel
    
    Start a consumer. Calls the consumer's Consumer.handleConsumeOk(java.lang.String) method. Provide access to basic.deliver, basic.cancel and shutdown signal callbacks (which is sufficient for most cases). See methods with a Consumer argument to have access to all the application callbacks.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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. Note that the RabbitMQ server does not support this flag.
    
    exclusive - true if this is an exclusive consumer
    
    arguments - a set of arguments for the consume
    
    deliverCallback - callback when a message is delivered
    
    cancelCallback - callback when the consumer is cancelled
    
    shutdownSignalCallback - callback when the channel/connection is shut down
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk
  - basicConsume
```
public String basicConsume(String queue,
                           boolean autoAck,
                           String consumerTag,
                           boolean noLocal,
                           boolean exclusive,
                           Map<String,Object> arguments,
                           Consumer callback)
                    throws IOException
```
    Public API - Start a consumer. Calls the consumer's Consumer.handleConsumeOk(java.lang.String) method.
    
    Specified by:
    
    basicConsume in interface Channel
    
    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. Note that the RabbitMQ server does not support this flag.
    
    exclusive - true if this is an exclusive consumer
    
    arguments - a set of arguments for the consume
    
    callback - an interface to the consumer object
    
    Returns:
    
    the consumerTag associated with the new consumer
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Basic.Consume, AMQP.Basic.ConsumeOk
  - basicCancel
```
public void basicCancel(String consumerTag)
                 throws IOException
```
    Public API - Cancel a consumer. Calls the consumer's Consumer.handleCancelOk(java.lang.String) method.
    
    Specified by:
    
    basicCancel in interface Channel
    
    Parameters:
    
    consumerTag - a client- or server-generated consumer tag to establish context
    
    Throws:
    
    IOException - if an error is encountered, or if the consumerTag is unknown
    
    See Also:
    
    AMQP.Basic.Cancel, AMQP.Basic.CancelOk
  - basicRecover
```
public AMQImpl.Basic.RecoverOk basicRecover()
                                     throws IOException
```
    Public API -
    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.
    
    Specified by:
    
    basicRecover in interface Channel
    
    Throws:
    
    IOException
    
    See Also:
    
    Channel.basicRecover(boolean)
  - basicRecover
```
public AMQImpl.Basic.RecoverOk basicRecover(boolean requeue)
                                     throws IOException
```
    Public API - 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.
    
    Specified by:
    
    basicRecover in interface Channel
    
    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:
    
    IOException
  - txSelect
```
public AMQImpl.Tx.SelectOk txSelect()
                             throws IOException
```
    Public API - Enables TX mode on this channel.
    
    Specified by:
    
    txSelect in interface Channel
    
    Returns:
    
    a transaction-selection method to indicate the transaction was successfully initiated
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Tx.Select, AMQP.Tx.SelectOk
  - txCommit
```
public AMQImpl.Tx.CommitOk txCommit()
                             throws IOException
```
    Public API - Commits a TX transaction on this channel.
    
    Specified by:
    
    txCommit in interface Channel
    
    Returns:
    
    a transaction-commit method to indicate the transaction was successfully committed
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Tx.Commit, AMQP.Tx.CommitOk
  - txRollback
```
public AMQImpl.Tx.RollbackOk txRollback()
                                 throws IOException
```
    Public API - Rolls back a TX transaction on this channel.
    
    Specified by:
    
    txRollback in interface Channel
    
    Returns:
    
    a transaction-rollback method to indicate the transaction was successfully rolled back
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Tx.Rollback, AMQP.Tx.RollbackOk
  - confirmSelect
```
public AMQImpl.Confirm.SelectOk confirmSelect()
                                       throws IOException
```
    Public API - Enables publisher acknowledgements on this channel.
    
    Specified by:
    
    confirmSelect in interface Channel
    
    Throws:
    
    IOException - if an error is encountered
    
    See Also:
    
    AMQP.Confirm.Select
  - getNextPublishSeqNo
```
public long getNextPublishSeqNo()
```
    Public API - When in confirm mode, returns the sequence number of the next message to be published.
    
    Specified by:
    
    getNextPublishSeqNo in interface Channel
    
    Returns:
    
    the sequence number of the next message to be published
  - asyncRpc
```
public void asyncRpc(Method method)
              throws IOException
```
    Description copied from interface: Channel
    
    Asynchronously send a method over this channel.
    
    Specified by:
    
    asyncRpc in interface Channel
    
    Parameters:
    
    method - method to transmit over this channel.
    
    Throws:
    
    IOException - Problem transmitting method.
  - rpc
```
public AMQCommand rpc(Method method)
               throws IOException
```
    Description copied from class: AMQChannel
    
    Protected API - sends a Method to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!
    
    Specified by:
    
    rpc in interface Channel
    
    Overrides:
    
    rpc in class AMQChannel
    
    Parameters:
    
    method - method to transmit over this channel.
    
    Returns:
    
    command response to method. Caller should cast as appropriate.
    
    Throws:
    
    IOException - Problem transmitting method.
  - asyncCompletableRpc
```
public CompletableFuture<Command> asyncCompletableRpc(Method method)
                                               throws IOException
```
    Description copied from interface: Channel
    
    Asynchronously send a method over this channel.
    
    Specified by:
    
    asyncCompletableRpc in interface Channel
    
    Parameters:
    
    method - method to transmit over this channel.
    
    Returns:
    
    a completable future that completes when the result is received
    
    Throws:
    
    IOException - Problem transmitting method.
  - enqueueRpc
```
public void enqueueRpc(AMQChannel.RpcContinuation k)
```
    Overrides:
    
    enqueueRpc in class AMQChannel
  - markRpcFinished
```
protected void markRpcFinished()
```
    Overrides:
    
    markRpcFinished in class AMQChannel

Class ChannelN

Nested Class Summary

Nested classes/interfaces inherited from class com.rabbitmq.client.impl.AMQChannel

Field Summary

Fields inherited from class com.rabbitmq.client.impl.AMQChannel

Constructor Summary

Method Summary

Methods inherited from class com.rabbitmq.client.impl.AMQChannel

Methods inherited from class com.rabbitmq.client.impl.ShutdownNotifierComponent

Methods inherited from class java.lang.Object

Methods inherited from interface com.rabbitmq.client.Channel

Methods inherited from interface com.rabbitmq.client.ShutdownNotifier

Field Detail

metricsCollector

Constructor Detail

ChannelN

ChannelN

Method Detail

open

addReturnListener

addReturnListener

removeReturnListener

clearReturnListeners

addConfirmListener

addConfirmListener

removeConfirmListener

clearConfirmListeners

waitForConfirms

waitForConfirms

waitForConfirmsOrDie

waitForConfirmsOrDie

getDefaultConsumer

setDefaultConsumer

processShutdownSignal

processAsync

processDelivery

close

close

abort

abort

close

basicQos

basicQos

basicQos

basicPublish

basicPublish

basicPublish

exchangeDeclare

exchangeDeclare

exchangeDeclareNoWait

exchangeDeclareNoWait

exchangeDeclare

exchangeDeclare

exchangeDeclare

exchangeDeclare

exchangeDeclare

exchangeDeclare

exchangeDeclarePassive

exchangeDelete

exchangeDeleteNoWait

exchangeDelete

exchangeBind

exchangeBindNoWait

exchangeBind

exchangeUnbind

exchangeUnbind

exchangeUnbindNoWait

queueDeclare

queueDeclare

queueDeclareNoWait

queueDeclarePassive

messageCount

consumerCount

queueDelete

queueDeleteNoWait

queueDelete

queueBind

queueBind

queueBindNoWait

queueUnbind