二、RabbitMQ不同模型样例

最新推荐文章于 2024-08-04 22:57:13 发布
最新推荐文章于 2024-08-04 22:57:13 发布
阅读量99 收藏
点赞数
分类专栏： RabbitMQ 文章标签： 交换机 队列 rabbitmq java 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/endless_fighting/article/details/116226947
版权

文章目录

RabbitMQ不同模型样例

这篇样例代码都是基于这个包

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.10.0</version>
</dependency>

工作队列—轮询策略样例

  • 轮询策略

    生产端能力大于消费端能力，增加多几个消费节点

    缺点：如果某个消费端消费能力不足处理时间过长会导致一个消息使用卡在那里等他消费完才会去找其他的消费节点，如同一个消费阻塞在那里其他节点在旁边干看着帮不上。

    // 消费者代码 一共写两个消费者代码 
public class Recv1 {

    private final static String QUEUE_NAME = "work_mq";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        // 连接信息
        factory.setHost("20.18.24.143");
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("devTest");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 消费
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);

                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 一般固定，一般称为会话名称
                /*System.out.println("consumerTag: "+consumerTag);
                // 可以获取交换机、路由键等信息
                System.out.println("envelope: "+envelope);
                //
                System.out.println("properties: "+properties);*/
                //
                System.out.println("body: "+new String(body,"utf-8"));

                // 手工确认消息，不是多条确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

    }

}

    // 生产者代码 为测试轮询需要发送多条消息 做了10次发送
public class Send {

    // 队列名称
    private final static String QUEUE_NAME = "work_mq";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        // 连接信息
        factory.setHost("20.18.24.143");
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("devTest");
        factory.setPort(5672);

        // 继承
        try (Connection connection = factory.newConnection();
             // 创建信道
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            // 循环 发送10次消息
            for (int i = 0; i < 10; i++) {
                String message = "Work_Mq Test"+i;
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'");
            }

        }
    }

}

    运行结果：

    #消费端1 打印结果
body: Work_Mq Test0
body: Work_Mq Test2
body: Work_Mq Test4
body: Work_Mq Test6
body: Work_Mq Test8
#消费端2 打印结果
body: Work_Mq Test1
body: Work_Mq Test3
body: Work_Mq Test5
body: Work_Mq Test7
body: Work_Mq Test9

工作队列—公平策略样例

  • 公平策略

    解决消费端消费能力不足的问题，降低消费时间

    代码如下：

    // 消费者代码 一共写两个消费者代码 一个Recv1一个Recv2区别仅在手动sleep的时间上
public class Recv1 {

    private final static String QUEUE_NAME = "work_mq_fair";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        // 连接信息
        factory.setHost("20.18.24.143");
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("devTest");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 限制消费，每次消费一个，消费完成在进行下一个
        channel.basicQos(1);

        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 消费
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);

                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 一般固定，一般称为会话名称
               /* System.out.println("consumerTag: "+consumerTag);
                // 可以获取交换机、路由键等信息
                System.out.println("envelope: "+envelope);
                //
                System.out.println("properties: "+properties);*/
                //
                System.out.println("body: "+new String(body,"utf-8"));

                // 手工确认消息，不是多条确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(QUEUE_NAME,false,consumer);

    }

}

    // 生产者代码
public class Send {

    // 队列名称
    private final static String QUEUE_NAME = "work_mq_fair";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        // 连接信息
        factory.setHost("20.18.24.143");
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("devTest");
        factory.setPort(5672);

        // 继承
        try (Connection connection = factory.newConnection();
             // 创建信道
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            // 循环 发送10次消息
            for (int i = 0; i < 10; i++) {
                String message = "work_mq_fair Test"+i;
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
                System.out.println(" [x] Sent '" + message + "'");
            }

        }
    }

}

    运行结果：

    // 消费者1 打印结果
[*] Waiting for messages. To exit press CTRL+C
body: work_mq_fair Test0
body: work_mq_fair Test4
body: work_mq_fair Test7
// 消费者2 打印结果
[*] Waiting for messages. To exit press CTRL+C
body: work_mq_fair Test1
body: work_mq_fair Test2
body: work_mq_fair Test3
body: work_mq_fair Test5
body: work_mq_fair Test6
body: work_mq_fair Test8
body: work_mq_fair Test9
#手动设置了不同的sleep时间来模拟不同消费能力，体现公平策略
#我这里设置消费者1 sleep 5 秒 消费者2 sleep 2秒

工作队列—发布 订阅模型

什么是rabbitmq的发布订阅模式？

  • 发布-订阅模型中，消息生产者不再是直接面对queue(队列名称)，而是直面exchange,都需要经过exchange来进行消息的发送, 所有发往同一个fanout交换机的消息都会被所有监听这个交换机的消费者接收到

  • 发布订阅-消息模型引入fanout交换机

    通过把消息发送给交换机，交互机转发给对应绑定的队列

    交换机绑定的队列是排它独占队列，自动删除

    代码如下：

    // 消费者
public class Recv1 {

    private final static String EXCHANGE_NAME = "exchange_fanout";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        // 连接信息
        factory.setHost("20.18.24.143");
        factory.setUsername("admin");
        factory.setPassword("123456");
        factory.setVirtualHost("devTest");
        factory.setPort(5672);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 绑定交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

        // 获取队列
        String queueName = channel.queueDeclare().getQueue();

        // 绑定交换机和队列 fanout交换机不用routingKey
        channel.queueBind(queueName,EXCHANGE_NAME,"");

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);

                System.out.println("body: "+new String(body,"utf-8"));

                // 手工确认消息，不是多条确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(queueName,false,consumer);

    }

}

    // 生产者public class Send {    // 队列名称    private final static String EXCHANGE_NAME = "exchange_fanout";    public static void main(String[] argv) throws Exception {        ConnectionFactory factory = new ConnectionFactory();        // 连接信息        factory.setHost("20.18.24.143");        factory.setUsername("admin");        factory.setPassword("123456");        factory.setVirtualHost("devTest");        factory.setPort(5672);        // 继承        try (Connection connection = factory.newConnection();             // 创建信道             Channel channel = connection.createChannel()) {            // 绑定交换机 fanout扇形 广播            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);            String message = "rabbitMQ 广播方式测试";            channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes(StandardCharsets.UTF_8));            System.out.println("广播消息发送成功");        }    }}

    运行结果：

    #recv1 结果打印body: rabbitMQ 广播方式测试#recv2 结果打印body: rabbitMQ 广播方式测试

工作队列—路由模式

什么是rabbitmq的路由模式

  • 交换机类型是Direct

  • 队列和交换机绑定，需要指定一个路由key( 也叫Bingding Key)

  • 消息生产者发送消息给交换机，需要指定routingKey

  • 交换机根据消息的路由key，转发给对应的队列

    可用于日志分类采集

    代码如下：

    // 消费者public class Recv1 {    private final static String EXCHANGE_NAME = "exchange_direct";    public static void main(String[] argv) throws Exception {        ConnectionFactory factory = new ConnectionFactory();        // 连接信息        factory.setHost("20.18.24.143");        factory.setUsername("admin");        factory.setPassword("123456");        factory.setVirtualHost("devTest");        factory.setPort(5672);        Connection connection = factory.newConnection();        Channel channel = connection.createChannel();        // 绑定交换机        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);        // 获取队列        String queueName = channel.queueDeclare().getQueue();        // 绑定交换机和队列 直连交换机 绑定routingKey        channel.queueBind(queueName,EXCHANGE_NAME,"errorRoutingKey");        channel.queueBind(queueName,EXCHANGE_NAME,"infoRoutingKey");        channel.queueBind(queueName,EXCHANGE_NAME,"debugRoutingKey");        Consumer consumer = new DefaultConsumer(channel){            @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                super.handleDelivery(consumerTag, envelope, properties, body);                System.out.println("body: "+new String(body,"utf-8"));                // 手工确认消息，不是多条确认                channel.basicAck(envelope.getDeliveryTag(),false);            }        };        // 关闭消息自动确认        channel.basicConsume(queueName,false,consumer);    }}

    // 消费者2的代码只绑定error 只接收error的// 获取队列String queueName = channel.queueDeclare().getQueue();// 绑定交换机和队列 直连交换机 绑定routingKeychannel.queueBind(queueName,EXCHANGE_NAME,"errorRoutingKey");

    // 生产者代码public class Send {    // 队列名称    private final static String EXCHANGE_NAME = "exchange_direct";    public static void main(String[] argv) throws Exception {        ConnectionFactory factory = new ConnectionFactory();        // 连接信息        factory.setHost("20.18.24.143");        factory.setUsername("admin");        factory.setPassword("123456");        factory.setVirtualHost("devTest");        factory.setPort(5672);        // 继承        try (Connection connection = factory.newConnection();             // 创建信道             Channel channel = connection.createChannel()) {            // 绑定交换机 直连交换机            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);            String error = "订单服务错误日志error";            String info = "订单服务错误日志info";            String debug = "订单服务错误日志debug";            channel.basicPublish(EXCHANGE_NAME,"errorRoutingKey",null,error.getBytes(StandardCharsets.UTF_8));            channel.basicPublish(EXCHANGE_NAME,"infoRoutingKey",null,info.getBytes(StandardCharsets.UTF_8));            channel.basicPublish(EXCHANGE_NAME,"debugRoutingKey",null,debug.getBytes(StandardCharsets.UTF_8));            System.out.println("直连消息发送成功");        }    }}

    控制台绑定信息如下：

    在这里插入图片描述

    运行结果：

    #recv1 结果打印body: 订单服务错误日志errorbody: 订单服务错误日志infobody: 订单服务错误日志debug#recv2 结果打印body: 订单服务错误日志error#一组日常日志队列 一组报错日志队列

工作队列—topic主题通配符

什么是rabbitmq的主题模式

  • 交换机是 topic, 可以实现发布订阅模式fanout和路由模式Direct 的功能，更加灵活，支持模式匹配，通配符等

  • 交换机同过通配符进行转发到对应的队列，* 代表一个词，#代表1个或多个词，一般用#作为通配符居多。

  • 注意

    • 交换机和队列绑定时用的binding使用通配符的路由健
    • 生产者发送消息时需要使用具体的路由健

    匹配规则示例：

    quick.orange.rabbit 只会匹配  *.orange.* 和 *.*.rabbit ，进到Q1和Q2
lazy.orange.elephant 只会匹配 *.orange.* 和 lazy.#，进到Q1和Q2
quick.orange.fox 只会匹配 *.orange.*，进入Q1
lazy.brown.fox 只会匹配azy.#，进入Q2
lazy.pink.rabbit 只会匹配 lazy.#和*.*.rabbit ，同个队列进入Q2(消息只会发一次)
quick.brown.fox 没有匹配，默认会被丢弃，可以通过回调监听二次处理
lazy.orange.male.rabbit，只会匹配 lazy.#，进入Q2

在这里插入图片描述

​ 代码样例：

  • 一个队列采集error日志 ，order.log.error

  • 一个队列采集全部级别日志，* .log. *

    //消费者1 代码public class Recv1 {    private final static String EXCHANGE_NAME = "exchange_topic";    public static void main(String[] argv) throws Exception {        ConnectionFactory factory = new ConnectionFactory();        // 连接信息        factory.setHost("20.18.24.143");        factory.setUsername("admin");        factory.setPassword("123456");        factory.setVirtualHost("devTest");        factory.setPort(5672);        Connection connection = factory.newConnection();        Channel channel = connection.createChannel();        // 绑定交换机        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);        // 获取队列        String queueName = channel.queueDeclare().getQueue();        // 绑定交换机和队列 直连交换机 绑定routingKey        channel.queueBind(queueName,EXCHANGE_NAME,"order.log.error");        Consumer consumer = new DefaultConsumer(channel){            @Override            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {                super.handleDelivery(consumerTag, envelope, properties, body);                System.out.println("body: "+new String(body,"utf-8"));                // 手工确认消息，不是多条确认                channel.basicAck(envelope.getDeliveryTag(),false);            }        };        // 关闭消息自动确认        channel.basicConsume(queueName,false,consumer);    }}

    //消费者2 代码中只有绑定的路由key和消费者1不一样// 绑定交换机和队列 直连交换机 绑定routingKeychannel.queueBind(queueName,EXCHANGE_NAME,"*.log.*");

    // 生产者 发送两组订单的日志 和一组商品的日志public class Send {    // 队列名称    private final static String EXCHANGE_NAME = "exchange_topic";    public static void main(String[] argv) throws Exception {        ConnectionFactory factory = new ConnectionFactory();        // 连接信息        factory.setHost("20.18.24.143");        factory.setUsername("admin");        factory.setPassword("123456");        factory.setVirtualHost("devTest");        factory.setPort(5672);        // 继承        try (Connection connection = factory.newConnection();             // 创建信道             Channel channel = connection.createChannel()) {            // 绑定交换机 topic交换机 支持通配符模式            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);            String error = "订单服务错误日志error";            String info = "订单服务错误日志info";            String debug = "商品服务错误日志debug";            channel.basicPublish(EXCHANGE_NAME,"order.log.error",null,error.getBytes(StandardCharsets.UTF_8));            channel.basicPublish(EXCHANGE_NAME,"order.log.info",null,info.getBytes(StandardCharsets.UTF_8));            channel.basicPublish(EXCHANGE_NAME,"product.log.debug",null,debug.getBytes(StandardCharsets.UTF_8));            System.out.println("topic消息发送成功");        }    }}

    rabbit控制台绑定信息如下：

    在这里插入图片描述

    ​ 运行结果：

    #recv1 打印信息body: 订单服务错误日志error#recv2 打印信息body: 订单服务错误日志errorbody: 订单服务错误日志infobody: 商品服务错误日志debug

    实际应用中一般使用topic主题模型，topic模型更灵活

EssinZhang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rabbitmq消息中间件初步学习——第二节七种模型分析
Burnup_110的博客
01-28 482
前言 Rabbitmq应用场景 1.RabbitMQ的消息应当尽可能的小，并且只用来处理实时且要高可靠性的消息。 2.消费者和生产者的能力尽量对等，否则消息堆积会严重影响RabbitMQ的性能。 3.集群部署，使用热备，保证消息的可靠性。 ...
flink样例完整代码
05-31
标签 "flink 软件/插件" 指出，Flink是一个软件或插件，可以在不同的环境中部署和集成。这可能包括Hadoop生态系统、Kubernetes或者云服务提供商，例如Amazon EMR、Azure Databricks等。 压缩包中的文件名为 ...
消息队列之RabbitMQ的五种工作模式及代码样例(二)
qq_43805456的博客
02-08 1448
消息队列之RabbitMQ的五种工作模式及代码样例
RabbitMQ 使用样例
afxf27382的博客
08-14 99
package cn.com.kpcq.xunjian.utils; import java.io.IOException; import java.util.Date; import java.util.concurrent.TimeoutException; import com.google.gson.JsonObject; import com.rab...
RabbitMQ使用场景和springboot实例
ifspirt的博客
04-02 435
使用场景 springboot实例 死信队列 消息队列 持久化 内存监控
RabbitMQ常见的消息模型
cj1561435010的博客
08-07 709
首先安装RabbitMQ的前置条件即erlang，因为这个中间件是由erlang语言编写的。 yum install erlang 出现了上面的错误，不急，使用下面的指令安装deltarpm。 yum provides '*/applydeltarpm' #查看依赖包的位置 yum -y install deltarpm #安装命令 可以使用下面指令查看erlang是否成功安装。 erl 使用下面指令安装socat。 yum install soc
RabbitMQ 详解及实例（含错误信息处理）
深圳市多克创新科技有限公司
10-12 1382
常见的消息队列很多，主要包括 RabbitMQ、Kafka、RocketMQ 和 ActiveMQ，这篇文章详细讲 述RabbitMQ，先讲原理，后搞实战
RabbitMQ相关概念及代码示例
穿越在未来的专栏
02-15 613
介绍RabbitMQ的一些重要概念，并结合几段实际代码，帮助理解
rabbitmq
hx1176406648的博客
06-19 246
rabbitmq简介Exchange交换机作业总结参考文档 简介 rabbitmq由三部分组成，生产者、消费者、broker。 broker的作用是存储与转发消息。 mq的用途：异步通信、解耦、流量削峰。 rabbitmq工作模型： 生产者、消费者与broker维持了tcp长连接，长连接中可以创建许多channel，消息通过channel传输，broker中可以有很多虚拟主机（VHOST）。 Exchange交换机 Direct 直连模式：指定路由键通过交换机和队列的绑定关系发送到指定队列。 publ
一个普通的SpringCloud样例
06-20
它允许开发者定义输入和输出绑定，以便与消息中间件进行交互，如 RabbitMQ 或 Kafka。 9. **Spring Cloud Sleuth**： Sleuth 提供了分布式追踪解决方案，它集成 Zipkin 或 Brave，使得在分布式系统中可以追踪服务...
Distributed-Architecture-BoilerPlate:使用CQRS，RabbitMQ，MassTransit和微服务的样板应用程序
03-25
"Distributed-Architecture-BoilerPlate" 是一个使用CQRS（命令查询职责分离），RabbitMQ，MassTransit以及微服务概念的样例应用，旨在帮助开发者快速理解和实现分布式系统的各种组件。 **CQRS（命令查询职责分离）...
spring-cloud-stream
03-25
在 Spring Cloud Stream 中，我们首先定义“绑定器”(Binder)，它是一个抽象层，负责将应用的输入和输出通道连接到实际的消息中间件，如 RabbitMQ、Kafka 或 AWS Kinesis。通过这种方式，开发者可以专注于业务逻辑，...
flinkTest.zip
03-09
1. **流处理模型**：Flink的Stream API允许开发者定义数据流转换，这些转换可以是简单的过滤、映射，也可以是复杂的窗口操作和状态管理。Flink的DataStream API支持两种模式：数据流（Data Streams）和数据集...
RabbitMQ高级特性 - 非持久化 / 持久化（交换机、队列、消息）
CYK_byte的博客
08-04 191
前面讲到了 生产者消息确认机制 和 消费者消息确认机制，保证了消息传输的可靠性，但是这还不够，试想如果 Broker 突然崩溃，那么所有的 交换机、队列、消息 不就全部都没了（RabbitMQ 以内存为主，硬盘为辅，默认交换机和队列都是非持久化的）. 因此需要持久化机制.a）交换机持久化如果交换机不设置持久化，那么在 rabbitmq 服务重启之后，相关的交换机元数据就会丢失，对一个长期使用的交换机来说，建议设置成持久化的.
RabbitMQ应用场景及特性
最新发布
Smarmot的博客
08-04 321
RabbitMQ是一款开源的消息队列中间件，拥有非常好用的管理控制面板，类似使用navicat一样，简便的操纵数据库。本文将介绍应用场景、工作流程、已经核心特性
RabbitMQ高级特性 - 消费者消息确认机制
CYK_byte的博客
08-04 663
为了保证消息从 队列 到 消费者正确消费，那么就引入了消费者消息确认机制.a）消费者在订阅队列时，可以指定 autoAck 参数，根据这个参数设置，消息确认机制分为以下两种（以下讲到的方法和参数来自于 RabbitMQ 原生的 SDK，非 Spring 提供）.自动确认：当 autoAck = true 时，RabbitMQ 会自动把发送出去的消息置为确认，然后不管消费者是否真正的消费这些消息，都会从内存中删除.（适合对消息可靠性要求不高的场景）.
03 RabbitMQ：HelloWorld
Eyesmoon的博客
08-04 620
03 RabbitMQ：HelloWorld
RabbitMQ高级特性 - 生产者消息确认机制
CYK_byte的博客
08-04 466
为了保证信息 从生产者 发送到 队列，因此引入了生产者的消息确认机制.通过事务机制实现.通过发送确认机制（confirm 和 return）实现.因为事务机制比较消耗性能，在实际工作中用的也不多，因此这里主要介绍confirm 和 return机制来实现发送放的确认.a）confirm 确认模式如上图，confirm 确认模式主要保障于 生产者 到 交换机 的消息可靠性.如果 Exchange成功收到消息，那么 ConfirmCallback 这个回调 ack 参数就为true。
python rabbitmq发消息样例
07-17
在Python中，使用RabbitMQ发送消息通常涉及pika库，这是一个AMQP（Advanced Message Queuing Protocol）客户端。下面是一个简单的例子，展示了如何连接到RabbitMQ服务器并发送一条消息： ```python import pika # ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值