RabbitMQ系列(四)-Exchange

最新推荐文章于 2024-05-22 00:06:31 发布
最新推荐文章于 2024-05-22 00:06:31 发布
阅读量145 收藏
点赞数
分类专栏： rabbitmq 消息队列 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rhnxbdbdh/article/details/120118127
版权

RabbitMQ系列(四)-发布订阅模式

上一篇 : RabbitMQ系列(三)-工作队列模式

这里写目录标题

一、 介绍

1.1 交换机Exchange

1. rabbitmq中的消息首先会到达 exchange.  
2. exchange根据指定的规则,将消息分发到指定的队列或者多个队列中,在Server中承担着从Produce
接收Message的责任。
3. 我们常用的模式有3个. Fanout、Direct、Topic

1.2 Fanout

Fanout模式的交换机会忽略routingkey,把消息发送到所有绑定了此交换机的队列上

1.3 Direct

完全匹配的工作模式,需要队列和交换机绑定并指定了routingkey.消息将被发送到指定routingkey的队列中

1.4 Topic

模糊匹配的工作模式,支持*通配符和#通配符

二、 测试

2.1 Fanout

  1. 生产者
var factory = new ConnectionFactory
            {
                HostName = "192.168.3.20",
                Port = 5672,
                UserName = "xxx",
                Password = "xxx",
                VirtualHost = "/"
            };
            using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "fanout_exchange",
                                    type: "fanout");
            //声明3个队列
            string queueName1 = "fanout_queue1";
            channel.QueueDeclare(queue: queueName1,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            string queueName2 = "fanout_queue2";
            channel.QueueDeclare(queue: queueName2,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            string queueName3 = "fanout_queue3";
            channel.QueueDeclare(queue: queueName3,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            //绑定队列到交换机
            channel.QueueBind(queue: queueName1,
                              exchange: "fanout_exchange",
                              routingKey: "");
            channel.QueueBind(queue: queueName2,
                              exchange: "fanout_exchange",
                              routingKey: "");
            channel.QueueBind(queue: queueName3,
                              exchange: "fanout_exchange",
                              routingKey: "");
            Console.WriteLine("请输入要发送的消息,如果发送完毕,输入ok即可.");
            var sendMsg = "";
            while (sendMsg != "ok")
            {
                sendMsg = Console.ReadLine();
                var body = Encoding.UTF8.GetBytes(sendMsg);
                channel.BasicPublish(exchange: "fanout_exchange",
                                     routingKey: "",
                                     basicProperties: null,
                                     body: body);
                if (sendMsg == "ok")
                {
                    Console.WriteLine("消息发送结束,按任意键退出.");
                }
                else
                {
                    Console.WriteLine($"Send ====>{sendMsg}");
                }
            }

            Console.ReadKey();

  1. 运行可以发现,三个队列已经创建并且有3条数据.
    在这里插入图片描述

  2. 点对点和工作队列模式我们用的是默认的交换机,而现在我们用的是自己创建的新交换机

在这里插入图片描述

  1. 消费者
//这里博主只消费一个队列
#region fanout
            string queueName = "fanout_queue1";
            using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "fanout_exchange",
                                    type: "fanout");
            channel.QueueDeclare(queue: queueName,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            //绑定队列到交换机
            channel.QueueBind(queue: queueName,
                              exchange: "fanout_exchange",
                              routingKey: "");
            var consumer = new EventingBasicConsumer(channel);
            
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine($"Received {message}");
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: true,
                                 consumer: consumer);
            #endregion

            Console.ReadKey();

在这里插入图片描述

  1. 可以看到队列1中的消息已经被消费完了.

2.2 Direct

  1. 生产者,这里我将奇数1 3 5 三条消息发送到 d1–routingkey,偶数 2 4 6三条发送到d2–routingkey
 using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "direct_exchange",
                                    type: "direct");
            //声明2个队列
            string queueName1 = "direct_queue1";
            channel.QueueDeclare(queue: queueName1,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            string queueName2 = "direct_queue2";
            channel.QueueDeclare(queue: queueName2,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            //绑定队列到交换机
            channel.QueueBind(queue: queueName1,
                              exchange: "direct_exchange",
                              routingKey: "d1");
            channel.QueueBind(queue: queueName2,
                              exchange: "direct_exchange",
                              routingKey: "d2");
            Console.WriteLine("请输入要发送的消息,如果发送完毕,输入ok即可.");
            var sendMsg = "";
            while (sendMsg != "ok")
            {
                sendMsg = Console.ReadLine();
                Console.WriteLine("输入routingkey");
                var routingKey = Console.ReadLine();
                var body = Encoding.UTF8.GetBytes(sendMsg);
                channel.BasicPublish(exchange: "direct_exchange",
                                     routingKey: routingKey,
                                     basicProperties: null,
                                     body: body);
                if (sendMsg == "ok")
                {
                    Console.WriteLine("消息发送结束,按任意键退出.");
                }
                else
                {
                    Console.WriteLine($"Send ====>{sendMsg}");
                }
            }
  1. 运行结果图
    在这里插入图片描述
  2. 交换机绑定
    在这里插入图片描述
  3. 消费者,这里博主还是只消费direct_queue1
string queueName = "direct_queue1";
            using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "direct_exchange",
                                    type: "direct");
            channel.QueueDeclare(queue: queueName,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            //绑定队列到交换机
            channel.QueueBind(queue: queueName,
                              exchange: "direct_exchange",
                              routingKey: "d1");
            var consumer = new EventingBasicConsumer(channel);

            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine($"Received {message}, routingkey:{ea.RoutingKey}");
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: true,
                                 consumer: consumer);

在这里插入图片描述

2.3 Topic

  1. 生产者,两个正常routingkey,一个通配符routingkey
using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "topic_exchange",
                                    type: "topic");
            //声明3个队列
            string queueName1 = "topic_queue1";
            channel.QueueDeclare(queue: queueName1,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            string queueName2 = "topic_queue2";
            channel.QueueDeclare(queue: queueName2,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            string queueName3 = "topic_queue3";
            channel.QueueDeclare(queue: queueName3,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);

            //绑定队列到交换机
            channel.QueueBind(queue: queueName1,
                              exchange: "topic_exchange",
                              routingKey: "test.info");
            channel.QueueBind(queue: queueName2,
                              exchange: "topic_exchange",
                              routingKey: "test.debug");
            channel.QueueBind(queue: queueName3,
                              exchange: "topic_exchange",
                              routingKey: "test.info.*");
            Console.WriteLine("请输入要发送的消息,如果发送完毕,输入ok即可.");
            var sendMsg = "";
            while (sendMsg != "ok")
            {
                sendMsg = Console.ReadLine();
                var body = Encoding.UTF8.GetBytes(sendMsg);
                channel.BasicPublish(exchange: "topic_exchange",
                                     routingKey: "test.info",
                                     basicProperties: null,
                                     body: body);
                channel.BasicPublish(exchange: "topic_exchange",
                                     routingKey: "test.debug",
                                     basicProperties: null,
                                     body: body);
                channel.BasicPublish(exchange: "topic_exchange",
                                     routingKey: "test.info.a1",
                                     basicProperties: null,
                                     body: body);
                channel.BasicPublish(exchange: "topic_exchange",
                                     routingKey: "test.info.a2",
                                     basicProperties: null,
                                     body: body);
                channel.BasicPublish(exchange: "topic_exchange",
                                     routingKey: "test.info.a3",
                                     basicProperties: null,
                                     body: body);
                if (sendMsg == "ok")
                {
                    Console.WriteLine("消息发送结束,按任意键退出.");
                }
                else
                {
                    Console.WriteLine($"Send ====>{sendMsg}");
                }
            }
  1. 因为通配符可以适配模糊匹配,所以 test.info.a1/test.info.a2/test.info.a3三个数据都被发送到了topic_queue3中,下图所示也符合预期

在这里插入图片描述
3. 消费者,这里我们消费通配符队列,其他队列指定队列名称即可消费.

string queueName = "topic_queue3";
            using var conn = factory.CreateConnection();
            using var channel = conn.CreateModel();
            //声明交换机
            channel.ExchangeDeclare(exchange: "topic_exchange",
                                    type: "topic");
            channel.QueueDeclare(queue: queueName,
                                 durable: false,
                                 exclusive: false,
                                 autoDelete: false,
                                 arguments: null);
            //绑定队列到交换机
            channel.QueueBind(queue: queueName,
                              exchange: "topic_exchange",
                              routingKey: "test.info.*");
            var consumer = new EventingBasicConsumer(channel);

            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine($"Received {message}, routingkey:{ea.RoutingKey}");
                channel.BasicAck(deliveryTag: ea.DeliveryTag, 
                                 multiple: false);
            };
            channel.BasicConsume(queue: queueName,
                                 autoAck: false,
                                 consumer: consumer);

在这里插入图片描述

三、 用法优化

3.1 消费者消费能力

var consumer = new EventingBasicConsumer(channel);
//在创建了消费者对象之后,用prefetchCount来限定消费者可以同时消费处理的数量.
//如果设置为1,那么只能消费1个并且这个消费完成之前,rabbitmq不会下发新的消息
//根据情况可以适当增大来提升消费速度
channel.BasicQos(prefetchSize: 0,
                 prefetchCount: 1,
                 global: false);

3.2 手动ack

var consumer = new EventingBasicConsumer(channel);

consumer.Received += (model, ea) =>
{
    var body = ea.Body.ToArray();
    var message = Encoding.UTF8.GetString(body);
    Console.WriteLine($"Received {message}, routingkey:{ea.RoutingKey}");        
    //加上下面这行,如果上面部分的业务处理完成,那么就自己手动签收
    //如果不加这个会导致重复消费问题
    channel.BasicAck(deliveryTag: ea.DeliveryTag, 
                     multiple: false);
};
//自己手动签收,保证正确消费
channel.BasicConsume(queue: queueName,
                     autoAck: false, #这里选false
                     consumer: consumer);

3.3 消息持久化

//创建一个这个对象
var basicProperties = channel.CreateBasicProperties();
//1为非持久化  2为持久化
basicProperties.DeliveryMode = 2;
//把第三个参数赋值即可达到持久化的效果
channel.BasicPublish(exchange: "",
                     routingKey: queueName,
                     basicProperties: basicProperties,
                     body: body);

四、 总结

1. 博主介绍了关于exchange交换机的3钟模式,当然还有其他的,但是博主也没用过.就不介绍了
2. 如有不对,欢迎指正.
小丑dd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq-delayed-message-exchange:RabbitMQ 的延迟消息传递
08-04
较早的系列。支持的 Erlang/OTP 版本此插件，与 RabbitMQ 3.8.16+ 相同。项目成熟度这个插件被认为是实验性的，但相当稳定，只要用户意识到它的局限性，就可能适合生产使用。 它存在一些问题，并且在其存在的大约 ...
RabbitMQ系列--Direct Exchange
撸码社区的博客
08-03 468
RabbitMQ工作流程 左边是生产者，右边是消费者，中间红框内是RabbitMQ服务器，其中包括交换机以及消息队列 消费者发送消息给RabbitMQ服务器，交换机接收到消息，然后根据不同的交换机规则投递给消息队列，消费者订阅消息进行消费 RabbitMQ交换机类型 作用：接收消息，按照路由规则将消息路由到一个或者多个队列。如果路由不到，或者返回给生产者，或者直接丢弃。RabbitMQ常用的交换器常用类型有direct、topic、fanout三种，其他的由于性能不好等原因几乎用不到，后续主要介绍这
RabbitMQ系列--Topic Exchange
撸码社区的博客
08-04 361
关于RabbitMQ的介绍以及工作流程，还有Direct Exchange的相关使用大家可以看下前两篇文章，本篇主要介绍Topic Exchange，下面直接进入正题。 Topic Exchange 上文简单介绍了主题交换机，是根据一定规则将消息投递给对应队列。接下来我们简单通俗的说一下这个规则是什么？ 上文我们将交换机和队列进行绑定的时候有一个 routing key，在 Direct Exchange(直连交换机) 中这个路由键是可以由任意规则组成的，而在我们今天介绍的主题交换机中，routing ke
RabbitMQ系列--Fanout Exchange
撸码社区的博客
08-05 140
关于RabbitMQ的介绍以及工作流程，还有Direct Exchange、Topic Exchange的相关使用大家可以看下前两篇文章，本篇主要介绍Fanout Exchange，下面直接进入正题。 Fanout Exchange 这个扇形交换机的话，相对前两种而言是更加简单的，因为它没有路由键的这个概念，如果你去绑定了路由键的话，也是无效的哈，交换机接收到生产者发送的消息后会直接投递给绑定的队列中。 编写RabbitMQ示例 生产者项目创建扇形交换机 package com.chentawen.ra
SpringBoot整合RabbitMQ系列--用死信队列实现延迟消息
IT利刃出鞘的博客
05-26 710
本文用示例介绍SpringBoot整合RabbitMQ时如何处理死信队列/延迟队列。
SpringBoot整合RabbitMQ系列--备份交换机的使用
IT利刃出鞘的博客
09-21 3250
本文用示例介绍SpringBoot整合RabbitMQ时如何使用备份交换机。
rabbitmq-delayed-message-exchange 3.11.1
10-25
rabbitmq 延迟队列插件
rabbitmq-server-3.10.5-1.el8.noarch.rpm
07-01
rabbitmq-server-3.10.5-1.el8.noarch.rpm
rabbitmq-server-3.7.7.exe
10-27
RabbitMQ3.7.7安装包在ERLang19.3语音的安装包。
php-rabbitmq-management-api
05-25
$ composer require richardfullmer/rabbitmq-management-api 此外，您需要一个。 例如，使用guzzle6适配器： $ composer require php-http/guzzle6-adapter 基本用法 <?php use RabbitMq \ ManagementApi \ ...
消息队列之Pulsar、kafaka、rabbitmq、mqtt、RocketMQ
CherryXieのblog
05-19 290
Pulsar 具有高度可扩展的架构，可以处理大规模的实时数据流，并提供低延迟的消息传递。
本机搭建RabbitMQ
ql_gome的博客
05-15 953
Exchange（交换机）作用：Exchange是消息的路由器。生产者将消息发送给exchange，而不是直接发送给队列。exchange根据预定义的规则（称为binding）来决定哪些消息应该路由到哪个队列类型：Exchange有多种类型，如direct（直接交换机）、fanout（广播交换机）、topic（主题交换机）和headers（基于消息头的交换机），每种类型的exchange有不同的路由策略配置：Exchange需要预先声明，指定其类型和任何其他相关配置Queue（队列）
RabbitMQ .NET
ooo
05-18 221
.NET RabbitMQQ Send Receive
rabbitmq交换机，死信队列的简单例子
weixin_43970625的博客
05-14 553
假设我们有一个场景，生产者有消息发到某个直连交换机，这个交换机上有两个队列分别存储两种类型的消息，但是与这两个队列相连的消费者太不争气了，处理消息有点慢，我们想5秒钟这个消息在队列中还没有被消费的话，就给它丢进死信队列里得了，后续再处理，但是这俩队列明显存储的消息不一样，我们又不好意思将它都扔到同一个死信队列里去，如果我们想要俩死信队列分别装这两个消费者漏掉的消息，那我们怎么做呢？：我们先创建一个工具类用来连接rabbitmq，注意你需要去创建对应的虚拟主机，以及对应的登录账号和密码。
RabbitMQ 消息队列安装及入门
2302_79789602的博客
05-18 903
RabbitMQ 安装及入门消费者，生产者
Rabbitmq报unauthorized异常
qq_32590535的博客
05-14 328
处理rabbitmq的unauthorized 异常。Caused by: java.lang.SecurityException: Attempt to deserialize unauthorized class java.util.HashMap;
RabbitMQ02-RebbitMQ简介及交换器
最新发布
qq_43676797的博客
05-22 349
RabbitMQ是通过Erlang语言基于AMQP协议编写的消息中间件，它在分布式系统中可以解应用耦合、流量削峰、异步消息等问题。它有两个特性队列排队和异步应用解耦：多个个应用程序之间可通过RabbitMQ作为媒介，两个应用不再粘连，实现解耦；异步消息：多个应用可通过RabbitMQ进行消息传递；流量削峰：在高并发情况下，可以通过RabbitMQ的队列特性实现流量削峰；应用场景：应用到队列特性的应用场景： 排序算法、秒杀活动。
RabbitMQ
lercent的博客
05-21 681
RabbitMQ是一个开源的消息队列中间件，它实现了高度可靠、灵活和可扩展的消息传递模型。RabbitMQ是由支持高并发的erlang语言开发，它实现了 AMQP（高级消息队列协议）。
RabbitMQ-----发送接收
m0_72410274的博客
05-17 983
RabbitMQ 消息发送和接收
rabbitmq-c-0.13
08-23
RabbitMQ-C是一个用于与RabbitMQ消息代理进行通信的C语言客户端库。它提供了发送和接收消息的功能，以及管理队列、交换机和绑定等基本操作。RabbitMQ-C库使用AMQP协议与RabbitMQ进行通信，并通过简单而直观的API提供...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值