Interface Channel

All Superinterfaces:
AutoCloseable, ShutdownNotifier
All Known Subinterfaces:
RecoverableChannel
All Known Implementing Classes:
AutorecoveringChannel, ChannelN, RecoveryAwareChannelN

public interface Channel extends ShutdownNotifier, AutoCloseable
Interface to a channel. All non-deprecated methods of this interface are part of the public API.

Tutorials

RabbitMQ tutorials demonstrate how key methods of this interface are used.

User Guide

See Java Client User Guide.

Concurrency Considerations

Channel instances must not be shared between threads. Applications should prefer using a Channel per thread instead of sharing the same Channel across multiple threads. While some operations on channels are safe to invoke concurrently, some are not and will result in incorrect frame interleaving on the wire. Sharing channels between threads will also interfere with Publisher Confirms. As such, applications need to use a Channel per thread.

See Also:
  • Method Details

    • getChannelNumber

      int getChannelNumber()
      Retrieve this channel's channel number.
      Returns:
      the channel number
    • getConnection

      Connection getConnection()
      Retrieve the connection which carries this channel.
      Returns:
      the underlying Connection
    • close

      void close() throws IOException, TimeoutException
      Close this channel with the AMQP.REPLY_SUCCESS close code and message 'OK'.
      Specified by:
      close in interface AutoCloseable
      Throws:
      IOException - if an error is encountered
      TimeoutException
    • close

      void close(int closeCode, String closeMessage) throws IOException, TimeoutException
      Close this channel.
      Parameters:
      closeCode - the close code (See under "Reply Codes" in the AMQP specification)
      closeMessage - a message indicating the reason for closing the connection
      Throws:
      IOException - if an error is encountered
      TimeoutException
    • abort

      void abort() throws IOException
      Abort this channel with the AMQP.REPLY_SUCCESS close code and message 'OK'. Forces the channel to close and waits for the close operation to complete. Any encountered exceptions in the close operation are silently discarded.
      Throws:
      IOException
    • abort

      void abort(int closeCode, String closeMessage) throws IOException
      Abort this channel. Forces the channel to close and waits for the close operation to complete. Any encountered exceptions in the close operation are silently discarded.
      Throws:
      IOException
    • addReturnListener

      void addReturnListener(ReturnListener listener)
      Parameters:
      listener - the listener to add
    • addReturnListener

      ReturnListener addReturnListener(ReturnCallback returnCallback)
      Add a lambda-based ReturnListener.
      Parameters:
      returnCallback - the callback when the message is returned
      Returns:
      the listener that wraps the callback
      See Also:
    • removeReturnListener

      boolean removeReturnListener(ReturnListener listener)
      Remove a ReturnListener.
      Parameters:
      listener - the listener to remove
      Returns:
      true if the listener was found and removed, false otherwise
    • clearReturnListeners

      void clearReturnListeners()
      Remove all ReturnListeners.
    • addConfirmListener

      void addConfirmListener(ConfirmListener listener)
      Parameters:
      listener - the listener to add
    • addConfirmListener

      ConfirmListener addConfirmListener(ConfirmCallback ackCallback, ConfirmCallback nackCallback)
      Add a lambda-based ConfirmListener.
      Parameters:
      ackCallback - callback on ack
      nackCallback - call on nack (negative ack)
      Returns:
      the listener that wraps the callbacks
      See Also:
    • removeConfirmListener

      boolean removeConfirmListener(ConfirmListener listener)
      Remove a ConfirmListener.
      Parameters:
      listener - the listener to remove
      Returns:
      true if the listener was found and removed, false otherwise
    • clearConfirmListeners

      void clearConfirmListeners()
      Remove all ConfirmListeners.
    • getDefaultConsumer

      Consumer getDefaultConsumer()
      Get the current default consumer. @see setDefaultConsumer for rationale.
      Returns:
      an interface to the current default consumer.
    • setDefaultConsumer

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

      void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException
      Request specific "quality of service" settings.

      These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

      Note the prefetch count must be between 0 and 65535 (unsigned short in AMQP 0-9-1).

      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:
    • basicQos

      void basicQos(int prefetchCount, boolean global) throws IOException
      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).

      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:
    • basicQos

      void basicQos(int prefetchCount) throws IOException
      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).

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicPublish

      void basicPublish(String exchange, String routingKey, AMQP.BasicProperties props, byte[] body) throws IOException
      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.
      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:
    • basicPublish

      void basicPublish(String exchange, String routingKey, boolean mandatory, AMQP.BasicProperties props, byte[] body) throws IOException
      Publish a message. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.
      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:
    • basicPublish

      void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, AMQP.BasicProperties props, byte[] body) throws IOException
      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.
      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:
    • exchangeDeclare

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, String type) throws IOException
      Actively declare a non-autodelete, non-durable exchange with no extra arguments
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclare

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, BuiltinExchangeType type) throws IOException
      Actively declare a non-autodelete, non-durable exchange with no extra arguments
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclare

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable) throws IOException
      Actively declare a non-autodelete exchange with no extra arguments
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      durable - true if we are declaring a durable exchange (the exchange will survive a server restart)
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclare

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable) throws IOException
      Actively declare a non-autodelete exchange with no extra arguments
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      durable - true if we are declaring a durable exchange (the exchange will survive a server restart)
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclare

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

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

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments) throws IOException
      Declare an exchange, via an interface that allows the complete set of arguments.
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      durable - true if we are declaring a durable exchange (the exchange will survive a server restart)
      autoDelete - true if the server should delete the exchange when it is no longer in use
      internal - true if the exchange is internal, i.e. can't be directly published to by a client.
      arguments - other properties (construction arguments) for the exchange
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclare

      AMQP.Exchange.DeclareOk exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments) throws IOException
      Declare an exchange, via an interface that allows the complete set of arguments.
      Parameters:
      exchange - the name of the exchange
      type - the exchange type
      durable - true if we are declaring a durable exchange (the exchange will survive a server restart)
      autoDelete - true if the server should delete the exchange when it is no longer in use
      internal - true if the exchange is internal, i.e. can't be directly published to by a client.
      arguments - other properties (construction arguments) for the exchange
      Returns:
      a declaration-confirm method to indicate the exchange was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeclareNoWait

      void exchangeDeclareNoWait(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments) throws IOException
      Like 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).
      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

      void exchangeDeclareNoWait(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String,Object> arguments) throws IOException
      Like 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).
      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
    • exchangeDeclarePassive

      AMQP.Exchange.DeclareOk exchangeDeclarePassive(String name) throws IOException
      Declare an exchange passively; that is, check if the named exchange exists.
      Parameters:
      name - 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

      AMQP.Exchange.DeleteOk exchangeDelete(String exchange, boolean ifUnused) throws IOException
      Delete an exchange
      Parameters:
      exchange - the name of the exchange
      ifUnused - true to indicate that the exchange is only to be deleted if it is unused
      Returns:
      a deletion-confirm method to indicate the exchange was successfully deleted
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeDeleteNoWait

      void exchangeDeleteNoWait(String exchange, boolean ifUnused) throws IOException
      Like exchangeDelete(String, boolean) but sets nowait parameter to true and returns void (as there will be no response from the server).
      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:
    • exchangeDelete

      AMQP.Exchange.DeleteOk exchangeDelete(String exchange) throws IOException
      Delete an exchange, without regard for whether it is in use or not
      Parameters:
      exchange - the name of the exchange
      Returns:
      a deletion-confirm method to indicate the exchange was successfully deleted
      Throws:
      IOException - if an error is encountered
      See Also:
    • exchangeBind

      AMQP.Exchange.BindOk exchangeBind(String destination, String source, String routingKey) throws IOException
      Bind an exchange to an exchange, with no extra arguments.
      Parameters:
      destination - the name of the exchange to which messages flow across the binding
      source - the name of the exchange from which messages flow across the binding
      routingKey - the 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:
    • exchangeBind

      AMQP.Exchange.BindOk exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments) throws IOException
      Bind an exchange to an exchange.
      Parameters:
      destination - the name of the exchange to which messages flow across the binding
      source - the name of the exchange from which messages flow across the binding
      routingKey - the 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:
    • exchangeBindNoWait

      void exchangeBindNoWait(String destination, String source, String routingKey, Map<String,Object> arguments) throws IOException
      Like 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).
      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
    • exchangeUnbind

      AMQP.Exchange.UnbindOk exchangeUnbind(String destination, String source, String routingKey) throws IOException
      Unbind an exchange from an exchange, with no extra arguments.
      Parameters:
      destination - the name of the exchange to which messages flow across the binding
      source - the name of the exchange from which messages flow across the binding
      routingKey - the 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:
    • exchangeUnbind

      AMQP.Exchange.UnbindOk exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments) throws IOException
      Unbind an exchange from an exchange.
      Parameters:
      destination - the name of the exchange to which messages flow across the binding
      source - the name of the exchange from which messages flow across the binding
      routingKey - the 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:
    • exchangeUnbindNoWait

      void exchangeUnbindNoWait(String destination, String source, String routingKey, Map<String,Object> arguments) throws IOException
      Same as 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).
      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

      AMQP.Queue.DeclareOk queueDeclare() throws IOException
      Actively declare a server-named exclusive, autodelete, non-durable queue. The name of the new queue is held in the "queue" field of the AMQP.Queue.DeclareOk result.
      Returns:
      a declaration-confirm method to indicate the queue was successfully declared
      Throws:
      IOException - if an error is encountered
      See Also:
    • queueDeclare

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

      void queueDeclareNoWait(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String,Object> arguments) throws IOException
      Like 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).
      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

      AMQP.Queue.DeclareOk queueDeclarePassive(String queue) throws IOException
      Declare a queue passively; i.e., check if it exists. In AMQP 0-9-1, all arguments aside from nowait are ignored; and sending nowait makes this method a no-op, so we default it to false.
      Parameters:
      queue - the name of the queue
      Returns:
      a declaration-confirm method to indicate the queue exists
      Throws:
      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:
    • queueDelete

      AMQP.Queue.DeleteOk queueDelete(String queue) throws IOException
      Delete a queue, without regard for whether it is in use or has messages on it
      Parameters:
      queue - the name of the queue
      Returns:
      a deletion-confirm method to indicate the queue was successfully deleted
      Throws:
      IOException - if an error is encountered
      See Also:
    • queueDelete

      AMQP.Queue.DeleteOk queueDelete(String queue, boolean ifUnused, boolean ifEmpty) throws IOException
      Delete a queue
      Parameters:
      queue - the name of the queue
      ifUnused - true if the queue should be deleted only if not in use
      ifEmpty - true if the queue should be deleted only if empty
      Returns:
      a deletion-confirm method to indicate the queue was successfully deleted
      Throws:
      IOException - if an error is encountered
      See Also:
    • queueDeleteNoWait

      void queueDeleteNoWait(String queue, boolean ifUnused, boolean ifEmpty) throws IOException
      Like queueDelete(String, boolean, boolean) but sets nowait parameter to true and returns nothing (as there will be no response from the server).
      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:
    • queueBind

      AMQP.Queue.BindOk queueBind(String queue, String exchange, String routingKey) throws IOException
      Bind a queue to an exchange, with no extra arguments.
      Parameters:
      queue - the name of the queue
      exchange - the name of the exchange
      routingKey - the 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:
    • queueBind

      AMQP.Queue.BindOk queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments) throws IOException
      Bind a queue to an exchange.
      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:
    • queueBindNoWait

      void queueBindNoWait(String queue, String exchange, String routingKey, Map<String,Object> arguments) throws IOException
      Same as 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).
      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

      AMQP.Queue.UnbindOk queueUnbind(String queue, String exchange, String routingKey) throws IOException
      Unbinds a queue from an exchange, with no extra arguments.
      Parameters:
      queue - the name of the queue
      exchange - the name of the exchange
      routingKey - the 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:
    • queueUnbind

      AMQP.Queue.UnbindOk queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments) throws IOException
      Unbind a queue from an exchange.
      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:
    • queuePurge

      AMQP.Queue.PurgeOk queuePurge(String queue) throws IOException
      Purges the contents of the given queue.
      Parameters:
      queue - the name of the queue
      Returns:
      a purge-confirm method if the purge was executed successfully
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicGet

      GetResponse basicGet(String queue, boolean autoAck) throws IOException
      Retrieve a message from a queue using AMQP.Basic.Get
      Parameters:
      queue - the name of the queue
      autoAck - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
      Returns:
      a GetResponse containing the retrieved message data
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicAck

      void basicAck(long deliveryTag, boolean multiple) throws IOException
      Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.
      Parameters:
      deliveryTag - the tag from the received AMQP.Basic.GetOk or AMQP.Basic.Deliver
      multiple - true to acknowledge all messages up to and including the supplied delivery tag; false to acknowledge just the supplied delivery tag.
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicNack

      void basicNack(long deliveryTag, boolean multiple, boolean requeue) throws IOException
      Reject one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.GetOk method containing the message to be rejected.
      Parameters:
      deliveryTag - the tag from the received AMQP.Basic.GetOk or AMQP.Basic.Deliver
      multiple - true to reject all messages up to and including the supplied delivery tag; false to reject just the supplied delivery tag.
      requeue - true if the rejected message(s) should be requeued rather than discarded/dead-lettered
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicReject

      void basicReject(long deliveryTag, boolean requeue) throws IOException
      Reject a message. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being rejected.
      Parameters:
      deliveryTag - the tag from the received AMQP.Basic.GetOk or AMQP.Basic.Deliver
      requeue - true if the rejected message should be requeued rather than discarded/dead-lettered
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicConsume

      String basicConsume(String queue, Consumer callback) throws IOException
      Start a non-nolocal, non-exclusive consumer, with explicit acknowledgement and a server-generated consumerTag.
      Parameters:
      queue - the name of the queue
      callback - an interface to the consumer object
      Returns:
      the consumerTag generated by the server
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicConsume

      String basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, Consumer callback) throws IOException
      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
      Parameters:
      queue - the name of the queue
      autoAck - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
      callback - an interface to the consumer object
      Returns:
      the consumerTag generated by the server
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, Consumer callback) throws IOException
      Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and specified arguments.
      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:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, Consumer callback) throws IOException
      Start a non-nolocal, non-exclusive consumer.
      Parameters:
      queue - the name of the queue
      autoAck - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
      consumerTag - a client-generated consumer tag to establish context
      callback - an interface to the consumer object
      Returns:
      the consumerTag associated with the new consumer
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, Consumer callback) throws IOException
      Start a consumer. Calls the consumer's Consumer.handleConsumeOk(java.lang.String) method.
      Parameters:
      queue - the name of the queue
      autoAck - true if the server should consider messages acknowledged once delivered; false if the server should expect explicit acknowledgements
      consumerTag - a client-generated consumer tag to establish context
      noLocal - True if the server should not deliver to this consumer messages published on this channel's connection. Note that the RabbitMQ server does not support this flag.
      exclusive - true if this is an exclusive consumer
      callback - an interface to the consumer object
      arguments - a set of arguments for the consume
      Returns:
      the consumerTag associated with the new consumer
      Throws:
      IOException - if an error is encountered
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicConsume

      String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String,Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException
      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.
      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
      Since:
      5.0
      See Also:
    • basicCancel

      void basicCancel(String consumerTag) throws IOException
      Cancel a consumer. Calls the consumer's Consumer.handleCancelOk(java.lang.String) method.
      Parameters:
      consumerTag - a client- or server-generated consumer tag to establish context
      Throws:
      IOException - if an error is encountered, or if the consumerTag is unknown
      See Also:
    • basicRecover

      AMQP.Basic.RecoverOk basicRecover() throws IOException

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

      Equivalent to calling basicRecover(true), messages will be requeued and possibly delivered to a different consumer.
      Throws:
      IOException
      See Also:
    • basicRecover

      AMQP.Basic.RecoverOk basicRecover(boolean requeue) throws IOException
      Ask the broker to resend unacknowledged messages. In 0-8 basic.recover is asynchronous; in 0-9-1 it is synchronous, and the new, deprecated method basic.recover_async is asynchronous.
      Parameters:
      requeue - If true, messages will be requeued and possibly delivered to a different consumer. If false, messages will be redelivered to the same consumer.
      Throws:
      IOException
    • txSelect

      AMQP.Tx.SelectOk txSelect() throws IOException
      Enables TX mode on this channel.
      Returns:
      a transaction-selection method to indicate the transaction was successfully initiated
      Throws:
      IOException - if an error is encountered
      See Also:
    • txCommit

      AMQP.Tx.CommitOk txCommit() throws IOException
      Commits a TX transaction on this channel.
      Returns:
      a transaction-commit method to indicate the transaction was successfully committed
      Throws:
      IOException - if an error is encountered
      See Also:
    • txRollback

      AMQP.Tx.RollbackOk txRollback() throws IOException
      Rolls back a TX transaction on this channel.
      Returns:
      a transaction-rollback method to indicate the transaction was successfully rolled back
      Throws:
      IOException - if an error is encountered
      See Also:
    • confirmSelect

      AMQP.Confirm.SelectOk confirmSelect() throws IOException
      Enables publisher acknowledgements on this channel.
      Throws:
      IOException - if an error is encountered
      See Also:
    • getNextPublishSeqNo

      long getNextPublishSeqNo()
      When in confirm mode, returns the sequence number of the next message to be published.
      Returns:
      the sequence number of the next message to be published
    • waitForConfirms

      boolean waitForConfirms() throws 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.
      Returns:
      whether all the messages were ack'd (and none were nack'd)
      Throws:
      IllegalStateException
      InterruptedException
    • waitForConfirms

      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.
      Returns:
      whether all the messages were ack'd (and none were nack'd)
      Throws:
      IllegalStateException
      InterruptedException
      TimeoutException
    • waitForConfirmsOrDie

      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.
      Throws:
      IllegalStateException
      IOException
      InterruptedException
    • waitForConfirmsOrDie

      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.
      Throws:
      IllegalStateException
      IOException
      InterruptedException
      TimeoutException
    • asyncRpc

      void asyncRpc(Method method) throws IOException
      Asynchronously send a method over this channel.
      Parameters:
      method - method to transmit over this channel.
      Throws:
      IOException - Problem transmitting method.
    • rpc

      Command rpc(Method method) throws IOException
      Synchronously send a method over this channel.
      Parameters:
      method - method to transmit over this channel.
      Returns:
      command response to method. Caller should cast as appropriate.
      Throws:
      IOException - Problem transmitting method.
    • messageCount

      long messageCount(String queue) throws IOException
      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.
      Parameters:
      queue - the name of the queue
      Returns:
      the number of messages in ready state
      Throws:
      IOException - Problem transmitting method.
    • consumerCount

      long consumerCount(String queue) throws IOException
      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.
      Parameters:
      queue - the name of the queue
      Returns:
      the number of consumers
      Throws:
      IOException - Problem transmitting method.
    • asyncCompletableRpc

      CompletableFuture<Command> asyncCompletableRpc(Method method) throws IOException
      Asynchronously send a method over this 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.