RabbitMQ简介和六种工作模式实战详解

最新推荐文章于 2024-02-06 07:00:00 发布
最新推荐文章于 2024-02-06 07:00:00 发布
阅读量533 收藏 2
点赞数
分类专栏： .NET CORE& .NET＆C# # RabbitMQ,kafka.....消息队列 文章标签： rabbitmq c# .NET CORE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41872328/article/details/120075865
版权

一、RabbitMQ简介

是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang(高并发语言)语言来编写的，并且RabbitMQ是基于AMQP协议的。

1.1 AMQP协议

Advanced Message Queuing Protocol(高级消息队列协议)

1.2 AMQP专业术语：（多路复用->在同一个线程中开启多个通道进行操作）

  • Server：又称broker，接受客户端的链接，实现AMQP实体服务

  • Connection:连接，应用程序与broker的网络连接

  • Channel:网络信道，几乎所有的操作都在channel中进行，Channel是进行消息读写的通道。客户端可以建立多个channel，每个channel代表一个会话任务。

  • Message:消息，服务器与应用程序之间传送的数据，由Properties和Body组成.Properties可以对消息进行修饰，必须消息的优先级、延迟等高级特性；Body则是消息体内容。

  • virtualhost: 虚拟地址，用于进行逻辑隔离，最上层的消息路由。一个virtual host里面可以有若干个Exchange和Queue，同一个Virtual Host 里面不能有相同名称的Exchange 或 Queue。

  • Exchange：交换机，接收消息，根据路由键转单消息到绑定队列

  • Binding: Exchange和Queue之间的虚拟链接，binding中可以包换routing key

  • Routing key: 一个路由规则，虚拟机可用它来确定如何路由一个特定消息。（如负载均衡）

1.3 RabbitMQ整体架构

图片

ClientA(生产者)发送消息到Exchange1(交换机)，同时带上RouteKey(路由Key)，Exchange1找到绑定交换机为它和绑定传入的RouteKey的队列，把消息转发到对应的队列，消费者Client1，Client2,Client3只需要指定对应的队列名即可以消费队列数据。

交换机和队列多对多关系，实际开发中一般是一个交换机对多个队列，防止设计复杂化。

二、安装RabbitMQ

安装方式不影响下面的使用，这里用Docker安装

#15672端口为web管理端的端口，5672为RabbitMQ服务的端口
docker run -d  --name rabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=123456 -p 15672:15672 -p 5672:5672 rabbitmq:3-management

输入：ip:5672访问验证。

图片

建一个名为develop的Virtual host(虚拟主机)使用，项目中一般是一个项目建一个Virtual host用，能够隔离队列。

图片

切换Virtual host

图片

三、RabbitMQ六种队列模式在.NetCore中使用

(1)简单队列

最简单的工作队列，其中一个消息生产者，一个消息消费者，一个队列。也称为点对点模式

图片

描述：一个生产者 P 发送消息到队列 Q，一个消费者 C 接收

建一个RabbitMQHelper.cs类

/// <summary>
    /// RabbitMQ帮助类
    /// </summary>
    public class RabbitMQHelper
    {
        private static ConnectionFactory factory;
        private static object lockObj = new object();
        /// <summary>
        /// 获取单个RabbitMQ连接
        /// </summary>
        /// <returns></returns>
        public static IConnection GetConnection()
        {
            if (factory == null)
            {
                lock (lockObj)
                {
                    if (factory == null)
                    {
                         factory = new ConnectionFactory
                        {
                            HostName = "172.16.2.84",//ip
                            Port = 5672,//端口
                            UserName = "admin",//账号
                            Password = "123456",//密码
                            VirtualHost = "develop" //虚拟主机
                        };
                    }
                }
            }
            return factory.CreateConnection();
        }
    }

生产者代码：

新建发送类Send.cs

public static void SimpleSendMsg()
        {
            string queueName = "simple_order";//队列名
            //创建连接
            using (var connection = RabbitMQHelper.GetConnection())
            {
                //创建信道
                using (var channel = connection.CreateModel())
                {//创建队列
                    channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
                    for (var i = 0; i < 10; i++)
                    {
                        string message = $"Hello RabbitMQ MessageHello,{i + 1}";
                        var body = Encoding.UTF8.GetBytes(message);//发送消息
                        channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: false, basicProperties: null, body);
                        Console.WriteLine($"发送消息到队列:{queueName},内容:{message}");
                    }
                }
            }
        }

创建队列参数解析：

durable：是否持久化。

exclusive：排他队列，只有创建它的连接(connection)能连，创建它的连接关闭，会自动删除队列。

autoDelete：被消费后，消费者数量都断开时自动删除队列。

arguments：创建队列的参数。

发送消息参数解析：

exchange：交换机，为什么能传空呢，因为RabbitMQ内置有一个默认的交换机，如果传空时，就会用默认交换机。

routingKey：路由名称，这里用队列名称做路由key。

mandatory：true告诉服务器至少将消息route到一个队列种，否则就将消息return给发送者；false：没有找到路由则消息丢弃。

执行效果：

图片

队列产生10条消息。

图片

 消费者代码：

新建Recevie.cs类

public static void SimpleConsumer()
        {
            string queueName = "simple_order";
            var connection = RabbitMQHelper.GetConnection();
            {
                //创建信道
                var channel = connection.CreateModel();
                {
                    //创建队列
                     channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
                    var consumer = new EventingBasicConsumer(channel);
                    int i = 0;
                    consumer.Received += (model, ea) =>
                    {
                        //消费者业务处理
                        var message = Encoding.UTF8.GetString(ea.Body.ToArray());
                        Console.WriteLine($"{i},队列{queueName}消费消息长度:{message.Length}");
                        i++;
                    };
                    channel.BasicConsume(queueName, true, consumer);
                }
            }
        }

消费者只需要知道队列名就可以消费了，不需要Exchange和routingKey。

注：消费者这里有一个创建队列，它本身不需要，是预防消费端程序先执行，没有队列会报错。

执行效果：

图片

图片

消息已经被消费完。

(2)工作队列模式

一个消息生产者，一个交换器，一个消息队列，多个消费者。同样也称为点对点模式

图片

生产者P发送消息到队列，多个消费者C消费队列的数据。

工作队列也称为公平性队列模式，循环分发，RabbitMQ 将按顺序将每条消息发送给下一个消费者，每个消费者将获得相同数量的消息。

生产者：

Send.cs代码：

/// <summary>
        /// 工作队列模式
        /// </summary>
        public static void WorkerSendMsg()
        {
            string queueName = "worker_order";//队列名
            //创建连接
            using (var connection = RabbitMQHelper.GetConnection())
            {
                //创建信道
                using (var channel = connection.CreateModel())
                {
                    //创建队列
                    channel.QueueDeclare(queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
　　　　　　　　　　　　 var properties = channel.CreateBasicProperties();
　　　　　　　　　　　　　properties.Persistent = true; //消息持久化
                    for ( var i=0;i<10;i++)
                    {
                        string message = $"Hello RabbitMQ MessageHello,{i+1}";
                        var body = Encoding.UTF8.GetBytes(message);
                        //发送消息到rabbitmq
                        channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: false, basicProperties: properties, body);
                        Console.WriteLine($"发送消息到队列:{queueName},内容:{message}");
                    }
                }
            }
        }

参数durable：true，需要持久化，实际项目中肯定需要持久化的，不然重启RabbitMQ数据就会丢失了。

执行效果：

图片

 写入10条数据，有持久化标识D。

图片

 消费端：

Recevie代码：

public static void WorkerConsumer()
        {
            string queueName = "worker_order";
            var connection = RabbitMQHelper.GetConnection();
            {
                //创建信道
                var channel = connection.CreateModel();
                {
                    //创建队列
                    channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
                    var consumer = new EventingBasicConsumer(channel);
                    //prefetchCount:1来告知RabbitMQ,不要同时给一个消费者推送多于 N 个消息，也确保了消费速度和性能
                    channel.BasicQos(prefetchSize: 0, prefetchCount:1, global: false);
                    int i = 1;
                    int index = new Random().Next(10);
                    consumer.Received += (model, ea) =>
                    {
                        //处理业务
                        var message = Encoding.UTF8.GetString(ea.Body.ToArray());
                        Console.WriteLine($"{i},消费者:{index},队列{queueName}消费消息长度:{message.Length}");
                         channel.BasicAck(ea.DeliveryTag, false); //消息ack确认，告诉mq这条队列处理完，可以从mq删除了
　　　　　　　　　　　　　　　Thread.Sleep(1000);
                        i++;
                    };
                    channel.BasicConsume(queueName,autoAck:false, consumer);
                }
            }
        }

BasicQos参数解析：

prefetchSize：每条消息大小，一般设为0，表示不限制。

prefetchCount：1，作用限流，告诉RabbitMQ不要同时给一个消费者推送多于N个消息，消费者会把N条消息缓存到本地一条条消费，如果不设，RabbitMQ会进可能快的把消息推到客户端，导致客户端内存升高。设置合理可以不用频繁从RabbitMQ 获取能提升消费速度和性能，设的太多的话则会增大本地内存，需要根据机器性能合理设置，官方建议设为30。

global:是否为全局设置。

这些限流设置针对消费者autoAck：false时才有效，如果是自动Ack的，限流不生效。

执行两个消费者，效果：

图片

可以看到消费者号的标识，8,2,8,2是平均的，一个消费者5个，RabbitMQ上也能看到有2个消费者，Unacked数是2，因为每个客户端的限流数是1。

图片

工作队列模式也是很常用的队列模式。

(3)发布订阅模式 

Pulish/Subscribe，无选择接收消息，一个消息生产者，一个交换机（交换机类型为fanout），多个消息队列，多个消费者。称为发布/订阅模式

在应用中，只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。

图片

生产者P只需把消息发送到交换机X，绑定这个交换机的队列都会获得一份一样的数据。

应用场景：适合于用同一份数据源做不同的业务。

生产者代码：　

/// <summary>
        /// 发布订阅， 扇形队列
        /// </summary>
        public static void SendMessageFanout()
        {
            //创建连接
            using (var connection = RabbitMQHelper.GetConnection())
            {
                //创建信道
                using (var channel = connection.CreateModel())
                {
                    string exchangeName = "fanout_exchange";
                    //创建交换机,fanout类型
                    channel.ExchangeDeclare(exchangeName, ExchangeType.Fanout);
                    string queueName1 = "fanout_queue1";
                    string queueName2 = "fanout_queue2";
                    string queueName3 = "fanout_queue3";
                    //创建队列
                    channel.QueueDeclare(queueName1, false, false, false);
                    channel.QueueDeclare(queueName2, false, false, false);
                    channel.QueueDeclare(queueName3, false, false, false);

                    //把创建的队列绑定交换机,routingKey不用给值，给了也没意义的
                    channel.QueueBind(queue: queueName1, exchange: exchangeName, routingKey: "");
                    channel.QueueBind(queue: queueName2, exchange: exchangeName, routingKey: "");
                    channel.QueueBind(queue: queueName3, exchange: exchangeName, routingKey: "");
　　　　　　　　　　　　　var properties = channel.CreateBasicProperties();
　　　　　　　　　　　　　properties.Persistent = true; //消息持久化
                    //向交换机写10条消息
                    for (int i = 0; i < 10; i++)
                    {
                        string message = $"RabbitMQ Fanout {i + 1} Message";
                        var body = Encoding.UTF8.GetBytes(message);
                        channel.BasicPublish(exchangeName, routingKey: "", null, body);
                        Console.WriteLine($"发送Fanout消息:{message}");
                    }
                }
            }
        }

执行代码：

图片

图片

 向交换机发送10条消息，则绑定这个交换机的3个队列都会有10条消息。

消费端的代码和工作队列的一样，只需知道队列名即可消费，声明时要和生产者的声明一样。

(4)路由模式（推荐使用）

在发布/订阅模式的基础上，有选择的接收消息，也就是通过 routing 路由进行匹配条件是否满足接收消息。

图片

 上图是一个结合日志消费级别的配图，在路由模式它会把消息路由到那些 binding key 与 routing key 完全匹配的 Queue 中，此模式也就是 Exchange 模式中的direct模式。

 生产者P发送数据是要指定交换机(X）和routing发送消息 ，指定的routingKey=error，则队列Q1和队列Q2都会有一份数据，如果指定routingKey=into,或=warning，交换机(X)只会把消息发到Q2队列。

 生产者代码：

　/// <summary>
        /// 路由模式，点到点直连队列
        /// </summary>
        public static void SendMessageDirect()
        {
            //创建连接
            using (var connection = RabbitMQHelper.GetConnection())
            {
                //创建信道
                using (var channel = connection.CreateModel())
                {
                    //声明交换机对象,fanout类型
                    string exchangeName = "direct_exchange";
                    channel.ExchangeDeclare(exchangeName, ExchangeType.Direct);
                    //创建队列
                    string queueName1 = "direct_errorlog";
                    string queueName2 = "direct_alllog";
                    channel.QueueDeclare(queueName1, true, false, false);
                    channel.QueueDeclare(queueName2, true, false, false);

                    //把创建的队列绑定交换机,direct_errorlog队列只绑定routingKey:error
                    channel.QueueBind(queue: queueName1, exchange: exchangeName, routingKey: "error");
                    //direct_alllog队列绑定routingKey:error,info
                    channel.QueueBind(queue: queueName2, exchange: exchangeName, routingKey: "info");
                    channel.QueueBind(queue: queueName2, exchange: exchangeName, routingKey: "error");
　　　　　　　　　　　　　var properties = channel.CreateBasicProperties();
　　　　　　　　　　　　　properties.Persistent = true; //消息持久化
                    //向交换机写10条错误日志和10条Info日志
                    for (int i = 0; i < 10; i++)
                    {
                        string message = $"RabbitMQ Direct {i + 1} error Message";
                        var body = Encoding.UTF8.GetBytes(message);
                        channel.BasicPublish(exchangeName, routingKey: "error", properties, body);
                        Console.WriteLine($"发送Direct消息error:{message}");

                        string message2 = $"RabbitMQ Direct {i + 1} info Message";
                        var body2 = Encoding.UTF8.GetBytes(message);
                        channel.BasicPublish(exchangeName, routingKey: "info", properties, body2);
                        Console.WriteLine($"info:{message2}");

                    }
                }
            }
        }

这里创建一个direct类型的交换机，两个路由key,一个error，一个info,两个队列，一个队列只绑定error，一个队列绑定error和info，向error和info各发10条消息。

执行代码：

图片

 查看RabbitMQ管理界面，direct_errorlog队列10条，而direct_alllog有20条，因为direct_alllog队列两个routingKey的消息都进去了。

图片

 点进去看下两个队列绑定的交换机和routingKey

图片

图片

 消费者代码：

消费者和工作队列一样，只需根据队列名消费即可，这里只消费direct_errorlog队列作示例

 public static void DirectConsumer()
        {
            string queueName = "direct_errorlog";
            var connection = RabbitMQHelper.GetConnection();
            {
                //创建信道
                var channel = connection.CreateModel();
                {
                    //创建队列
                    channel.QueueDeclare(queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
                    var consumer = new EventingBasicConsumer(channel);
                    ///prefetchCount:1来告知RabbitMQ,不要同时给一个消费者推送多于 N 个消息，也确保了消费速度和性能
                    ///global：是否设为全局的
                    ///prefetchSize:单条消息大小，通常设0，表示不做限制
                    //是autoAck=false才会有效
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: true);
                    int i = 1;
                    consumer.Received += (model, ea) =>
                    {
                        //处理业务
                        var message = Encoding.UTF8.GetString(ea.Body.ToArray());
                        Console.WriteLine($"{i},队列{queueName}消费消息长度:{message.Length}");
                        channel.BasicAck(ea.DeliveryTag, false); //消息ack确认，告诉mq这条队列处理完，可以从mq删除了
                        i++;
                    };
                    channel.BasicConsume(queueName, autoAck: false, consumer);
                }
            }
        }

普通场景中推荐使用路由模式，因为路由模式有交换机，有路由key，能够更好的拓展各种应用场景。

(5)主题模式

topics(主题)模式跟routing路由模式类似，只不过路由模式是指定固定的路由键 routingKey，而主题模式是可以模糊匹配路由键 routingKey，类似于SQL中 = 和 like 的关系。

图片

P 表示为生产者、 X 表示交换机、C1C2 表示为消费者，红色表示队列。

 topics 模式与 routing 模式比较相近，topics 模式不能具有任意的 routingKey，必须由一个英文句点号“.”分隔的字符串（我们将被句点号“.”分隔开的每一段独立的字符串称为一个单词），比如 "lazy.orange.a"。topics routingKey 中可以存在两种特殊字符"*"与“#”，用于做模糊匹配，其中“*”用于匹配一个单词，“#”用于匹配多个单词（可以是零个）。

以上图为例：

如果发送消息的routingKey设置为：

aaa.orange.rabbit，那么消息会路由到Q1与Q2，

routingKey=aaa.orange.bb的消息会路由到Q1，

routingKey=lazy.aa.bb.cc的消息会路由到Q2；

routingKey=lazy.aa.rabbit的消息会路由到 Q2（只会投递给Q2一次，虽然这个routingKey 与 Q2 的两个 bindingKey 都匹配）；

没匹配routingKey的消息将会被丢弃。

生产者代码：

public static void SendMessageTopic()
        {
            //创建连接
            using (var connection = RabbitMQHelper.GetConnection())
            {
                //创建信道
                using (var channel = connection.CreateModel())
                {
                    //声明交换机对象,fanout类型
                    string exchangeName = "topic_exchange";
                    channel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
                    //队列名
                    string queueName1 = "topic_queue1";
                    string queueName2 = "topic_queue2";
                    //路由名
                    string routingKey1 = "*.orange.*";
                    string routingKey2 = "*.*.rabbit";
                    string routingKey3 = "lazy.#";
                    channel.QueueDeclare(queueName1, true, false, false);
                    channel.QueueDeclare(queueName2, true, false, false);

                    //把创建的队列绑定交换机,routingKey指定routingKey
                    channel.QueueBind(queue: queueName1, exchange: exchangeName, routingKey: routingKey1);
                    channel.QueueBind(queue: queueName2, exchange: exchangeName, routingKey: routingKey2);
                    channel.QueueBind(queue: queueName2, exchange: exchangeName, routingKey: routingKey3);
                    //向交换机写10条消息
                    for (int i = 0; i < 10; i++)
                    {
                        string message = $"RabbitMQ Direct {i + 1} Message";
                        var body = Encoding.UTF8.GetBytes(message);
                        channel.BasicPublish(exchangeName, routingKey: "aaa.orange.rabbit", null, body);
                        channel.BasicPublish(exchangeName, routingKey: "lazy.aa.rabbit", null, body);
                        Console.WriteLine($"发送Topic消息:{message}");
                    }
                }
            }
        }

这里演示了 routingKey为aaa.orange.rabbit，和lazy.aa.rabbit的情况，第一个匹配到Q1和Q2，第二个匹配到Q2，所以应该Q1是10条，Q2有20条，

执行后看rabbitMQ界面：

图片

(6)RPC模式

与上面其他5种所不同之处，该模式是拥有请求/回复的。也就是有响应的，上面5种都没有。

RPC是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的处理业务，处理完后然后在A服务器继续执行下去，把异步的消息以同步的方式执行。

图片

 客户端(C)声明一个排他队列自己订阅，然后发送消息到RPC队列同时也把这个排他队列名也在消息里传进去，服务端监听RPC队列，处理完业务后把处理结果发送到这个排他队列，然后客户端收到结果，继续处理自己的逻辑。

RPC的处理流程：

  • 当客户端启动时，创建一个匿名的回调队列。

  • 客户端为RPC请求设置2个属性：replyTo：设置回调队列名字；correlationId：标记request。

  • 请求被发送到rpc_queue队列中。

  • RPC服务器端监听rpc_queue队列中的请求，当请求到来时，服务器端会处理并且把带有结果的消息发送给客户端。接收的队列就是replyTo设定的回调队列。

  • 客户端监听回调队列，当有消息时，检查correlationId属性，如果与request中匹配，那就是结果了。

服务端代码：

public class RPCServer
    {
        public static void RpcHandle()
        {

            var connection = RabbitMQHelper.GetConnection();
            {
                var channel = connection.CreateModel();
                {
                    string queueName = "rpc_queue";
                    channel.QueueDeclare(queue: queueName, durable: false,
                      exclusive: false, autoDelete: false, arguments: null);
                    channel.BasicQos(0, 1, false);
                    var consumer = new EventingBasicConsumer(channel);
                    channel.BasicConsume(queue: queueName,
                      autoAck: false, consumer: consumer);
                    Console.WriteLine("【服务端】等待RPC请求...");

                    consumer.Received += (model, ea) =>
                    {
                        string response = null;

                        var body = ea.Body.ToArray();
                        var props = ea.BasicProperties;
                        var replyProps = channel.CreateBasicProperties();
                        replyProps.CorrelationId = props.CorrelationId;

                        try
                        {
                            var message = Encoding.UTF8.GetString(body);
                            Console.WriteLine($"【服务端】接收到数据:{ message},开始处理");
                            response = $"消息:{message},处理完成";
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("错误:" + e.Message);
                            response = "";
                        }
                        finally
                        {
                            var responseBytes = Encoding.UTF8.GetBytes(response);
                            channel.BasicPublish(exchange: "", routingKey: props.ReplyTo,
                              basicProperties: replyProps, body: responseBytes);
                            channel.BasicAck(deliveryTag: ea.DeliveryTag,
                              multiple: false);
                        }
                    };
                }
            }
        }
       
    }

客户端：

public class RPCClient
    {
        private readonly IConnection connection;
        private readonly IModel channel;
        private readonly string replyQueueName;
        private readonly EventingBasicConsumer consumer;
        private readonly BlockingCollection<string> respQueue = new BlockingCollection<string>();
        private readonly IBasicProperties props;

        public RPCClient()
        {
            connection = RabbitMQHelper.GetConnection();

            channel = connection.CreateModel();
            replyQueueName = channel.QueueDeclare().QueueName;
            consumer = new EventingBasicConsumer(channel);

            props = channel.CreateBasicProperties();
            var correlationId = Guid.NewGuid().ToString();
            props.CorrelationId = correlationId; //给消息id
            props.ReplyTo = replyQueueName;//回调的队列名，Client关闭后会自动删除

            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var response = Encoding.UTF8.GetString(body);
                //监听的消息Id和定义的消息Id相同代表这条消息服务端处理完成
                if (ea.BasicProperties.CorrelationId == correlationId)
                {
                    respQueue.Add(response);
                }
            };

            channel.BasicConsume(
                consumer: consumer,
                queue: replyQueueName,
                autoAck: true);
        }

        public string Call(string message)
        {
            var messageBytes = Encoding.UTF8.GetBytes(message);
            //发送消息
            channel.BasicPublish(
                exchange: "",
                routingKey: "rpc_queue",
                basicProperties: props,
                body: messageBytes);
            //等待回复
            return respQueue.Take();
        }

        public void Close()
        {
            connection.Close();
        }
    }

执行代码：

static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            //启动服务端，正常逻辑是在另一个程序
            RPCServer.RpcHandle();
            //实例化客户端
            var rpcClient = new RPCClient();
            string message = $"消息id:{new Random().Next(1, 1000)}";
            Console.WriteLine($"【客服端】RPC请求中，{message}");
            //向服务端发送消息，等待回复
            var response = rpcClient.Call(message);
            Console.WriteLine("【客服端】收到回复响应:{0}", response);
            rpcClient.Close();
            Console.ReadKey();
        }

测试效果：

图片

 z执行完，客服端close后，可以接着自己的下一步业务处理。

总结：

以上便是RabbitMQ的6中模式在.net core中实际使用，其中(1)简单队列，(2)工作队列,(4)路由模式,(6)RPC模式的交换机类型都是direct，(3)发布订阅的交换机是fanout，(5)topics的交换机是topic。正常场景用的是direct，默认交换机也是direct类型的，推荐用(4)路由模式，因为指定交换机名比起默认的交换机会容易扩展场景，其他的交换机看业务场景所需使用。

下面位置可以看到交换机类型，amq.开头那几个是内置的，避免交换机过多可以直接使用。

图片

RabbitMQ 6种业务场景
weixin_33860528的博客
05-22 3368
应用场景1-“Hello Word”一个P向queue发送一个message，一个C从该queue接收message并打印。producer，连接至RabbitMQ Server，声明队列，发送message，关闭连接，退出。应用场景2-work queues工作队列（又称：任务队列——Task Queues）是为了避免等待一些占用大量资源、时间的操作。当我们把任务（Task...
rabbitMQ实战
10-10
### RabbitMQ实战知识点详解 #### 一、RabbitMQ简介及背景 - **RabbitMQ开发语言**: Erlang，一种面向并发的编程语言，非常适合处理大量并发连接。 - **AMQP**: 先进的消息队列协议（Advanced Message Queuing ...
RabbitMQ简介及其六种工作模式
样young的博客
07-14 816
本文参考自： https://blog.csdn.net/kavito/article/details/91403659 https://www.cnblogs.com/zpKang/p/13599813.html 什么是消息队列 MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，
RabbitMQ学习：RabbitMQ的六种工作模式终结篇(四)
Java笔记虾
03-17 686
来源：my.oschina.net/u/4115134/blog/3228182前言，在前面我讲到了RabbitMQ的六种工作模式中简单模式和工作模式，这里呢，我就一次性将剩下的四种--发...
RabbitMQ超详细的使用笔记（各种工作模式+可靠生产消费+死信队列等）
weixin_45819165的博客
08-07 1336
消息队列协议 网络协议三要素 rabbitMq采用amqp协议 消息分发策略和机制 轮询分发不考略服务器性能，没有时间倾斜性，公平分发类似能者多劳，性能好就多消费 什么是高可用？ ...
RabbitMQ概述及--工作模式
m0_48639280的博客
09-06 221
MQ 的基本概念 概念 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进 行通信。 下面是传统方式，上面是消息队列方式。 MQ 的优势和劣势 既然 MQ 有优势也有劣势，那么使用 MQ 需要满足什么条件呢？ ① 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明 明下层的动作还没做，上层却当成动作做完了继续往后走，即所谓异步成为了可能。 ② 容许短暂的不一致性。 ③ 确实是用了有效果。即解耦、提速、
RabbitMQ实战：三大模式详解及代码示例
"RabbitMQ最常用的三大模式实例解析，包括Direct模式、Fanout模式和Topic模式，通过示例代码详细解析了如何在实际应用中使用这些模式进行消息传递。" 在RabbitMQ中，有多种交换机（Exchange）类型用于处理消息路由...
Python实战：RabbitMQ六种消息模型详解与示例
在本文中，我们将深入探讨如何使用Python实现RabbitMQ的6种消息模型，以及RabbitMQ相对于Redis的优势和适用场景。首先，让我们了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，它遵循Advanced ...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
RabbitMQ实战资源
11-13
本资源集合包含了RabbitMQ的实战示例、工作模式以及常见问题的解决方案，旨在帮助开发者深入理解和有效应用RabbitMQ。 ### 1. RabbitMQ工作模式 RabbitMQ的核心概念是生产者、消费者和消息队列。在实际应用中，...
C# RabbitMQ Helper 帮助类
10-25
C# RabbitMQ Helper 帮助类，类库项目，可封装为DLL，.Net RabbitMQ Helper 帮助类，一个Net类库项目，可以发布为DLL，直接引用到你的项目中。
RabbitMqHelper.cs+RabbitMQ.Client.dll
10-26
(C#/.Net版) RabbitMqHelper 帮助类，外加 RabbitMQ.Client.dll，亲手完美封装的类库非常好用，欢迎下载！
rabbitMQ封装c#
08-23
rabbitmq封装，采用连接池，频道也是采用连接池。减少频繁连接造成的资源消耗。如果代码有误的地方请指出。
rabbitmq.net各种实例
08-15
rabbitma.net 分发，点对点，应答，广播、各种实例代码
集群及高可用之LVS负载均衡(三种工作模式介绍)
抛物线的博客
07-13 938
linux自动化运维也好，云计算自动化运维也罢，基础技术都必须掌握严实，今天我们一起来完整的介绍一下真正的集群以及高可用技术中的LVS负载均衡技术。博客的引入内容是参考博客园的一位博主的文字内容，又加以详细补充完善，加上自己实践的两种LVS的工作模式。 参考的博客园：https://www.cnblogs.com/xiaocheche/p/7695024.html 1.1 什么是集群？ 随着互联网...
RabbitMqHelper 消息队列帮助类
weixin_30725467的博客
07-24 1443
using Newtonsoft.Json;using RabbitMQ.Client;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace RabbitMQ_Send{ class Conf...
它让你1小时精通RabbitMQ消息队列
最新发布
.Net技术、软件架构、人工智能、数字化转型、DeveloperSharp、微服务、工业互联网、智能制造
02-06 1059
若是在.Net Core环境下，你则需要在DeveloperSharp.json文件中添加“DeveloperSharp.RabbitMQ”节点（如下配置示例），并把DeveloperSharp.json文件放到程序执行目录中（即bin目录下与dll、exe等文件的同一目录中，放错了位置会报错）（注意：有些.Net Core版本在Visual Studio“调试”时，不会在bin目录下生成全部的dll、exe，此时需要把此配置文件放在应用程序的“根目录”下）。有些场景下，我们希望为使用的消息设定有效期。
【RabbitMQ】集群和运维
qq_43745578的博客
01-17 1539
RabbitMQ集群和运维
.Net全网最简RabbitMQ操作【强烈推荐】
2301_78287784的博客
06-09 866
~“世界5，你好！（其它说明：为了演示便利，文本前面给出的几个代码示例中，把SendMessage、GetMessage、UseMessage三个方法都放到了同一段代码程序中，这样做不好，偶尔会造成一些资源冲突。若是在.Net Core环境下，你则需要在appsettings.json文件中添加“DeveloperSharp.RabbitMQ”节点（如下配置示例），并把appsettings.json文件放到程序执行目录中（即bin目录下与dll、exe等文件的同一目录中）（放错了位置会报错）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值