RabbitMq笔记（2）

今天收获不少，记个笔记。

 namespace RabbitMQTest
 {
     class Program
     {
         static void Main(string[] args)
         {
             Consumer();
             //Console.WriteLine("方法————{0}",Thread.CurrentThread.ManagedThreadId);

             //Thread thread = new Thread(Consumer);
             //thread.Start();
             //Console.WriteLine("线程1————{0}", Thread.CurrentThread.ManagedThreadId);
             //Thread tt = new Thread(
             //    () => {
             //        Consumer();
             //    }
             //    );
             //tt.Start();

             Task task = new Task(Consumer);
             task.Start();

             TaskFactory tf = new TaskFactory();
             Task t =  tf.StartNew(Consumer);
             //Console.WriteLine("线程2————{0}", Thread.CurrentThread.ManagedThreadId);
             Console.ReadLine();
         }

         private static void Consumer()
         {
             Console.WriteLine("线程开始,ID：" + Thread.CurrentThread.ManagedThreadId);
             var factory = new ConnectionFactory() { HostName = "localhost" };
             using (var connection = factory.CreateConnection())
             using (var channel = connection.CreateModel())
             {
                 //声明queue
                 channel.QueueDeclare(queue: "hellos",//队列名
                                      durable: false,//是否持久化
                                      exclusive: false,//true:排他性，该队列仅对首次申明它的连接可见，并在连接断开时自动删除
                                      autoDelete: false,//true:如果该队列没有任何订阅的消费者的话，该队列会被自动删除
                                      arguments: null);//如果安装了队列优先级插件则可以设置优先级

                 string message = "Hello World!";//待发送的消息
                 var body = Encoding.UTF8.GetBytes(message);
                 for (int i = ; i < ; i++)
                 {
                     channel.BasicPublish(exchange: "",//exchange名称
                                          routingKey: "hellos",//如果存在exchange,则消息被发送到名称为hello的queue的客户端
                                          basicProperties: null,
                                          body: body);//消息体
                     Console.WriteLine(" [x] Sent {0}", message);
                 }
             }
         }
     }
 }

生产者

 namespace RabbitXiaoFei
 {
     class Program
     {
         static void Main(string[] args)
         {
             //var factory = new ConnectionFactory() { HostName = "localhost", UserName = "ty2017", Password = "123456", VirtualHost = "log" };
             var factory = new ConnectionFactory() { HostName = "localhost" };
             using (var connection = factory.CreateConnection())
             using (var channel = connection.CreateModel())
             {
                 channel.QueueDeclare(queue: "hellos",//指定发送消息的queue，和生产者的queue匹配
                                      durable: false,//耐用的，持久的
                                      exclusive: false,//独有的；排外的；专一的
                                      autoDelete: false,//
                                      arguments: null);

                 //设置预取消息的数量为1个，消费完当前的消息后再去获取下一个消息
                 //就是有多个消费者去请求队列的时候，序号为奇数的会给第一个，为偶数的会给第二个
                 //但是如果第一个要耗费很长时间，那么第二个就得等，那就很消耗资源了
                 //要是每个Consumer处理完一个消息后再去获取下一个消息，这是多么理想呀！
                 channel.BasicQos(,  //设置0
                                  , //设置当前Consumer的预取数量为1个就行啦！
                                  false); //设置false  

                 var consumer = new EventingBasicConsumer(channel);
                 //注册接收事件，一旦创建连接就去拉取消息
                 consumer.Received += (obj, sss) =>
                 {
                     var body = sss.Body;
                     var message = Encoding.UTF8.GetString(body);
                     Console.WriteLine(" [x] Received {0}", message);
                 };
                 channel.BasicConsume(queue: "hellos",
                                      autoAck:true,//Ack :确认
                                                   //和tcp协议的ack一样，为false则服务端必须在收到客户端的回执（ack）后才能删除本条消息
                                      consumer: consumer);
                 Console.WriteLine(" Press [enter] to exit.");
                 Console.ReadLine();
             }
         }
     }
 }

消费者

New 生产者

            ConnectionFactory factory = new ConnectionFactory
            {
                UserName = "guest",//用户名
                Password = "guest",//密码
                HostName = "127.0.0.1",//rabbitmq ip
                //VirtualHost = "/"
            };

            //创建连接
            var connection = factory.CreateConnection();
            //创建通道
            var channel = connection.CreateModel();
            //声明一个队列    （队列名字，是否持久化，是否自动删除队列，是否排外的，是否等待服务器返回）
            channel.QueueDeclare("queuename_zkb", false, false, false, null);
            Guid guid = new Guid();
            var sendBytes = Encoding.UTF8.GetBytes(guid.ToString());
            //发布消息         （交换器名称，路由键，是否为强制性，
            channel.BasicPublish("", "queuename_zkb", null, sendBytes);
            channel.Close();
            connection.Close();

New 消费者

  IConnectionFactory connFactory = new ConnectionFactory//创建连接工厂对象
            {
                HostName = "127.0.0.1",//IP地址
                //Port = 5672,//端口号
                UserName = "guest",//用户账号
                Password = "guest"//用户密码
            };
            using (IConnection conn = connFactory.CreateConnection())
            {
                using (IModel channel = conn.CreateModel())
                {
                    String queueName = String.Empty;
                    queueName = "queuename_zkb";
                    //声明一个队列
                    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));

                        ViewData[""] = Encoding.UTF8.GetString(message);
                        //_logger.LogError("我是错误显示")
                    };
                    //消费者开启监听
                    channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer);

                }
            }

这个是在多个消费者的时候用到的，假如发给A消费，那就发一条给他，然后收到A的确认消息时候，在发给n消费者。一定是收到A的确认消息

下面的这张图，这样就变成了：公平分发⭐⭐⭐⭐（不加这些code的是轮询分发）

假如来了一批活需要1和2处理，2的能力比1强，那么这两个消费者就都是每次只取一条信息，但是2的能力强，2就做的多，这也叫能者多劳