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

 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就做的多,这也叫能者多劳

最新文章

  1. ffmpeg.exe dos下怎么用 放在哪里
  2. js中正则表达式 ---- 现成
  3. 异或链表(XOR linked list)
  4. MVC过滤器详解 面向切面编程(AOP)
  5. QT笔记之不规则窗口的实现
  6. sass学习笔记2
  7. EXt form属性
  8. NYOJ-86 找球号(一)AC 分类: NYOJ 2014-02-02 10:45 160人阅读 评论(0) 收藏
  9. bzoj 2002 [Hnoi2010]Bounce 弹飞绵羊(LCT)
  10. 线段树练习[单点更新] HDU 2795 Billboard
  11. c#接口深入一步探究其作用,适合新人了解
  12. 理解Java中的前期绑定和后期绑定
  13. Linux I2C设备驱动编写(一)
  14. PowerShell使用SMTP发送邮件
  15. Difference between LINQ to SQL and LINQ to Entity(DataContext and DbContext)
  16. MFC 用gdi绘制填充多边形区域
  17. 201521123010 《Java程序设计》第8周学习总结
  18. Python_001_开始学习的一些准备
  19. ES 6 系列 - Proxy
  20. 使用Twitter异常检测框架遇到的坑

热门文章

  1. TimSort学习资料
  2. Log4Net快速配置
  3. POJ 3624 Charm Bracelet【01背包】
  4. CGI与ISAPI的区别(转)
  5. laravel 知识点总结
  6. 如何让select中的滚动条自动定位到框中选中项的位置
  7. 搭建hadoop java开发环境
  8. java SSM多操作注解回滚
  9. Python学习笔记(5)practice:shopping_cart
  10. HTTP请求和响应模式(B/S)(2)