RabbitMQ路由篇

RabbitMQ路由篇

标题：轻松玩转RabbitMQ路由Exchange

搞定RabbitMQ?玩不转RabbitMQ路由就不算搞定RabbitMQ；路由？这是大家熟悉的词儿，那什么是路由呢？在我们生活中家里的无线网都有一个路由器，负责做电信号的转发，才有了我们的电脑、手机能够无线接收信号。同样的，我们的RabbitMQ就是需要通过交换机，Exchange才能把消息发送给队列Queue，也就是说生产者把消息发给交换机，然后让交换机转发给Queue。

也就是Producer发送消息是发给Exchange,Exchage转发消息给Queue。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nETbXJP3-1616122816717)(imgs/image-20210228204746216.png)]

正因为有了Exchange在中间做了一层的转发，做了一层包装，那我们就可以自己定义各种规则。那么在实际开发中，就可以满足各种各样的需求，让我们的开发更友好，更便捷。Exchage共有四种规则类型，这里讲解两种。

Exchage共有四种规则类型

1.direct类型路由

direct路由规则很简单：

exchange在和queue进行绑定时会设置routingkey，生产者在发送消息的时候，也需要指定一个key,如果指定的这个key与exchange和队列绑定的routingkey完全匹配，那么消息就可以正常的发送到绑定的queue中。

绑定key:channel.QueueBind(queue:"DirectExchangeQueue", exchange:"DirectExChange", routingKey:"key");

来个案例：

生产者代码：

public class DirectProducer
    {
        public static void Send()
        {
            var factory = new ConnectionFactory();
            factory.HostName = "localhost";//RabbitMQ服务在本地运行
            factory.UserName = "guest";//用户名
            factory.Password = "guest";//密码 
            using (var connection = factory.CreateConnection())
            {
                using (IModel channel = connection.CreateModel())
                {
                    //声明队列1---DirectExchangeQueue1
                    channel.QueueDeclare(queue: "DirectExchangeQueue1", durable: true, exclusive: false, autoDelete: false, arguments: null);
                    //声明队列2---DirectExchangeQueue2
                    channel.QueueDeclare(queue: "DirectExchangeQueue2", durable: true, exclusive: false, autoDelete: false, arguments: null);
                    //交换机的类型：type：ExchangeType  type: ExchangeType.Direct：声明为direct类型路由
                    channel.ExchangeDeclare(exchange: "DirectExChange", type: ExchangeType.Direct, durable: true, autoDelete: false, arguments: null);

                    channel.QueueBind(queue: "DirectExchangeQueue1",
                             exchange: "DirectExChange",
                             routingKey: "Key1");

                    channel.QueueBind(queue: "DirectExchangeQueue2",
                            exchange: "DirectExChange",
                            routingKey: "Key2");

                    string message1 = "这里是发送给路由DirectExChange，发送消息声明的key为Key1";
                    channel.BasicPublish(exchange: "DirectExChange",
                                           routingKey: "Key1",//这里指定的Key1和上面绑定的Key1吻合
                                           basicProperties: null,
                                           body: Encoding.UTF8.GetBytes(message1));

                    string message2 = "这里是发送给路由DirectExChange，发送消息声明的key为Key2";
                    channel.BasicPublish(exchange: "DirectExChange",
                                           routingKey: "Key2",//这里指定的Key2和上面绑定的Key2吻合
                                           basicProperties: null,
                                           body: Encoding.UTF8.GetBytes(message2)
                );
                }
            }
        } 
    }

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pc4IbXLy-1616122816720)(imgs/image-20210228211458460.png)]

生产者发送了两次消息，发送的时候指定了两个不同的routingKey为Key1和Key2,结果展示两个队列分别接受到了一条消息；队列DirectExchangeQueue1绑定路由时绑定额routingKey为Key1，所以收到了来自于生产者指定routingKey为Key1的消息；队列DirectExchangeQueue2绑定路由时绑定额routingKey为Key2，所以收到了来自于生产者指定routingKey为Key2的消息；

2.fanout类型路由

fanout路由规则就更简单了，direct类型exchange在和queue进行绑定时会设置了routingkey，fanout类型路由不需要在绑定的时候声明routingkey，绑定即可，生产者发送的消息，只要是路由和队列绑定了，任何一个和路由绑定的队列都可以收到生产者发送过来的消息；

来个案例：

生产者代码：

public class FanoutTypeExchange
    {
        public static void Send()
        {
            var factory = new ConnectionFactory();
            factory.HostName = "localhost";//RabbitMQ服务在本地运行
            factory.UserName = "guest";//用户名
            factory.Password = "guest";//密码 
            using (var connection = factory.CreateConnection())
            {
                using (IModel channel = connection.CreateModel())
                {
                    //声明队列为：FanoutExchangeQueue1
                    channel.QueueDeclare(queue: "FanoutExchangeQueue1", durable: true, exclusive: false, autoDelete: false, arguments: null);
                    //声明队列为：FanoutExchangeQueue2
                    channel.QueueDeclare(queue: "FanoutExchangeQueue2", durable: true, exclusive: false, autoDelete: false, arguments: null);
                    //在这里声明一个Fanout 类型的交换机，type: ExchangeType.Fanout
                    channel.ExchangeDeclare(exchange: "FanoutExchange", type: ExchangeType.Fanout, durable: true, autoDelete: false, arguments: null);
                    //交换机绑定队列，不需要绑定routingKey
                    channel.QueueBind(queue: "FanoutExchangeQueue1", exchange: "FanoutExchange", routingKey: string.Empty, arguments: null);
                    channel.QueueBind(queue: "FanoutExchangeQueue2", exchange: "FanoutExchange", routingKey: string.Empty, arguments: null); 
                    for (int i = 0; i < 30; i++)
                    {
                        string message = "生产者发送消息，这里使用Fanout路由，只要是和路由FanoutExchange绑定的队列，就都可以收到生产者发送过来的消息";
                        var body = Encoding.UTF8.GetBytes(message);
                        //基本发布
                        channel.BasicPublish(exchange: "FanoutExchange",
                                             routingKey: string.Empty,
                                             basicProperties: null,
                                             body: body); 
                    }
                }
            }
        }
    }

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rxy86iYo-1616122816722)(imgs/image-20210228213112435.png)]

生产者循环发送了30条消息，没有指定routingKey，Fanout类型路由FanoutExchange绑定了FanoutExchangeQueue1和FanoutExchangeQueue2，生产者发送的消息，两个队列都收到了30条消息。就是因为FanoutExchange绑定了两个队列，所有队列都可以接受到消息；这就是相当于是一个典型的发布订阅模式；

e绑定了FanoutExchangeQueue1和FanoutExchangeQueue2，生产者发送的消息，两个队列都收到了30条消息。就是因为FanoutExchange绑定了两个队列，所有队列都可以接受到消息；这就是相当于是一个典型的发布订阅模式；

好了，本期就说到这儿，下一期我们继续聊RabbitMQ