RabbitMQ之basicConsume、basicCancel、basicPublish等方法详解

已于 2022-05-27 15:44:05 修改
阅读量2.6w 收藏 101
点赞数 19
分类专栏： 【RabbitMQ系列】 文章标签： RabbitMQ basicConsume basicCancel basicPublish
于 2019-10-19 11:34:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaomingyang/article/details/102636657
版权

最新版5.7.3提供了20个basicConsume消费方法，这些方法是由服务端主动PUSH消息过来，方法接收到消息后进行处理；而每个方法处理接收到的消息相差不大，下面详细介绍每个方法的参数详情；

1.String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)
   /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
            System.out.println("调用"+consumerTag);
        });
2.String basicConsume(String queue, boolean autoAck, Consumer callback)
  /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * callback: 消费者对象的回调接口
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel){});

使用接口com.rabbitmq.client.Consumer的实现类com.rabbitmq.client.DefaultConsumer实现自定义消息监听器，接口中有多个不同的方法可以根据自己系统的需要实现；

3.String basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
/**
         * queue:队列名
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, deliverCallback, consumerTag -> {}, (consumerTag, sig) -> {});
4.String basicConsume(String queue, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
/**
         * queue:队列名
         * deliverCallback： 当一个消息发送过来后的回调接口
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, deliverCallback, (consumerTag, sig) -> {});
5.String basicConsume(String queue, DeliverCallback deliverCallback, CancelCallback cancelCallback)
 /**
         * queue:队列名
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, deliverCallback, consumerTag -> {});
6.String basicConsume(String queue, Consumer callback)
  /**
         * queue:队列名
         * callback: 消费者对象的回调接口
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, new DefaultConsumer(channel){});
7.String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
 /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * deliverCallback： 当一个消息发送过来后的回调接口
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, (consumerTag, sig)->{
            //consumerTag服务端生成的消费者标识
            //sig(ShutdownSignalException):说明关闭的原因
        });
8.String basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
 /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag->{
            //consumerTag:服务端小费制标识
        }, (consumerTag, sig) -> {
            //consumerTag服务端生成的消费者标识
            //sig(ShutdownSignalException):说明关闭的原因
        });
9.String basicConsume(String queue, boolean autoAck, Map<String, Object> arguments, Consumer callback)
  /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * arguments: 消费的一组参数
         * callback：消费者对象接口
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, arguments, new DefaultConsumer(channel){
          //根据需要实现对应的方法
        });
10.String basicConsume(String queue, boolean autoAck, Map<String, Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback)
 /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * arguments: 消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, arguments, deliverCallback, consumerTag -> {});
11.String basicConsume(String queue, boolean autoAck, Map<String, Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
/**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * arguments: 消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, arguments, deliverCallback, (consumerTag, sig) -> {});
12.String basicConsume(String queue, boolean autoAck, Map<String, Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
 /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * arguments: 消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 服务端生成的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, arguments, deliverCallback, consumerTag -> {}, (consumerTag, sig) -> {});
13.String basicConsume(String queue, boolean autoAck, String consumerTag, Consumer callback)
 /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag: 客户端生成的用于建立上线文的使用者标识
         * callback：消费者对象接口
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, new DefaultConsumer(channel){
            //根据需要实现具体的方法
        });
14.String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback)
  /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, deliverCallback, consumerTag -> {});
15.String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
/**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * deliverCallback： 当一个消息发送过来后的回调接口
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, deliverCallback, (consumerTag, sig) -> {});
16.String basicConsume(String queue, boolean autoAck, String consumerTag, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
  /**
         * 启动一个消费者，并返回服务端生成的消费者标识
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, deliverCallback, consumerTag -> {}, (consumerTag, sig) -> {});
17.String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String, Object> arguments, Consumer callback)
 /**
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * nolocal:如果服务器不应将在此通道连接上发布的消息传递给此使用者，则为true;请注意RabbitMQ服务器上不支持此标记
         * exclusive: 如果是单个消费者，则为true
         * callback:消费者对象接口
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, false, false, arguments, new DefaultConsumer(channel){
            //根据需求实现方法
        });
18.String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String, Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback)
 /**
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * nolocal:如果服务器不应将在此通道连接上发布的消息传递给此使用者，则为true;请注意RabbitMQ服务器上不支持此标记
         * exclusive: 如果是单个消费者，则为true
         * arguments:消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * @return 与消费者关联的消费者标识
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, false, false, arguments, deliverCallback, consumerTag -> {});
19.String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String, Object> arguments, DeliverCallback deliverCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
 /**
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * nolocal:如果服务器不应将在此通道连接上发布的消息传递给此使用者，则为true;请注意RabbitMQ服务器上不支持此标记
         * exclusive: 如果是单个消费者，则为true
         * arguments:消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, false, false, arguments, deliverCallback, (consumerTag, sig) -> {});
20.String basicConsume(String queue, boolean autoAck, String consumerTag, boolean noLocal, boolean exclusive, Map<String, Object> arguments, DeliverCallback deliverCallback, CancelCallback cancelCallback, ConsumerShutdownSignalCallback shutdownSignalCallback)
	 /**
         * queue:队列名
         * autoAck：true 接收到传递过来的消息后acknowledged（应答服务器），false 接收到消息后不应答服务器
         * consumerTag:客户端生成的一个消费者标识
         * nolocal:如果服务器不应将在此通道连接上发布的消息传递给此使用者，则为true;请注意RabbitMQ服务器上不支持此标记
         * exclusive: 如果是单个消费者，则为true
         * arguments:消费的一组参数
         * deliverCallback： 当一个消息发送过来后的回调接口
         * cancelCallback：当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
         * shutdownSignalCallback: 当channel/connection 关闭后回调
         */
        channel.basicConsume(QUEUE_NAME, true, ctag, false, false, arguments, deliverCallback, consumerTag -> {}, (consumerTag, sig) -> {});
主动拉取队列中的一条消息
GetResponse basicGet(String queue, boolean autoAck)

使用示例：

        /**
         * 从消息队列中取出第一条消息；整个方法的执行过程是首先消费队列，然后检索第一条消息，然后再取消订阅
         */
        GetResponse response = channel.basicGet(QUEUE_NAME, true);
        System.out.println("消费者接收到的消息是："+new String(response.getBody(), "UTF-8"));
取消消费者订阅
/**
* 取消消费者对队列的订阅关系
* consumerTag:服务器端生成的消费者标识
**/
void basicCancel(String consumerTag)
basicQoc设置服务端每次发送给消费者的消息数量
/**
* prefetchSize:服务器传送最大内容量（以八位字节计算），如果没有限制，则为0
* prefetchCount:服务器每次传递的最大消息数，如果没有限制，则为0；
* global:如果为true,则当前设置将会应用于整个Channel(频道)
**/
void basicQos(int prefetchSize, int prefetchCount, boolean global)

/**
* prefetchCount:服务器每次传递的最大消息数，如果没有限制，则为0；
* global:如果为true,则当前设置将会应用于整个Channel(频道)
**/
void basicQos(int prefetchCount, boolean global)

/**
* prefetchCount:服务器每次传递的最大消息数，如果没有限制，则为0；
**/
void basicQos(int prefetchCount)
Acknowledge(确认)收到一个或者多个消息
/**
* 消费者确认收到一个或者多个消息
* deliveryTag：服务器端向消费者推送消息，消息会携带一个deliveryTag参数，也可以成此参数为消息 * 的唯一标识，是一个递增的正整数
* multiple：true表示确认所有消息，包括消息唯一标识小于等于deliveryTag的消息，false只确认 * * deliveryTag指定的消息
**/
void basicAck(long deliveryTag, boolean multiple)

/**
* 要求代理重新发送未确认的消息
* requeue:如果为true,消息将会重新入队，可能会被发送给其它的消费者；如果为false,消息将会发送给* 相同的消费者
**/
Basic.RecoverOk basicRecover(boolean requeue)

/**
* 要求代理重新发送未确认的消息;消息将会重新排队，并且可能会发送给其它的消费者
**/
Basic.RecoverOk basicRecover()
拒绝消息
/**
* 拒绝接收到的一个或者多个消息
* deliveryTag：接收到消息的唯一标识
* multiple: true表示拒绝所有的消息，包括提供的deliveryTag；false表示仅拒绝提供的deliveryTag
* requeue：true 表示拒绝的消息应重新入队，而不是否丢弃
*/
void basicNack(long deliveryTag, boolean multiple, boolean requeue)

/**
* 拒绝接收到的一个或者多个消息
* deliveryTag：接收到消息的唯一标识
* requeue：true 表示拒绝的消息应重新入队，而不是否丢弃
*/
void basicReject(long deliveryTag, boolean requeue)
发送消息
/**
* exchange:要将消息发送到的Exchange(交换器)
* routingKey:路由Key
* mandatory:true 如果mandatory标记被设置
* immediate: true 如果immediate标记被设置，注意：RabbitMQ服务端不支持此标记
* props:其它的一些属性，如：{@link MessageProperties.PERSISTENT_TEXT_PLAIN}
* body:消息内容
**/
void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)

/**
* 发布消息
* 发布到不存在的交换器将导致信道级协议异常，该协议关闭信道，
* exchange: 要将消息发送到的交换器
* routingKey: 路由KEY
* mandatory:true 如果mandatory标记被设置
* props: 消息的其它属性，如：路由头等
* body: 消息体
*/
void basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)

/**
* 发布消息
* 发布到不存在的交换器将导致信道级协议异常，该协议关闭信道，
* exchange: 要将消息发送到的交换器
* routingKey: 路由KEY
* props: 消息的其它属性，如：路由头等
* body: 消息体
*/
void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)

GitHub地址：https://github.com/mingyang66/spring-parent

立小言先森
关注
  • 19
    点赞
  • 踩
  • 101
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
RabbitMQ基础
DOVISSSS的博客
09-08 1116
RabbitMQ基础
springboot集成rabbitMQ之对象传输的方法
08-28
本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一、RabbitMQ 的安装 RabbitMQ 的安装方法网上有...
关于利用RabbitMQ实现延迟任务的方法详解
10-18
最近在使用RabbitMQ来实现延迟任务的时候发现，这其中的知识点还是挺多的，所以下面这篇文章主要给大家介绍了关于利用RabbitMQ实现延迟任务的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下。
rabbitmq入门
qq_21277357的博客
12-24 1001
遇到mq的消息堆积，可以先把消费者的预取值设置为1，不公平分发，这样一个消费者堆积消息，在开启一个新的消费者来消费消息，这样控制台最终会剩下1条消息没有被消费，这时候在控制台点击get message获取消息，手动处理，然后把这条队列删除掉，这样就可以解决。如果有一个消费者消费快,一个消费者消费慢，那么这时候我想要消费快的那个多干点活，这时候，我们把消费者2宕机，可以看到，消费者1接收到了消息，这就是手动应答。接下来我们在重启mq,可以看到消息也恢复了，这就是消息的持久化。
SimpleAmqpClient 编译使用
最新发布
qq_57283958的博客
04-21 473
下载rabbitmq-c githup源码国内新建build 和 install 安装目录打开CMKAE工具配置点击Configure修改安装目录点击Generate 点击Open Project 或者去Bulid目录下打开生成的rabbitmq-c.sln 原理上一样选择Release版本在编译rabbitmq 和rabbitmq_static在build 目录下打开打开选择Release 在生成install 目录下生成头文件 静态库 和 动态库。
rabbitmq
weixin_41340417的博客
01-29 299
rabbitmq
RabbitMQ(六)：RabbitMQ-消费消息-basicConsume
weixin_40805079的博客
01-02 1万+
转载地址： https://www.jianshu.com/p/df231c152754 RabbitMQ-消费消息 Address[] addresses = new Address[] {new Address(IP_ADDRESS, PORT)}; /** * 1.建立连接工厂 */ Connecti...
RabbitMQ笔记
H35790的博客
03-16 131
RabbitMQ前言一、消息发送流程Rabbitmq的特点二、RabbitMQ安装1.docker命令安装2.RabbitMQ支持的消息模型spring中RabbitMQ的使用三、Springboot方式的RabbitMQ总结 RabbitMQ前言一、消息发送流程Rabbitmq的特点二、RabbitMQ安装1.docker命令安装2.RabbitMQ支持的消息模型spring中RabbitMQ的使用三、Springboot方式的RabbitMQ总结 前言 面向消息的中间件(message-orient
消息队列RabbitMQ入门与5种模式详解
02-24
简介：MQ全称为MessageQueue，消息队列是应用程序和应用程序之间的通信方法；RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统；AMQP（高级消息队列协议）是一个...
SpringBoot之RabbitMQ的使用方法
08-26
SpringBoot之RabbitMQ的使用方法 RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件，消息中间件的工作过程可以用生产者消费者模型来表示。即，生产者不断的向消息队列发送信息...
rabbitMQ消息队列 – consume详解
scaubin711的博客
01-10 4836
##消费者 既然有发送者.自然就有消费者 实现消费者的方法就是 $channel-&gt;basic_consume(“TestQueue”, “”, false, false, false, false, $callback); …我们看具体函数定义 public function basic_consume( $queue = '', $consumer_tag = '', ...
rabbitmq的接口函数说明，api参数使用说明
05-10
rabbitmq的提供的各个接口函数使用说明，函数有 1、amqp_new_connection(声明一个新的connection) 2、amqp_open_socket(获取socket) 3、amqp_set_sockfd(将connection和sockfd进行绑定) 4、amqp_login(用于登录RabbitMQ server，主要目的为了进行权限管理) 5、amqp_channel_open(用于关联conn和channel) 6、amqp_exchange_declare(声明exchange) 7、amqp_queue_declare(声明queue) 8、amqp_queue_bind(声明binding，已经有的绑定直接返回，没有绑定的就会绑定) 9、amqp_basic_qos(控制预取消息数) 10、amqp_basic_consume(指定要接收的队列) 11、amqp_consume_message(接收数据) 12、int amqp_basic_ack(发送ask确认) 13、amqp_basic_reject(拒绝ask) 14、amqp_basic_publish(发布消息) 15、amqp_simple_wait_frame（回调等待服务器的结果返回） 16、amqp_basic_get（客户端主动获取服务器的下一条消息） 17、关闭 18、AE交换机的使用 19、死信交换机的使用
【PHP版】RabbitMQ 消费者参数说明
深漂小码哥
08-15 807
$channel->basic_consume('hello', '', false, true, false, false, $callback); 查看源码 public function basic_consume( $queue = '', $consumer_tag = '', $no_local = false, $no_ack = false, $exclusive = false, .
Rabbitmq—— 从入门到放弃
Take Easy，Work Hard！
07-20 865
本文简单介绍rabbitmq的架构以及使用方案
RabbitMQ中BasicGet与BasicConsume的区别
诚的博客
04-15 3199
在RabbitMQ中消费者有2种方式获取队列中的消息: a)一种是通过basic.consume命令，订阅某一个队列中的消息,channel会自动在处理完上一条消息之后，接收下一条消息。（同一个channel消息处理是串行的）。除非关闭channel或者取消订阅，否则客户端将会一直接收队列的消息。 b)另外一种方式是通过basic.get命令主动获取队列中的消息，但是绝对不可以通过循环...
basic_consume()遇到的问题
qq_34997073的博客
03-28 4681
channel.basic_consume( callback, queue='hello' ) 原本是这样，发现编译器报错，queue缺少关键参数 channel.basic_consume( "hello", callback ) 新版本pika源码默认参数位置发生变化。。。换一下就好了 ...
带你玩转RabbitMQ的五种队列
一心同学的博客
03-24 4153
一篇文章带你玩转RabbitMQ的五种队列，保姆级别讲解五种队列的知识以及应用场景，帮助我们尽快掌握RabbitMQ。
rabbitmq method之basic.consume
weixin_30485799的博客
06-07 291
basic.consume指的是channel在 某个队列上注册消费者,那在这个队列有消息来了之后,就会把消息转发到给此channel处理,如果 这个队列有多个消费者,则会采用轮转的方式将消息分发给消息者. 首先是rabbit_reader接收数据包后,解析组装出其中的method,channel方法交给channel处理.具体过程见http://www.cnblogs.com/haoqingc...
RabbitMQ Consumer获取消息的两种方式(poll,subscribe)解析
热门推荐
云计算、分布式架构、K8S、大数据、机器学习、搜索、推荐、广告
09-01 5万+
Producer和Queue Consumer和Queue 长连接
RabbitMQ中basicConsume的作用
07-16
basicConsume是RabbitMQ中一个用于消费消息的方法。当一个消费者连接到RabbitMQ的队列时，它可以通过调用basicConsume方法来注册自己，以便从队列中接收消息。 基本上，basicConsume方法的作用是告诉RabbitMQ服务器，该消费者想要从指定的队列中接收消息。一旦调用了basicConsume方法，RabbitMQ服务器就会开始将消息推送给该消费者。 当消息到达队列时，RabbitMQ服务器会将消息发送给已注册的消费者。消费者可以通过提供一个回调函数来处理接收到的消息。在回调函数中，消费者可以执行任何需要的操作，例如处理消息、存储数据或者发送回复。 需要注意的是，basicConsume方法是一个阻塞调用，这意味着它会一直等待直到有新的消息到达队列。因此，在调用basicConsume方法之后，通常需要一个循环来持续接收消息，直到消费者主动停止或者连接关闭。 总结起来，basicConsume方法的作用是注册一个消费者并开始从队列中接收消息。它是建立RabbitMQ消息消费者的重要步骤之一。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值