rabbitmq使用_C#队列学习笔记：RabbitMQ安装及使用

最新推荐文章于 2024-03-02 16:26:40 发布
最新推荐文章于 2024-03-02 16:26:40 发布
阅读量207 收藏
点赞数
文章标签： rabbitmq使用 rabbitmq实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39810856/article/details/111295739
版权
本文详细介绍了RabbitMQ在Windows环境下的安装步骤，并通过.NET演示了如何创建发送和接收消息的客户端，以及如何使用工作队列、消息持久化、公平分发、Exchange（包括fanout、direct、topic类型）和RPC。内容涵盖了从基本概念到高级特性的应用，帮助读者深入理解RabbitMQ在分布式系统中的应用。
摘要由CSDN通过智能技术生成

   一、环境搭建

    1.1、由于RabbitMQ是使用Erlang语言开发的，因此要安装Erlang运行时环境，下载地址：Erlang官网下载  CSDN分享下载

    1.2、去RabbitMQ官网下载RabbitMQ Server服务端程序，选择合适的平台版本下载并安装。

    RabbitMQ安装时，会自动在Windows服务中创建RabbitMQ服务，并自动启动。

d1bd2c8b3907cd6d5c2361748ca48a59.png

    1.3、开始->所有程序->RabbitMQ Server->RabbitMQ Command Prompt (sbin dir)：

e25e962e26ad3e1303bb8aeaa5f75d6f.png

    运行RabbitMQ Command Prompt与cmd下cd C:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.3\sbin的效果是一样的。

    1.3.1、sbin目录下的rabbitmqctl.bat，是用来查看和控制服务端状态的。运行rabbitmqctl status检查RabbitMQ状态：

6991ff74b5b0fd8e3550ca571272635e.png

    1.3.3、RabbitMQ Server上面也有用户概念，使用rabbitmqctl list_users命令，可以看到目前的用户：

ace742c281c5f5e76280efdb4a8e78a0.png

    可以看到，现在只有一个名为gues角色为administratort的用户，这个是RabbitMQ默认为我们创建的，它有RabbitMQ的所有权限。一般情况下，我们需要新建一个自己的用户，并设置密码及授予权限，同时设置为管理员。操作方法如下：

rabbitmqctl add_user hello world
rabbitmqctl set_permissions hello ".*" ".*" ".*"
rabbitmqctl set_user_tags hello administrator

ff4cb7c2eb8945c84fde152a44cab02d.png

    上面的第一命令添加了一个名为hello的用户并设置了密码world；第二条命令为用户hello分别授予对所有消息队列的配置、读和写的权限；第三条命令将用户hello设置为管理员。

    现在我们可以将默认的guest用户删掉，使用下面的命令即可：

rabbitmqctl delete_user guest

    如果要修改密码，可以使用下面的命令：

rabbitmqctl change_password {username} {newpassowrd}

   二、管理界面

    RabbitMQ还有一个管理界面，是以插件形式提供的，通过该界面可以查看RabbitMQ Server当前的状态。启用命令如下： 

rabbitmq-plugins enable rabbitmq_management

7fcd6c27132466c184d680d099211bad.png

    现在，在浏览器中输入 http://server-name:15672/ 即可。

    注：server-name为计算机名或IP地址，如果是本地的，直接用localhost即可。登录界面，使用我们之前创建的hello用户登录。

d4b09f785b55bb22d77622c35ff99bf7.png

    三、开始使用

    在.NET中使用RabbitMQ需要下载RabbitMQ客户端程序集，下载解压后在bin下找到RabbitMQ.Client.dll，并添加引用到项目中。

    3.1、Hello World

    为了展示RabbitMQ的基本使用，我们发送一个HelloWorld消息，然后接收并处理。

c62a55aa82be2e3ec87d7971c0475d45.png

    3.1.1、创建一个名为Send的客户端控制台程序，用来将消息发送到RabbitMQ消息队列中，代码如下：

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.声明队列
                    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);//5.构建byte消息数据包string message = args.Length > 0 ? args[0] : "Hello World";var body = Encoding.UTF8.GetBytes(message); //消息是以二进制数组的形式传输的//6.发送数据包
                    channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: null, body: body);
                    Console.WriteLine($"Send {message}");
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    3.1.2、创建一个名为Receive的服务端控制台程序，用来接收RabbitMQ消息队列中的消息，代码如下：

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列
                    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);//5.构造消费者实例var consumer = new EventingBasicConsumer(channel);//6.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);
                        Console.WriteLine($"Received {message}");
                    };//7.启动消费者
                    channel.BasicConsume(queue: "hello", noAck: true, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    3.1.3、先运行消息接收端，再运行消息发送端，结果如下：

635be8baa05166da934ba8513ca08e36.png

    从上面的代码中可以看出，发送端和接收端的代码前4步都是一样的。主要的区别在于发送端调用channel.BasicPublish方法发送消息，而接收端需要实例化一个EventingBasicConsumer实例来进行消息处理。另外一点需要注意的是：消息接收端和发送端的队列名称(queue)必须保持一致，这里指定的队列名称为hello。

    3.2、工作队列

c281c48771bb5d4f1412ba55d224d372.png

    工作队列(work queues，又称Task Queues)的主要思想是：为了避免立即执行一些实时性要求不高但是比较耗资源或时间的操作(如写日志)，把任务当作消息发送到队列中，由一个运行在后台的工作者(worker)进程取出并处理。当有多个工作者(workers)运行时，任务会在它们之间共享。

    现在发送一些字符串来模拟耗时的任务，在字符串中加上点号(.)来表示任务的复杂程度。一个点号将会耗时1秒钟，比如"Hello World..."就会耗时3秒钟。

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.声明队列
                    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);//5.构建byte消息数据包string message = args.Length > 0 ? string.Join(" ", args) : "Hello World...";var properties = channel.CreateBasicProperties();
                    properties.DeliveryMode = 2;//设置消息是否持久化 1：非持久化 2：持久化var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包
                    channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: null, body: body);
                    Console.WriteLine($"Send {message}");
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列
                    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);//5.构造消费者实例var consumer = new EventingBasicConsumer(channel);//6.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");
                    };//7.启动消费者
                    channel.BasicConsume(queue: "hello", noAck: true, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    3.3轮询分发

    使用工作队列的一个好处就是它能够并行的处理队列。如果堆积了很多任务，我们只需要添加更多的工作者(workers)就可以了，扩展很简单。

    现在，我们先启动两个接收端，等待接受消息，然后启动一个发送端开始发送消息(cmd->send.exe所在的目录)。

fe2ffb69780c5bebe205f9a507d11e42.png

285a4fea418f96d8cc474ad3c01b7d5b.png

    上面发了10条信息，两个接收端各收到5条信息。

    默认情况下，RabbitMQ会将每个消息按照顺序依次分发给下一个消费者，所以每个消费者接收到的消息个数大致是平均的。这种消息分发的方式称之为轮询(round-robin)。

    3.4、消息响应

    当处理一个比较耗时得任务的时候，也许想知道消费者(consumers)是否运行到一半就挂掉。在当前的代码中，当RabbitMQ将消息发送给消费者之后，马上就会将该消息从队列中移除。此时，如果把处理这个消息的工作者(worker)停掉，正在处理的这条消息就会丢失。同时，所有发送到这个工作者的还没有处理的消息都会丢失。

    我们不想丢失任何任务消息，如果一个工作者挂掉了，我们希望该消息能够重新发送给其它的工作者。

    为了防止消息丢失，RabbitMQ提供了消息响应(acknowledgments)机制。消费者会通过一个ack(响应)，告诉RabbitMQ已经收到并处理了某条消息，然后RabbitMQ才会释放并删除这条消息。如果消费者挂掉了，没有发送响应，RabbitMQ就会认为消息没有被完全处理，然后重新发送给其它消费者。这样，即使工作者偶尔的挂掉，也不会丢失消息。

    消息是没有超时这个概念的。当工作者与它断开连的时候，RabbitMQ会重新发送消息。这样在处理一个耗时非常长的消息任务的时候就不会出问题了。

    消息响应默认是开启的。在之前的例子中使用了no_Ack=true标识把它关闭。是时候移除这个标识了，当工作者完成了任务，就会发送一个响应。

    下面修改Receive.cs，主要改动的是：将 autoAck:true修改为autoAck:fasle，以及在消息处理完毕后手动调用BasicAck方法进行手动消息确认。

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列
                    channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);//5.构造消费者实例var consumer = new EventingBasicConsumer(channel);//6.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//7.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };//8.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: "hello", noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    一个很常见的错误就是忘掉了BasicAck这个方法，这个错误很常见，但是后果很严重。当客户端退出时，待处理的消息就会被重新分发，但是RabitMQ会消耗越来越多的内存，因为这些没有被应答的消息不能够被释放。调试这种case，可以使用rabbitmqctl打印messages_unacknowledged字段。

C:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.3\sbin>rabbitmqctl list_queues name messages_ready messages_unacknowledged
Timeout: 60.0 seconds ...
Listing queues for vhost / ...
name    messages_ready  messages_unacknowledged
hello   1       0
    3.5、消息持久化

    消息确认确保了即使消费端异常，消息也不会丢失能够被重新分发处理。但是如果RabbitMQ服务端异常，消息依然会丢失。除非我们指定durable:true，否则当RabbitMQ退出或崩溃时，消息将依然会丢失。通过指定durable:true(队列)，并指定Persistent=true(消息)，来告知RabbitMQ将消息持久化。一句话概括：需要保证队列和消息都是持久化的。

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.声明队列(指定durable:true，告知rabbitmq对消息进行持久化。)
                    channel.QueueDeclare(queue: "hello", durable: true, exclusive: false, autoDelete: false, arguments: null);//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构建byte消息数据包string message = args.Length > 0 ? args[0] : "Hello World";var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包(指定basicProperties)
                    channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: properties, body: body);
                    Console.WriteLine($"Send {message}");
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列(指定durable:true，告知rabbitmq对消息进行持久化。)
                    channel.QueueDeclare(queue: "hello", durable: true, exclusive: false, autoDelete: false, arguments: null);//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构造消费者实例var consumer = new EventingBasicConsumer(channel);//6.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//7.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };//8.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: "hello", noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    将消息标记为持久性不能完全保证消息不会丢失。虽然它告诉RabbitMQ将消息保存到磁盘，但是当RabbitMQ接受消息并且还没有保存时，仍然有一个很短的时间窗口。RabbitMQ可能只是将消息保存到了缓存中，并没有将其写入到磁盘上。持久化不是一定能够保证的，但是对于一个简单任务队列来说已经足够。

    如果需要确保消息队列的持久化，可以使用publisher confirms。

    3.6、公平分发

    你可能会注意到，消息的分发可能并没有如我们想要的那样公平分配。比如，对于两个工作者。当奇数个消息的任务比较重但是偶数个消息任务比较轻时，奇数个工作者始终处于忙碌状态，而偶数个工作者始终处于空闲状态，但是RabbitMQ并不知道这些，它仍然会平均依次地分发消息。

    为了改变这一状态，我们可以使用basicQos方法，设置perfetchCount=1 。这样就告诉RabbitMQ 不要在同一时间给一个工作者发送多于1个的消息。换句话说，在一个工作者还在处理消息并且没有响应消息之前，不要给它分发新的消息，而是将这条新的消息发送给下一个不那么忙碌的工作者。

6b30435843823513e11e36ce200e8529.png

a763ac6b9ae97041f6c57047650517ff.png

//Receive.cs//4.声明队列(指定durable:true，告知rabbitmq对消息进行持久化。)//channel.QueueDeclare(queue: "hello", durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.QueueDeclare("hello", true, false, false, null);//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
properties.Persistent = true;//设置prefetchCount : 1来告知RabbitMQ，在未收到消费端的消息确认时，不再分发消息。//channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
channel.BasicQos(0, 1, false);

a763ac6b9ae97041f6c57047650517ff.png

    3.7完整实例

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.声明队列(指定durable:true，告知rabbitmq对消息进行持久化。)
                    channel.QueueDeclare(queue: "hello", durable: true, exclusive: false, autoDelete: false, arguments: null);//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构建byte消息数据包string message = args.Length > 0 ? args[0] : "Hello World";var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包(指定basicProperties)
                    channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: properties, body: body);
                    Console.WriteLine($"Send {message}");
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region Hello World//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列(指定durable:true，告知rabbitmq对消息进行持久化。)
                    channel.QueueDeclare(queue: "hello", durable: true, exclusive: false, autoDelete: false, arguments: null);//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//设置prefetchCount : 1来告知RabbitMQ，在未收到消费端的消息确认时，不再分发消息。
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);//5.构造消费者实例var consumer = new EventingBasicConsumer(channel);//6.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//7.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);//8.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: "hello", noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    四、Exchange

    上面的示例，生产者和消费者直接是通过相同队列名称进行匹配衔接的。消费者订阅某个队列，生产者创建消息发布到队列中，队列再将消息转发到订阅的消费者。这样就会有一个局限性，即消费者一次只能发送消息到某一个队列。

    那消费者如何才能发送消息到多个消息队列呢？

    RabbitMQ提供了Exchange，它类似于路由器的功能，对消息进行路由，将消息发送到多个队列上。Exchange一方面从生产者接收消息，另一方面将消息推送到队列。但是Exchange是如何知道将消息附加到哪个队列或者直接忽略的呢？这些其实是由Exchange Type来定义的。关于Exchange的图文介绍，请看上一篇《C#队列学习笔记：RabbitMQ基础知识》，此处仅提供示例代码。

    4.1、fanout

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region fanout exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.使用fanout exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "fanoutEC", type: "fanout");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构建byte消息数据包for (int i = 1; i <= 10; i++)
                    {string message = args.Length > 0 ? args[0] : "Hello World" + new string('.', i);var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包(指定exchange；fanout类型无需指定routingKey；指定basicProperties)
                        channel.BasicPublish(exchange: "fanoutEC", routingKey: "", basicProperties: properties, body: body);
                        Console.WriteLine($"Send {message}");
                    }
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region fanout exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.使用fanout exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "fanoutEC", type: "fanout");//5.声明队列(随机生成队列名称)var queueName = channel.QueueDeclare().QueueName;//绑定队列到指定fanout类型exchange，fanout类型无需指定routingKey。
                    channel.QueueBind(queue: queueName, exchange: "fanoutEC", routingKey: "");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//设置prefetchCount : 1来告知RabbitMQ，在未收到消费端的消息确认时，不再分发消息。
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);//6.构造消费者实例var consumer = new EventingBasicConsumer(channel);//7.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//8.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };//9.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: queueName, noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    4.2、direct

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region direct exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.使用direct exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "directEC", type: "direct");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构建byte消息数据包for (int i = 1; i <= 10; i++)
                    {string message = args.Length > 0 ? args[0] : "Hello World" + new string('.', i);var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包(指定exchange；direct类型必须指定routingKey；指定basicProperties)
                        channel.BasicPublish(exchange: "directEC", routingKey: "green", basicProperties: properties, body: body);
                        Console.WriteLine($"Send {message}");
                    }
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region direct exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.使用direct exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "directEC", type: "direct");//5.声明队列(随机生成队列名称)var queueName = channel.QueueDeclare().QueueName;//绑定队列到指定direct类型exchange，direct类型必须指定routingKey。
                    channel.QueueBind(queue: queueName, exchange: "directEC", routingKey: "green");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//设置prefetchCount : 1来告知RabbitMQ，在未收到消费端的消息确认时，不再分发消息。
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);//6.构造消费者实例var consumer = new EventingBasicConsumer(channel);//7.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//8.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };//9.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: queueName, noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    4.3、topic

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region topic exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.使用topic exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "topicEC", type: "topic");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//5.构建byte消息数据包for (int i = 1; i <= 10; i++)
                    {string message = args.Length > 0 ? args[0] : "Hello World" + new string('.', i);var body = Encoding.UTF8.GetBytes(message);//消息是以二进制数组的形式传输的//6.发送数据包(指定exchange；topic类型必须指定routingKey；指定basicProperties)
                        channel.BasicPublish(exchange: "topicEC", routingKey: "first.green.fast", basicProperties: properties, body: body);
                        Console.WriteLine($"Send {message}");
                    }
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region topic exchange type//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.使用topic exchange type，指定exchange名称。
                    channel.ExchangeDeclare(exchange: "topicEC", type: "topic");//5.声明队列(随机生成队列名称)var queueName = channel.QueueDeclare().QueueName;//绑定队列到指定topic类型exchange，topic类型必须指定routingKey。
                    channel.QueueBind(queue: queueName, exchange: "topicEC", routingKey: "#.*.fast");//将消息标记为持久性 - 将IBasicProperties.SetPersistent设置为truevar properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//设置prefetchCount : 1来告知RabbitMQ，在未收到消费端的消息确认时，不再分发消息。
                    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);//6.构造消费者实例var consumer = new EventingBasicConsumer(channel);//7.绑定消息接收后的事件委托
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int dots = message.Split('.').Length - 1;
                        Thread.Sleep(dots * 1000);
                        Console.WriteLine($"Received {message}");//8.发送消息确认信号(手动消息确认)
                        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
                    };//9.启动消费者(noAck: false 启用消息响应)
                    channel.BasicConsume(queue: queueName, noAck: false, consumer: consumer);
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    五、RPC

    RPC--Remote Procedure Call，远程过程调用。RabbitMQ是如何进行远程调用的呢？示意图如下：

e7dec62347d0819c5f048f0f74287e7f.png

    第一步：主要是进行远程调用的客户端需要指定接收远程回调的队列，并声明消费者监听此队列。

    第二步：远程调用的服务端除了要声明消费端接收远程调用请求外，还要将结果发送到客户端用来监听结果的队列中去。

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region rpc//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.建立信道using (var channel = connection.CreateModel())
                {//4.声明唯一guid用来标识此次发送的远程调用请求var correlationId = Guid.NewGuid().ToString();//5.声明需要监听的回调队列var replyQueue = channel.QueueDeclare().QueueName;var properties = channel.CreateBasicProperties();
                    properties.Persistent = true;//将消息标记为持久性
                    properties.ReplyTo = replyQueue;//指定回调队列
                    properties.CorrelationId = correlationId;//指定消息唯一标识//6.构建byte消息数据包string number = args.Length > 0 ? args[0] : "30";var body = Encoding.UTF8.GetBytes(number);//7.发送数据包
                    channel.BasicPublish(exchange: "", routingKey: "rpc_queue", basicProperties: properties, body: body);
                    Console.WriteLine($"Request fib({number})");//8.创建消费者用于处理消息回调(远程调用返回结果)var callbackConsumer = new EventingBasicConsumer(channel);
                    channel.BasicConsume(queue: replyQueue, noAck: false, consumer: callbackConsumer);
                    callbackConsumer.Received += (model, ea) =>
                    {//仅当消息回调的ID与发送的ID一致时，说明远程调用结果正确返回。if (ea.BasicProperties.CorrelationId == correlationId)
                        {var responseMsg = $"Get Response: {Encoding.UTF8.GetString(ea.Body)}";
                            Console.WriteLine($"{responseMsg}");
                        }
                    };
                    Console.Read();
                }
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

bd75cd5a2b0dc323687cd46643009745.png

a763ac6b9ae97041f6c57047650517ff.png

    class Program
    {static void Main(string[] args)
        {#region rpc//1.实例化连接工厂var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "hello",
                Password = "world"
            };//2.建立连接using (var connection = factory.CreateConnection())
            {//3.创建信道using (var channel = connection.CreateModel())
                {//4.声明队列接收远程调用请求
                    channel.QueueDeclare(queue: "rpc_queue", durable: true, exclusive: false, autoDelete: false, arguments: null);var consumer = new EventingBasicConsumer(channel);
                    Console.WriteLine("Waiting for message.");//5.请求处理逻辑
                    consumer.Received += (model, ea) =>
                    {var message = Encoding.UTF8.GetString(ea.Body);int n = int.Parse(message);
                        Console.WriteLine($"Receive request of Fib({n})");int result = Fib(n);//6.从请求的参数中获取请求的唯一标识，在消息回传时同样绑定。var properties = ea.BasicProperties;var replyProerties = channel.CreateBasicProperties();
                        replyProerties.CorrelationId = properties.CorrelationId;//7.将远程调用结果发送到客户端监听的队列上
                        channel.BasicPublish(exchange: "", routingKey: properties.ReplyTo,
                            basicProperties: replyProerties, body: Encoding.UTF8.GetBytes(result.ToString()));//8.手动发回消息确认
                        channel.BasicAck(ea.DeliveryTag, false);
                        Console.WriteLine($"Return result: Fib({n})= {result}");
                    };
                    channel.BasicConsume(queue: "rpc_queue", noAck: false, consumer: consumer);
                    Console.Read();
                }
            }int Fib (int n)
            {if (n <= 2)return 1;elsereturn Fib(n - 1) + Fib(n - 2);
            }#endregion
        }
    }

a763ac6b9ae97041f6c57047650517ff.png

    六、总结

    本文介绍了RabbitMQ消息代理在Windows上的安装以及在.NET中的使用。消息队列在构建分布式系统、提高系统的可扩展性及响应性方面，有着很重要的作用。

    参考自：

    https://www.cnblogs.com/yangecnu/p/Introduce-RabbitMQ.html#!comments

    https://www.cnblogs.com/sheng-jie/p/7192690.html

出处：

https://www.cnblogs.com/atomy/archive/2020/04/03/12592749.html

版权申明：本文来源于网友收集或网友提供，如果有侵权，请转告版主或者留言，本公众号立即删除。

d7a0819d1ade2f39f0dd4c16a95f4fd6.gif

weixin_39810856
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 对RabbitMQ使用
qq_42335551的博客
10-13 3211
为了知道消息是否成功推送到RabbitMQ服务器上，我们需要开启Confirm模式。在消费者中 确保消息成功消费 取消自动autoAck，改成手动。
C#.NetCore RabbitMQ和ErLang安装使用-RabbitMQ工作模式
liyonghewangtao的博客
02-06 314
RabbitMQ Windows版本安装
C# 使用 RabbitMQ 的详细使用方法
最新发布
仰望星空的博客
03-02 2918
RabbitMQ 是一个功能强大的消息队列系统，可用于在分布式系统中进行可靠的消息传递。本篇博客将详细介绍如何在 C# 中使用 RabbitMQ 实现各种消息队列操作，包括连接 RabbitMQ 服务器、创建通道、声明队列、发布消息以及消费消息等。RabbitMQ 是一个开源的消息代理软件，实现了 AMQP（Advanced Message Queuing Protocol）协议，提供了可靠的消息传递机制。
C#使用rabbitmq （简单例子）
罗汉松驻扎的工作基地
05-31 2227
然后做一个help类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using EasyNetQ; using EasyNetQ.Topology; namespace ConsoleAppPublish { ..
RabbitMQ 获取队列信息
li953348869的博客
03-14 4314
RabbitManagementTemplate rabbitManagementTemplate=new RabbitManagementTemplate("http://47.115.31.214:15672/api","work-wechat-dev","12345678"); List<org.springframework.amqp.core.Queue> contextQueues = rabbitManagementTemplate.getQueues()...
淘宝RabbitMQ实验资料_的安装管理以性能优化使用方案及测试_rabbitmq_
10-03
通过以上内容的学习和实践，你可以更好地掌握 RabbitMQ 的使用，包括安装、管理、性能优化和测试，从而在实际项目中发挥出 RabbitMQ 的强大功能。记得结合提供的"淘宝RabbitMQ实验资料"进行深入研究，以获得更丰富的...
rabbitmq_delayed_message_exchange-3.8.0.7z
04-06
安装一个插件即可：...接下来，进入RabbitMQ的安装目录下的sbin目录，执行下面命令让该插件生效，然后重启RabbitMQ。 rabbitmq-plugins enable rabbitmq_delayed_message_exchange
rabbitmq_delayed_message_exchange-3.8.0 延迟队列插件
05-30
安装这个插件非常简单，只需要将`rabbitmq_delayed_message_exchange-3.8.0.ez`文件放置到RabbitMQ服务器的`/plugins`目录下，然后使用RabbitMQ管理控制台或者命令行工具启用它。启用命令通常是`rabbitmq-plugins ...
Release_rabbitmq_C#源码_
09-30
标题中的"Release_rabbitmq_C#源码_"表明这是一个关于RabbitMQ的C#源代码发布版本，可能包含了实现RabbitMQ在C#环境中使用的示例或者库。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中，用于...
rabbitmq_http_api_client：Ruby的RabbitMQ HTTP API客户端
02-03
获取群集节点状态（已使用＃个文件描述符，RAM消耗等） 获取有关交换，队列，绑定的信息 关闭客户端连接 获取有关虚拟主机，用户，权限的信息 获取有关已启用的插件，协议，其端口等的信息 管理虚拟主机，用户，...
RabbitMq安装教程（超详细） 与使用
qq_22905801的博客
03-31 6433
安装准备工具安装步骤（图文）RabbitMq简介1.1消息队列中间件简介消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 使用较多的消息队列有 ActiveMQ（安全），RabbitMQ，ZeroMQ，Kafka（大数据），MetaMQ，RocketMQ以下介绍消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和消息通讯四个场景1.2什么是RabbitMQ。
【C#】RabbitMQ入门指南（一）
catshitone的专栏
07-17 1万+
文章目录1.简介2. 相关概念2.1 消息中间件2.2 消息中间件的作用2.3 RabbitMQ中的一些概念2.4 RabbitMQ模型3. 点对点3.1 轮询消费3.2 手动发送ACK与数据持久存储4.发布订阅4.1 交换机（Exchange）4.2 `fanout`交换机4.3 路由（Routing）4.3.1 `Direct`交换机4.4 主题（Topics）4.4.1 `Topic`交换机4.4.2 最终实现5. 远程过程调用（RPC）6. 发布确认（Publisher Confirms）6.1 发
RabbitMQ在windows上安装部署&C#代码实现RabbitMQ通讯
magicchz的博客
03-08 821
RabbitMQ部署安装，已经C#代码实现通讯。从零到入门使用RabbitMQ.
RabbitMQ Client封装连接及业务处理接口
u010989191的博客
01-05 1283
一、RabbitMQ介绍 RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而群集和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 二、rabbitMQ安装 RabbitMQ Download 参考安装博客 三、封装RabbitMqClient.java import java.io.IOException; import org.apache.commons.lang.
C# 使用RabbitMQ（二）安装
你要明白，任何问题都不是孤立存在的，一定有人曾经遇到过，并且已经有更好的解决办法了，只是我还不知道。我不应该在黑暗中独自前行，去重新发明轮子，也许我的顿悟，只是别人的基本功！我应该要站在巨人的肩膀上，学习更成熟的经验和方法，然后再来解决这个问题
08-18 862
1.下载并安装RabbitMQ，当前版本是3.9 我们要查看与Erlang的对应关系 ps：必须先要安装Erlang 下载地址下载链接 点进超链接我们看到对应的Erlang版本是23.2-24.X之间，所以我们选的Erlang版本应该介于23.2-24.X 我们根据rabbitMQ对应的版本去下载Erlang 下载地址下载链接 安装Erlang 安装 RabbitMQ 配置RabbitMQ 1、首先以管理员身份打开 CMD(命令提示符)，CD到安装目录的 sbin文件夹下执行 rabbitmq-p
NET 环境中使用RabbitMQ
weixin_34310785的博客
01-28 173
一 环境搭建 首先，由于RabbitMQ使用Erlang编写的，需要运行在Erlang运行时环境上，所以在安装RabbitMQ Server之前需要安装Erlang 运行时环境，可以到Erlang官网下载对应平台的安装文件。如果没有安装运行时环境，安装RabbitMQ Server的时候，会提示需要先安装Erlang环境。 安装完成之后，确保已经将Erlang的安装路径注册到系统的环境变量...
如何在 C# 中使用 RabbitMQ
dotNET跨平台
11-29 586
译文链接：https://www.infoworld.com/article/3200210/how-to-work-with-rabbitmq-in-c.htmlRabbitMQ 是一...
RabbitMQ教程(安装与使用详解,Spring集成)
热门推荐
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
Windows C# RabbitMQ 安装--配置--信息收发
jack_dos的博客
11-08 2822
前言         近期要实现一个图片异步上传的需求，需要用到RabbitMQ，辅助客户端完成对高并发请求的处理。 一、安装Erlang 由于RabbitMQ服务器是用Erlang语言编写，所以我们需要先安装Erlang环境，本文使用的版本是erl-24.1 下载地址： https://github.com/erlang/otp/releases/download/OTP-24.1/otp_win64_24.1.exe
"WARNING: Using RABBITMQ_ADVANCED_CONFIG_FILE: C:\Users\佳琦\AppData\Roaming\RabbitMQ\advanced.config"
07-27
回答: 这个警告信息是在安装RabbitMQ后运行rabbitmq-server时出现的。警告信息中指出正在使用RABBITMQ_ADVANCED_CONFIG_FILE配置文件，并给出了文件路径。\[1\]\[2\]根据你提供的引用内容，你可能遇到了Erlang版本与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值