.NET Core 使用RabbitMQ

1.什么是rabbitmq

　　rabbitmq是一个开源的,基于amqp(advanced message queuing protocol)协议的完整,可复用的企业级消息队列(message queue 一种应用程序与应用程序之间的一种通信方法)系统,rabbitmq可以实现点对点,发布订阅等消息处理模式

2.安装rabbitmq

　　网上有许多rabbitmq的安装博客,所以在此不介绍   linux安装 windows安装

3..net core中使用rabbitmq

　　rabbitmq从信息接收者角度可以看做三种模式,一对一,一对多(此一对多并不是发布订阅，而是每条信息只有一个接收者)和发布订阅。其中一对一是简单队列模式，一对多是worker模式，而发布订阅包括发布订阅模式，路由模式和通配符模式，为什么说发布订阅模式包含三种模式呢，其实发布订阅，路由，通配符三种模式都是使用只是交换机(exchange)类型不一致

3.1 简单队列

　　首先,我们需要创建两个控制台项目.send(发送者)和receive(接收者),然后为两个项目安装rabbitmq.client驱动

install-package rabbitmq.client

　　然后在send和receive项目中编写我们的消息队列代码

　　发送者代码

using rabbitmq.client;
using system;
using system.text;

namespace send
{
    class program
    {
        static void main(string[] args)
        {
            console.writeline("start");
            iconnectionfactory confactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection con = confactory.createconnection())//创建连接对象
            {
                using (imodel channel = con.createmodel())//创建连接会话对象
                {
                    string queuename = string.empty;
                    if (args.length > 0)
                        queuename = args[0];
                    else
                        queuename = "queue1";
                    //声明一个队列
                    channel.queuedeclare(
                      queue: queuename,//消息队列名称
                      durable: false,//是否缓存
                      exclusive: false,
                      autodelete: false,
                      arguments: null
                       );
                    while (true)
                    {
                        console.writeline("消息内容:");
                        string message = console.readline();
                        //消息内容
                        byte[] body = encoding.utf8.getbytes(message);
                        //发送消息
                        channel.basicpublish(exchange: "", routingkey: queuename, basicproperties: null, body: body);
                        console.writeline("成功发送消息:" + message);
                    }
                }
            }
        }
    }
}

 

　　可以看到rabbitmq使用了iconnectionfactory,iconnection和imodel来创建链接和通信管道,iconnection实例对象只负责与rabbit的连接,而发送接收这些实际操作全部由会话通道进行,

　　而后使用quenedeclare方法进行创建消息队列,创建完成后可以在rabbitmq的管理工具中看到此队列，quenedelare方法需要一个消息队列名称的必须参数.后面那些参数则代表缓存,参数等信息.

　　最后使用basicpublish来发送消息,在一对一中routingkey必须和 queuename一致

　　接收者代码

using rabbitmq.client;
using rabbitmq.client.events;
using system;
using system.text;

namespace receive1
{
    class program
    {
        static void main(string[] args)
        {
            console.writeline("start");
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using (imodel channel = conn.createmodel())
                {
                    string queuename = string.empty;
                    if (args.length > 0)
                        queuename = args[0];
                    else
                        queuename = "queue1";
                    //声明一个队列
                    channel.queuedeclare(
                      queue: queuename,//消息队列名称
                      durable: false,//是否缓存
                      exclusive: false,
                      autodelete: false,
                      arguments: null
                       );
                    //创建消费者对象
                    var consumer = new eventingbasicconsumer(channel);
                    consumer.received += (model, ea) =>
                    {
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                    };
                    //消费者开启监听
                    channel.basicconsume(queue: queuename, autoack: true, consumer: consumer);
                    console.readkey();
                }
            }
        }
    }
}

　　在接收者中是定义一个eventingbasicconsumer对象的消费者(接收者),这个消费者与会话对象关联,

　　然后定义接收事件,输出从消息队列中接收的数据,

　　最后使用会话对象的basicconsume方法来启动消费者监听.消费者的定义也是如此简单.

　　不过注意一点,可以看到在接收者代码中也有声明队列的方法,其实这句代码可以去掉,但是如果去掉的话接收者在程序启动时监听队列,而此时这个队列还未存在,所以会出异常,所以往往会在消费者中也添加一个声明队列方法

　　此时,简单消息队列传输就算写好了,我们可以运行代码就行测试

　　

　　

3.2 worker模式

　　worker模式其实是一对多的模式,但是这个一对多并不是像发布订阅那种,而是信息以顺序的传输给每个接收者,我们可以使用上个例子来运行worker模式甚至,只需要运行多个接收者即可

　　

　　

　　

　　可以看到运行两个接收者,然后发送者发送了1-5这五个消息,第一个接收者接收的是奇数,而第二个接收者接收的是偶数,但是现在的worker存在这很大的问题,

　　　　1.丢失数据:一旦其中一个宕机,那么另外接收者的无法接收原本这个接收者所要接收的数据

　　　　2.无法实现能者多劳:如果其中的接收者接收的较慢,那么便会极大的浪费性能,所以需要实现接收快的多接收

　　下面针对上面的两个问题进行处理

　　首先我们先来看一下所说的宕机丢失数据一说,我们在上个例子receive接收事件中添加线程等待

 consumer.received += (model, ea) =>
                    {
                        thread.sleep(1000);//等待1秒,
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                    };

　　然后再次启动两个接收者进行测试

　　　　　　

　　

　　

　　可以看到发送者发送了1-9的数字,第二个接收者在接收数据途中宕机,第一个接收者也并没有去接收第二个接收者宕机后的数据,有的时候我们会有当接收者宕机后,其余数据交给其它接收者进行消费,那么该怎么进行处理呢,解决这个问题得方法就是改变其消息确认模式

　　在rabbit中存在两种消息确认模式,

　　　　自动确认:只要消息从队列获取,无论消费者获取到消息后是否成功消费,都认为是消息成功消费,也就是说上面第二个接收者其实已经消费了它所接收的数据

　　　　手动确认:消费从队列中获取消息后,服务器会将该消息处于不可用状态,等待消费者反馈

　　也就是说我们只要将消息确认模式改为手动即可,改为手动确认方式只需改两处,1.开启监听时将autoack参数改为false,2.消息消费成功后返回确认

 consumer.received += (model, ea) =>
                    {
                        thread.sleep(1000);//等待1秒,
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                        //返回消息确认
                        channel.basicack(ea.deliverytag, true);
                    };
                    //消费者开启监听
                    //将autoack设置false 关闭自动确认
                    channel.basicconsume(queue: queuename, autoack: false, consumer: consumer);

　　然后再次测试便会出现下面结果

 　　

　　

　　能者多劳是建立在手动确认基础上,下面修改一下代码中等待的时间

 consumer.received += (model, ea) =>
                    {
                        thread.sleep((new random().next(1,6))*1000);//随机等待,实现能者多劳,
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                        //返回消息确认
                        channel.basicack(ea.deliverytag, true);
                    };

　　然后只需要再添加basicqos方法即可

 //声明一个队列
                    channel.queuedeclare(
                      queue: queuename,//消息队列名称
                      durable: false,//是否缓存
                      exclusive: false,
                      autodelete: false,
                      arguments: null
                       );
                    //告诉rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
                    channel.basicqos(0, 1, false);

　　　　　　

　　

　　可以看到此时已实现能者多劳

　　worker模式接收者完整代码

using rabbitmq.client;
using rabbitmq.client.events;
using system;
using system.text;
using system.threading;

namespace receive1
{
    class program
    {
        static void main(string[] args)
        {
            console.writeline("start");
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using (imodel channel = conn.createmodel())
                {
                    string queuename = string.empty;
                    if (args.length > 0)
                        queuename = args[0];
                    else
                        queuename = "queue1";
                    //声明一个队列
                    channel.queuedeclare(
                      queue: queuename,//消息队列名称
                      durable: false,//是否缓存
                      exclusive: false,
                      autodelete: false,
                      arguments: null
                       );
                    //告诉rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
                    channel.basicqos(0, 1, false);
                    //创建消费者对象
                    var consumer = new eventingbasicconsumer(channel);
                    consumer.received += (model, ea) =>
                    {
                        thread.sleep((new random().next(1,6))*1000);//随机等待,实现能者多劳,
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                        //返回消息确认
                        channel.basicack(ea.deliverytag, true);
                    };
                    //消费者开启监听
                    //将autoack设置false 关闭自动确认
                    channel.basicconsume(queue: queuename, autoack: false, consumer: consumer);
                    console.readkey();
                }
            }
        }
    }
}

3.3 exchange模式(发布订阅模式,路由模式,通配符模式)

 　　前面说过发布,路由,通配符这三种模式其实可以算为一种模式，区别仅仅是交互机类型不同.在这里出现了一个交换机的东西，发送者将消息发送发送到交换机，接收者创建各自的消息队列绑定到交换机，

　　　    发布订阅模式

　　   路由模式        

　　   通配符模式

　　通过上面三幅图可以看出这三种模式本质就是一种订阅模式，路由，通配符模式只是订阅模式的变种模式。使其可以选择发送订阅者中的接收者。

　　注意：交换机本身并不存储数据，数据存储在消息队列中，所以如果向没有绑定消息队列的交换机中发送信息，那么信息将会丢失

　　下面依次来看一下这三种模式

　　发布订阅模式(fanout)

　　发送者代码

using rabbitmq.client;
using system;
using system.text;

namespace send3
{
    class program
    {
        static void main(string[] args)
        {
            console.writeline("start");
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using(imodel channel = conn.createmodel())
                {
                    //交换机名称
                    string exchangename = string.empty;
                    if (args.length > 0)
                        exchangename = args[0];
                    else
                        exchangename = "exchange1";
                    //声明交换机
                    channel.exchangedeclare(exchange: exchangename, type: "fanout");
                    while (true)
                    {
                        console.writeline("消息内容:");
                        string message = console.readline();
                        //消息内容
                        byte[] body = encoding.utf8.getbytes(message);
                        //发送消息
                        channel.basicpublish(exchange: exchangename, routingkey: "", basicproperties: null, body: body);
                        console.writeline("成功发送消息:" + message);
                    }
                }
            }
        }
    }
}

　　发送者代码与上面没有什么差异，只是由上面的消息队列声明变成了交换机声明(交换机类型为fanout)，也就说发送者发送消息从原来的直接发送消息队列变成了发送到交换机

　　接收者代码

using rabbitmq.client;
using rabbitmq.client.events;
using system;
using system.text;

namespace receive3
{
    class program
    {
        static void main(string[] args)
        {
            //创建一个随机数,以创建不同的消息队列
            int random = new random().next(1, 1000);
            console.writeline("start"+random.tostring());
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using (imodel channel = conn.createmodel())
                {
                    //交换机名称
                    string exchangename = string.empty;
                    if (args.length > 0)
                        exchangename = args[0];
                    else
                        exchangename = "exchange1";
                    //声明交换机
                    channel.exchangedeclare(exchange: exchangename, type: "fanout");
                    //消息队列名称
                    string queuename = exchangename + "_" + random.tostring();
                    //声明队列
                    channel.queuedeclare(queue: queuename, durable: false, exclusive: false, autodelete: false, arguments: null);
                    //将队列与交换机进行绑定
                    channel.queuebind(queue: queuename, exchange: exchangename,routingkey:"");
                    //声明为手动确认
                    channel.basicqos(0, 1, false);
                    //定义消费者
                    var consumer = new eventingbasicconsumer(channel);
                    //接收事件
                    consumer.received += (model, ea) =>
                    {
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                        //返回消息确认
                        channel.basicack(ea.deliverytag, true);
                    };
                    //开启监听
                    channel.basicconsume(queue: queuename, autoack: false, consumer: consumer);
                    console.readkey();
                }
            }
        }
    }
}

 

　　可以看到接收者代码与上面有些差异

　　首先是声明交换机(同上面一样，为了防止异常)

　　然后声明消息队列并对交换机进行绑定，在这里使用了随机数，目的是声明不重复的消息队列，如果是同一个消息队列，则就变成worker模式，也就是说对于发布订阅模式有多少接收者就有多少个消息队列，而这些消息队列共同从一个交换机中获取数据

　　然后同时开两个接收者，结果就如下

　　

　　

　　

　　路由模式(direct)

　　上面说过路由模式是订阅模式的一个变种模式，以路由进行匹配发送，例如将消息1发送给a,b两个消息队列，或者将消息2发送给b,c两个消息队列，路由模式的交换机是direct

　　发送者代码

using rabbitmq.client;
using system;
using system.text;

namespace send3
{
    class program
    {
        static void main(string[] args)
        {
            if (args.length == 0) throw new argumentexception("args");
            console.writeline("start");
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using(imodel channel = conn.createmodel())
                {
                    //交换机名称
                    string exchangename = "exchange2";
                    //路由名称
                    string routekey = args[0];
                    //声明交换机   路由交换机类型direct
                    channel.exchangedeclare(exchange: exchangename, type: "direct");
                    while (true)
                    {
                        console.writeline("消息内容:");
                        string message = console.readline();
                        //消息内容
                        byte[] body = encoding.utf8.getbytes(message);
                        //发送消息  发送到路由匹配的消息队列中
                        channel.basicpublish(exchange: exchangename, routingkey: routekey, basicproperties: null, body: body);
                        console.writeline("成功发送消息:" + message);
                    }
                }
            }
        }
    }
}

　　发送者代码相比上面只改了两处

　　　　1.将交换机类型改为了direct类型

　　　　2.将运行时的第一个参数改成了路由名称，然后发送数据时由指定路由的消息队列进行获取数据

　　接收者代码

using rabbitmq.client;
using rabbitmq.client.events;
using system;
using system.text;

namespace receive3
{
    class program
    {
        static void main(string[] args)
        {
            if (args.length == 0) throw new argumentexception("args");
            //创建一个随机数,以创建不同的消息队列
            int random = new random().next(1, 1000);
            console.writeline("start"+random.tostring());
            iconnectionfactory connfactory = new connectionfactory//创建连接工厂对象
            {
                hostname = "47.104.206.56",//ip地址
                port = 5672,//端口号
                username = "yan",//用户账号
                password = "yan"//用户密码
            };
            using (iconnection conn = connfactory.createconnection())
            {
                using (imodel channel = conn.createmodel())
                {
                    //交换机名称
                    string exchangename = "exchange2";
                    //声明交换机
                    channel.exchangedeclare(exchange: exchangename, type:"direct");
                    //消息队列名称
                    string queuename = exchangename + "_" + random.tostring();
                    //声明队列
                    channel.queuedeclare(queue: queuename, durable: false, exclusive: false, autodelete: false, arguments: null);
                    //将队列与交换机进行绑定
                    foreach (var routekey in args)
                    {//匹配多个路由
                        channel.queuebind(queue: queuename, exchange: exchangename, routingkey: routekey);
                    }
                    //声明为手动确认
                    channel.basicqos(0, 1, false);
                    //定义消费者
                    var consumer = new eventingbasicconsumer(channel);
                    //接收事件
                    consumer.received += (model, ea) =>
                    {
                        byte[] message = ea.body;//接收到的消息
                        console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
                        //返回消息确认
                        channel.basicack(ea.deliverytag, true);
                    };
                    //开启监听
                    channel.basicconsume(queue: queuename, autoack: false, consumer: consumer);
                    console.readkey();
                }
            }
        }
    }
}

 　　在接收者代码中的改动点也是与发送者一致，但是一个接收者消息队列可以声明多个路由与交换机进行绑定

　　运行情况如下

　　

　　

　　

　　通配符模式(topic)

　　通配符模式与路由模式一致，只不过通配符模式中的路由可以声明为模糊查询，rabbitmq拥有两个通配符

　　　　#：匹配0-n个字符语句

　　　　*：匹配一个字符语句

　　　　注意：rabbitmq中通配符并不像正则中的单个字符，而是一个以“.”分割的字符串，如 ”topic1.*“匹配的规则以topic1开始并且"."后只有一段语句的路由  例：“topic1.aaa”，“topic1.bb”

　　发送者代码

//交换机名称
string exchangename = "exchange3";
//路由名称
string routekey = args[0];
//声明交换机   通配符类型为topic
channel.exchangedeclare(exchange: exchangename, type: "topic");
while (true)
{
    console.writeline("消息内容:");
    string message = console.readline();
     //消息内容
     byte[] body = encoding.utf8.getbytes(message);
     //发送消息  发送到路由匹配的消息队列中
     channel.basicpublish(exchange: exchangename, routingkey: routekey, basicproperties: null, body: body);
     console.writeline("成功发送消息:" + message);
}

 　　修改了两点：交换机名称（每个交换机只能声明一种类型，如果还用exchang2的话就会出异常），交换机类型改为topic

　　接收者代码

//交换机名称
string exchangename = "exchange3";
//声明交换机    通配符类型为topic
channel.exchangedeclare(exchange: exchangename, type:"topic");
//消息队列名称
string queuename = exchangename + "_" + random.tostring();
//声明队列
channel.queuedeclare(queue: queuename, durable: false, exclusive: false, autodelete: false, arguments: null);
//将队列与交换机进行绑定
foreach (var routekey in args)
{//匹配多个路由
    channel.queuebind(queue: queuename, exchange: exchangename, routingkey: routekey);
}
//声明为手动确认
channel.basicqos(0, 1, false);
//定义消费者
var consumer = new eventingbasicconsumer(channel);
//接收事件
consumer.received += (model, ea) =>
{
   byte[] message = ea.body;//接收到的消息
   console.writeline("接收到信息为:" + encoding.utf8.getstring(message));
    //返回消息确认
    channel.basicack(ea.deliverytag, true);
};
//开启监听
channel.basicconsume(queue: queuename, autoack: false, consumer: consumer);
console.readkey();

　　接收者修改与发送者一致

　　运行结果如下