欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

rabbitmq 学习-10-channel 说明

程序员文章站 2022-07-13 15:47:16
...

rabbitmq java api 关于消息处理的一个重要的类是channel
channel 主要进行相关定义,发送消息,获取消息,事务处理等。
channel可以在多线程中使用,但是在任何时候保证只有一个线程执行命令是很重要的,这在前面 rabbitmq 学习-6-rabbitmq基础
已经说的很清楚了。

public interface Channel extends ShutdownNotifier {

// 重新得到channel number
int getChannelNumber();

//得到当前channel的connection
Connection getConnection();

//关闭 channel,closeCode=com.rabbitmq.client.AMQP#REPLY_SUCCESS,closeMessage='OK'
void close() throws IOException;

//指定code和message关闭channel
void close(int closeCode, String closeMessage) throws IOException;

 //中止 channel,closeCode=com.rabbitmq.client.AMQP#REPLY_SUCCESS,closeMessage='OK'
 //此操作中的所有异常将被丢弃
void abort() throws IOException;

//指定code和message中止channel
//此操作中的所有异常将被丢弃
void abort(int closeCode, String closeMessage) throws IOException;

//得到当前channel的ReturnListener
ReturnListener getReturnListener();

//设置当前channel的ReturnListener
void setReturnListener(ReturnListener listener);

/**
 * Request specific "quality of service" settings.
 *
 * These settings impose limits on the amount of data the server
 * will deliver to consumers before requiring the receipt of
 * acknowledgements.
 * Thus they provide a means of consumer-initiated flow control.
 * @see com.rabbitmq.client.AMQP.Basic.Qos
 * @param prefetchSize maximum amount of content (measured in
 * octets) that the server will deliver, 0 if unlimited
 * @param prefetchCount maximum number of messages that the server
 * will deliver, 0 if unlimited
 * @param global true if the settings should be applied to the
 * entire connection rather than just the current channel
 * @throws java.io.IOException if an error is encountered
 */
void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException;

/**
 * Request a specific prefetchCount "quality of service" settings
 * for this channel.
 *
 * @see #basicQos(int, int, boolean)
 * @param prefetchCount maximum number of messages that the server
 * will deliver, 0 if unlimited
 * @throws java.io.IOException if an error is encountered
 */
void basicQos(int prefetchCount) throws IOException;

//发送消息,"mandatory" and "immediate" 都是 false
void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;

/**
 * 发送消息
 * @param exchange名称
 * @param routingKey名称
 * @param mandatory 是否强制发送
 * @param immediate 是否立即发送
 * @param props other properties for the message - routing headers etc
 * @param body 消息
 * @throws java.io.IOException if an error is encountered
 */
void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)
        throws IOException;

/**
 * 删除exchange,不管是否在使用
 * @param exchange名称
 * @return a deletion-confirm method to indicate the exchange was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Exchange.DeleteOk exchangeDelete(String exchange) throws IOException;

/**
 * 删除exchange
 * @param exchange名称
 * @param ifUnused 设置是否只删除没有使用的
 * @return a deletion-confirm method to indicate the exchange was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Exchange.DeleteOk exchangeDelete(String exchange, boolean ifUnused) throws IOException;

/**
 * 定义exchange,non-autodelete, non-durable
 * @param exchange名称
 * @param exchange类型
 * @return a deletion-confirm method to indicate the exchange was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Exchange.DeclareOk exchangeDeclare(String exchange, String type) throws IOException;

/**
 * 定义exchange,non-autodelete
 * @param exchange名称
 * @param exchange类型
 * @param durable 是否持续存在(持续存在,即使server重启也会存在)
 * @throws java.io.IOException if an error is encountered
 * @return a declaration-confirm method to indicate the exchange was successfully declared
 */
Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable) throws IOException;

/**
 * 定义exchange
 * @param exchange名称
 * @param exchange类型
 * @param passive true if we are passively declaring a exchange (asserting the exchange already exists)
 * @param durable 是否持续存在(持续存在,即使server重启也会存在)
 * @param autoDelete 是否自动删除,自动删除-server会在它不在使用的时候将其删除
 * @param arguments other properties (construction arguments) for the exchange
 * @return a declaration-confirm method to indicate the exchange was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean passive, boolean durable, boolean autoDelete,
                                   Map<String, Object> arguments) throws IOException;

/**
 * 定义一个queue,由server去命名,exclusive, autodelete, non-durable
 * @return a declaration-confirm method to indicate the exchange was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeclareOk queueDeclare() throws IOException;

/**
 * 定义一个queue,non-exclusive, non-autodelete, non-durable
 * @param queue 名称
 * @return a declaration-confirm method to indicate the queue was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeclareOk queueDeclare(String queue) throws IOException;

/**
 * 定义一个queue,non-exclusive, non-autodelete
 * @param queue 名称
 * @param durable 是否持续存在(true:server重启也会存在)
 * @return a declaration-confirm method to indicate the exchange was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeclareOk queueDeclare(String queue, boolean durable) throws IOException;

/**
 * 定义一个queue
 * @param queue 名称
 * @param passive true if we are passively declaring a queue (asserting the queue already exists)
 * @param durable 是否持续存在
 * @param exclusive true if we are declaring an exclusive queue
 * @param autoDelete 是否自动删除,true:不在使用了server将会自动删除它
 * @param arguments other properties (construction arguments) for the queue
 * @return a declaration-confirm method to indicate the queue was successfully declared
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeclareOk queueDeclare(String queue, boolean passive, boolean durable, boolean exclusive, boolean autoDelete,
                             Map<String, Object> arguments) throws IOException;

/**
 * 删除queue,不管它是否在使用
 * @param queue 名称
 * @return a deletion-confirm method to indicate the queue was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeleteOk queueDelete(String queue) throws IOException;

/**
 * 删除queue
 * @param queue 名称
 * @param ifUnused 是否只删除没有被使用的queue
 * @param ifEmpty 是否只删除消息是空的queue
 * @return a deletion-confirm method to indicate the queue was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Queue.DeleteOk queueDelete(String queue, boolean ifUnused, boolean ifEmpty) throws IOException;

/**
 * 使用routingKey将queue绑定到exchange上
 * @param queue 名称
 * @param exchange the name of the exchange
 * @param routingKey the routine key to use for the binding
 * @return a binding-confirm method if the binding was successfully created
 * @throws java.io.IOException if an error is encountered
 */
Queue.BindOk queueBind(String queue, String exchange, String routingKey) throws IOException;

/**
 * 使用routingKey将queue绑定到exchange上,带参数
 * @param queue the name of the queue
 * @param exchange the name of the exchange
 * @param routingKey the routine key to use for the binding
 * @param arguments other properties (binding parameters)
 * @return a binding-confirm method if the binding was successfully created
 * @throws java.io.IOException if an error is encountered
 */
Queue.BindOk queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments) throws IOException;

/**
 * 解除绑定
 * @param queue the name of the queue
 * @param exchange the name of the exchange
 * @param routingKey the routine key to use for the binding
 * @return an unbinding-confirm method if the binding was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Queue.UnbindOk queueUnbind(String queue, String exchange, String routingKey) throws IOException;

/**
 * 解除绑定,带参数
 * @param queue the name of the queue
 * @param exchange the name of the exchange
 * @param routingKey the routine key to use for the binding
 * @param arguments other properties (binding parameters)
 * @return an unbinding-confirm method if the binding was successfully deleted
 * @throws java.io.IOException if an error is encountered
 */
Queue.UnbindOk queueUnbind(String queue, String exchange, String routingKey, Map<String, Object> arguments) throws IOException;

/**
 * Purges the contents of the given queue and awaits a completion.
 * @see com.rabbitmq.client.AMQP.Queue.Purge
 * @see com.rabbitmq.client.AMQP.Queue.PurgeOk
 * @param queue the name of the queue
 * @return a purge-confirm method if the purge was executed succesfully
 * @throws java.io.IOException if an error is encountered
 */
Queue.PurgeOk queuePurge(String queue) throws IOException;

/**
 * Purges the contents of the given queue.
 * @see com.rabbitmq.client.AMQP.Queue.Purge
 * @see com.rabbitmq.client.AMQP.Queue.PurgeOk
 * @param queue the name of the queue
 * @param nowait whether to await completion of the purge
 * @return a purge-confirm method if the purge was executed succesfully
 * @throws java.io.IOException if an error is encountered
 */
Queue.PurgeOk queuePurge(String queue, boolean nowait) throws IOException;

/**
 * 从queue上取消息
 * @param queue the name of the queue
 * @param noAck true if no handshake is required
 * @return a {@link GetResponse} containing the retrieved message data
 * @throws java.io.IOException if an error is encountered
 */
GetResponse basicGet(String queue, boolean noAck) throws IOException;

/**
 * Acknowledge one or several received
 * messages. Supply the deliveryTag from the {@link com.rabbitmq.client.AMQP.Basic.GetOk}
 * or {@link com.rabbitmq.client.AMQP.Basic.Deliver} method
 * containing the received message being acknowledged.
 * @see com.rabbitmq.client.AMQP.Basic.Ack
 * @param deliveryTag the tag from the received {@link com.rabbitmq.client.AMQP.Basic.GetOk} or {@link com.rabbitmq.client.AMQP.Basic.Deliver}
 * @param multiple true if we are acknowledging multiple messages with the same delivery tag
 * @throws java.io.IOException if an error is encountered
 */
void basicAck(long deliveryTag, boolean multiple) throws IOException;

/**
 * Start a non-nolocal, non-exclusive consumer, with
 * explicit acknowledgements required and a server-generated consumerTag.
 * @param queue the name of the queue
 * @param callback an interface to the consumer object
 * @return the consumerTag generated by the server
 * @throws java.io.IOException if an error is encountered
 * @see com.rabbitmq.client.AMQP.Basic.Consume
 * @see com.rabbitmq.client.AMQP.Basic.ConsumeOk
 * @see #basicAck
 * @see #basicConsume(String,boolean, String,boolean,boolean, Consumer)
 */
String basicConsume(String queue, Consumer callback) throws IOException;

/**
 * Start a non-nolocal, non-exclusive consumer, with
 * a server-generated consumerTag.
 * @param queue the name of the queue
 * @param noAck true if no handshake is required
 * @param callback an interface to the consumer object
 * @return the consumerTag generated by the server
 * @throws java.io.IOException if an error is encountered
 * @see com.rabbitmq.client.AMQP.Basic.Consume
 * @see com.rabbitmq.client.AMQP.Basic.ConsumeOk
 * @see #basicConsume(String,boolean, String,boolean,boolean, Consumer)
 */
String basicConsume(String queue, boolean noAck, Consumer callback) throws IOException;

/**
 * Start a non-nolocal, non-exclusive consumer.
 * @param queue the name of the queue
 * @param noAck true if no handshake is required
 * @param consumerTag a client-generated consumer tag to establish context
 * @param callback an interface to the consumer object
 * @return the consumerTag associated with the new consumer
 * @throws java.io.IOException if an error is encountered
 * @see com.rabbitmq.client.AMQP.Basic.Consume
 * @see com.rabbitmq.client.AMQP.Basic.ConsumeOk
 * @see #basicConsume(String,boolean, String,boolean,boolean, Consumer)
 */
String basicConsume(String queue, boolean noAck, String consumerTag, Consumer callback) throws IOException;

/**
 * Start a consumer. Calls the consumer's {@link Consumer#handleConsumeOk}
 * method before returning.
 * @param queue the name of the queue
 * @param noAck true if no handshake is required
 * @param consumerTag a client-generated consumer tag to establish context
 * @param noLocal flag set to true unless server local buffering is required
 * @param exclusive true if this is an exclusive consumer
 * @param callback an interface to the consumer object
 * @return the consumerTag associated with the new consumer
 * @throws java.io.IOException if an error is encountered
 * @see com.rabbitmq.client.AMQP.Basic.Consume
 * @see com.rabbitmq.client.AMQP.Basic.ConsumeOk
 */
String basicConsume(String queue, boolean noAck, String consumerTag, boolean noLocal, boolean exclusive, Consumer callback) throws IOException;

/**
 * Cancel a consumer. Calls the consumer's {@link Consumer#handleCancelOk}
 * method before returning.
 * @param consumerTag a client- or server-generated consumer tag to establish context
 * @throws java.io.IOException if an error is encountered
 * @see com.rabbitmq.client.AMQP.Basic.Cancel
 * @see com.rabbitmq.client.AMQP.Basic.CancelOk
 */
void basicCancel(String consumerTag) 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.
 * To avoid this API changing, this is named for the latter, and
 * will be deprecated.
 * @param requeue If true, messages will be requeued and possibly
 * delivered to a different consumer. If false, messages will be
 * redelivered to the same consumer.
 */
void basicRecoverAsync(boolean requeue) throws IOException;

/**
 * 启用事务模式
 * @return a transaction-selection method to indicate the transaction was successfully initiated
 * @throws java.io.IOException if an error is encountered
 */
Tx.SelectOk txSelect() throws IOException;

/**
 * 提交事务
 * @return a transaction-commit method to indicate the transaction was successfully committed
 * @throws java.io.IOException if an error is encountered
 */
Tx.CommitOk txCommit() throws IOException;

/**
 * 回流事务
 * @return a transaction-rollback method to indicate the transaction was successfully rolled back
 * @throws java.io.IOException if an error is encountered
 */
Tx.RollbackOk txRollback() throws IOException;
}

相关标签: rabbitmq