RabbitMQ七种工作模式

概念

   ☞ RabbitMQ的一个消息代理：它接受并转发消息。
   ☞ 你可以把它当成一个邮局：当你想邮寄信件的时候，你会把信件放在投 
   递箱中，并确信邮递员最终会将信件送到收件人的手里。在这个例子中，
   RabbitMQ就相当于投递箱、邮局和邮递员。
   ☞ AMQP协议中的核心思想就是生产者和消费者隔离，生产者从不直接将消
   息发送给队列。生产者通常不知道是否一个消息会被发送到对队列中，只是
   将消息发送到一个交换机（Exchange）。先由交换机（Exchange）来接
   收，然后交换机（Exchange）按照特定的策略转发Queue进行存储。同
   理，消费者也是如此。交换机（Exchange），转发各个消息分发到对应的
   队列。
  (参考链接：https://blog.youkuaiyun.com/qq_33040219/article/details/82383127)

一. simple：简单模式

1. 要点

一个生产者，一个消费者。

2. 原理

☞ 消息发布者（Publish）将消息放入队列（默认交换机）。
☞ 消息的消费者（Consumer）监听（while）消息队列，如果队列中有消
息，就消费掉，消息被拿走后，自动从队列中删除（隐患：消息可能没有被
消费者正确处理，已经从队列中消失了，造成消息的丢失）。应用场景：聊
天（中间有一个过度的服务器；P端，C端）。

3. 代码演示

3.1 发布端（Publish）

using RabbitMQ.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace KibaRabbitMQSend
{
   
    class Program
    {
   
        static void Main(string[] args)
        {
   
            var factory = new ConnectionFactory();
            factory.HostName = "localhost";//主机名，Rabbit会拿这个IP生成一个endpoint，这个很熟悉吧，就是socket绑定的那个终结点。
            factory.UserName = "guest";//默认用户名,用户可以在服务端自定义创建，有相关命令行
            factory.Password = "guest";//默认密码
            using (var connection = factory.CreateConnection())//连接服务器，即正在创建终结点。
            {
   
                //创建一个通道，这个就是Rabbit自己定义的规则了，如果自己写消息队列，这个就可以开脑洞设计了
                //这里Rabbit的玩法就是一个通道channel下包含多个队列Queue
                using (var channel = connection.CreateModel())
                {
   
                    //                               持久化 
                    channel.QueueDeclare("kibaQueue", false, false, false, null);//创建一个名称为kibaqueue的消息队列
                    var properties = channel.CreateBasicProperties();
                    //properties.DeliveryMode = 1;//1：非持久化；2：持久化
                    string message = "I am Kiba518"; //传递的消息内容
                    channel.BasicPublish(string.Empty, "kibaQueue", null, Encoding.UTF8.GetBytes(message)); //生产消息
                    Console.WriteLine($"Send:{message}");
                    Console.ReadKey();
                }
            }
        }
    }
}

启动成功后，消息被发布，如图：

3.2 消费端（Consumer）

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KibaRabbitMQReceived
{
   
    class Program
    {
   
        static void Main(string[] args)
        {
   
            var factory = new ConnectionFactory();
            factory.HostName = "localhost";
            factory.UserName = "guest";
            factory.Password = "guest";

            using (var connection = factory.CreateConnection())
            {
   
                using (var channel = connection.CreateModel())
                {
   
                    channel.QueueDeclare("kibaQueue", false, false, false, null);

                    /* 这里定义了一个消费者，用于消费服务器接受的消息
                     * C#开发需要注意下这里，在一些非面向对象和面向对象比较差的语言中，是非常重视这种设计模式的。
                     * 比如RabbitMQ使用了生产者与消费者模式，然后很多相关的使用文章都在拿这个生产者和消费者来表述。
                     * 但是，在C#里，生产者与消费者对我们而言，根本算不上一种设计模式，他就是一种最基础的代码编写规则。
                     * 所以，大家不要复杂的名词吓到，其实，并没那么复杂。
                     * 这里，其实就是定义一个EventingBasicConsumer类型的对象，然后该对象有个Received事件，
                     * 该事件会在服务接收到数据时触发。
                     */
                    var consumer = new EventingBasicConsumer(channel);//消费者
                    channel.BasicConsume("kibaQueue", true, consumer);//消费消息
                    consumer.Received += (model, ea) =>
                    {
   
                        var body = ea.Body;
                        var message = Encoding.UTF8.GetString(body);
                    };
                }
            }
            Console.WriteLine($"消息接收完成！");
            Console.ReadKey();
        }
    }
}

启动成功后，消息被消费，如图：

二. work：工作模式(资源的竞争)

1. 要点

一个生产者，多个消费者，消息被多个消费者竞争接收。

2. 原理

☞ 消息产生者将消息放入队列消费者可以有多个,消费者1,消费者2,同时监听
同一个队列,消息被消费。C1 C2共同争抢当前的消息队列内容,谁先拿到谁负责
消费消息(隐患：高并发情况下,默认会产生某一个消息被多个消费者共同使用,
可以设置一个开关(syncronize,与同步锁的性能不一样) 保证一条消息只能被
一个消费者使用)。
☞ 应用场景:红包;大项目中的资源调度(任务分配系统不需知道哪一个任务执
行系统在空闲,直接将任务扔到消息队列中,空闲的系统自动争抢)。

3. 代码演示

3.1 发布端（Publish）

using RabbitMQ.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Publish
{
   
    class Program
    {
   
        static void Main(string[] args)
        {
   
            var factory = new ConnectionFactory()
            {
   
                HostName = "localhost",//主机名，Rabbit会拿这个IP生成一个endpoint，这个很熟悉吧，就是socket绑定的那个终结点。
                UserName = "guest",//默认用户名,用户可以在服务端自定义创建，有相关命令行
                Password = "guest"//默认密码
            };

            #region 1. 发布/订阅方式，多个客户端（消费者）竞争处理消息，减轻单个客户端的负载压力
            //第一步：创建connection
            using (var connection = factory.CreateConnection())//连接服务器，即正在创建终结点。
            {
   
                //第二步：创建一个channel
                using (var channel = connection.CreateModel())
                {
   
                    //第三步：声明交换机（因为rabbitmq已经有了自定义的abpq default exchange,可以不用自己定义，定义了，一定要绑定 队列和交换机）
                    channel.ExchangeDeclare("myexchange", ExchangeType.Direct, true, false,null);

                    //第四步：创建一个队列（queue）
                    channel.QueueDeclare("mytest", true, false, false, null);

                    channel.QueueBind("mytest", "myexchange", "mytest", null);//交换机绑定队列

                    for (int i = 0; i < 100; i++)
                    {
   
                        var msg = Encoding.UTF8.GetBytes(string.Format("{0}：{1}", i, "您好！"));
                        //第五步：发布消息
                        channel.BasicPublish(string.Empty, routingKey: "mytest", basicProperties: null, body: msg);
                    }
                    Console.WriteLine($"Send End");
                    Console.ReadKey();
                }
            }
            #endregion 
        }
    }
}

3.2 消费端（Consumer）

using RabbitMQ