/// <summary>
/// 发布订阅
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//创建一个随机数,以创建不同的消息队列
int random = new Random().Next(1, 1000);
Console.WriteLine("Start" + random.ToString());
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "192.168.1.107", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
String exchangeName = "pubSubFanOutExchange";
//声明交换机
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();
}
}
}
static void Main(string[] args)
{
//发送者
Console.WriteLine("Start");
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
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);
}
}
}
}
static void Main(string[] args)
{
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "localhost", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
String exchangeName = "mlog.exchange";
//路由名称
String routeKey = "mlog.queue.control";
//声明交换机 路由交换机类型direct
channel.ExchangeDeclare(
exchange: exchangeName,
type: ExchangeType.Topic,
durable: true,
autoDelete: false,
arguments: null);
var properties = channel.CreateBasicProperties();
while (true)
{
Console.WriteLine("消息内容:");
String message = Console.ReadLine();
//消息内容
byte[] body = Encoding.UTF8.GetBytes(message);
//发送消息 发送到路由匹配的消息队列中
channel.BasicPublish(
exchange: exchangeName,
routingKey: routeKey,
basicProperties: properties,
body: body);
Console.WriteLine("成功发送消息:" + message);
}
}
}
}
public static void Regiest()
{
Console.WriteLine("Start");
Console.WriteLine("host:");
var host = Console.ReadLine();
Console.WriteLine("port:");
var portstr = Console.ReadLine();
int.TryParse(portstr, out int port);
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = host, //IP地址
Port = port, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
Console.WriteLine("queue name");
string queueName = Console.ReadLine();
using (IConnection con = conFactory.CreateConnection()) //创建连接对象
{
using (IModel channel = con.CreateModel()) //创建连接会话对象
{
//声明一个队列
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);
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("客户端");
IConnectionFactory factory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
IConnection con = factory.CreateConnection(); //创建连接对象
IModel channel = con.CreateModel(); //创建连接会话对象
string name = "CSharp";
//声明一个队列
channel.QueueDeclare(
queue: name, //消息队列名称
durable: false, //是否持久化,true持久化,队列会保存磁盘,服务器重启时可以保证不丢失相关信息。
exclusive: false, //是否排他,true排他的,如果一个队列声明为排他队列,该队列仅对首次声明它的连接可见,并在连接断开时自动删除.
autoDelete: false, //是否自动删除。true是自动删除。自动删除的前提是：致少有一个消费者连接到这个队列，之后所有与这个队列连接的消费者都断开时,才会自动删除.
arguments: null //设置队列的一些其它参数
);
channel.QueueBind(
queue: name,
exchange: "CSharp",
routingKey: "test",
arguments: null);
string str;
do
{
Console.WriteLine("发送内容:");
str = Console.ReadLine();
//消息内容
byte[] body = Encoding.UTF8.GetBytes(str);
//发送消息
channel.BasicPublish(name, "", null, body);
Console.WriteLine("成功发送消息:" + str);
} while (str.Trim().ToLower() != "exit");
con.Close();
channel.Close();
}
public IActionResult Index()
{
//_logger.LogError("我是错误显示");
//_logger.LogDebug("我是调试信息");
//_logger.LogInformation("我是提示信息");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
//Port = 5672,//端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
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["1212"] = Encoding.UTF8.GetString(message);
//_logger.LogError("我是错误显示")
};
//消费者开启监听
channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer);
}
}
ViewData["1213"] = "123456";
return(View());
}
static void Main(string[] args)
{
Console.WriteLine("Service 启动");
IConnectionFactory factory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
}; IConnection conn = factory.CreateConnection();
IModel channel = conn.CreateModel();
string name = "CSharp";
//创建一个交换机
channel.ExchangeDeclare(name, ExchangeType.Topic, false, false, null);
//声明一个队列
channel.QueueDeclare(
queue: name, //消息队列名称
durable: false, //是否持久化,true持久化,队列会保存磁盘,服务器重启时可以保证不丢失相关信息。
exclusive: false, //是否排他,true排他的,如果一个队列声明为排他队列,该队列仅对首次声明它的连接可见,并在连接断开时自动删除.
autoDelete: false, //是否自动删除。true是自动删除。自动删除的前提是：致少有一个消费者连接到这个队列，之后所有与这个队列连接的消费者都断开时,才会自动删除.
arguments: null ////设置队列的一些其它参数
);
//绑定虚拟机和队列
channel.QueueBind(
queue: name,
exchange: name,
routingKey: "",
arguments: null);
//创建消费者对象
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
byte[] message = ea.Body.ToArray();//接收到的消息
Console.WriteLine("接收到消息为:" + Encoding.UTF8.GetString(message));
channel.BasicAck(ea.DeliveryTag, true);
};
//消费者开启监听
channel.BasicConsume(name, false, consumer);
Console.ReadKey();
channel.Dispose();
conn.Close();
}
/// <summary>
/// 开启2个client 客户端,每次发送消息,客户端都会收到相同的信息.
/// </summary>
public static void 订阅发布模式()
{
Console.WriteLine("Exchange Start");
Console.WriteLine("host:");
var host = Console.ReadLine();
Console.WriteLine("port:");
var portstr = Console.ReadLine();
int.TryParse(portstr, out int port);
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = host, //IP地址
Port = port, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
Console.WriteLine("exchange name");
string exchangeName = Console.ReadLine();
Console.WriteLine("fanout_订阅发布,direct_路由模式,topic_通配符模式");
string type = "fanout";
using (IConnection con = conFactory.CreateConnection()) //创建连接对象
{
using (IModel channel = con.CreateModel()) //创建连接会话对象
{
//声明一个队列
channel.ExchangeDeclare(
exchange: exchangeName,//消息队列名称
type: type);
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);
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "localhost", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
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.ToArray();//接收到的消息
Console.WriteLine("接收到信息为:" + Encoding.UTF8.GetString(message));
};
//消费者开启监听
channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer);
Console.ReadKey();
}
}
}
public void recv()
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "192.168.200.112", //IP地址
UserName = "******", //账号
Password = "******", //密码
VirtualHost = "test-9825" //虚拟端口
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
String queueName = String.Empty;
queueName = "test-queue";
//声明一个队列
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, 4)) * 200); //随机等待,实现能者多劳,
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();
}
}
}
/// <summary>
/// 一对多
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "192.168.1.107", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
String queueName = "workerQueue";
//声明一个队列
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();
}
}
}
private static HealthItem ProduceTest()
{
HealthItem item = new HealthItem
{
ItemName = "Produce"
};
try
{
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = RabbitMQOption.Instance.HostName, //IP地址
Port = RabbitMQOption.Instance.Port, //端口号
UserName = RabbitMQOption.Instance.UserName, //用户账号
Password = RabbitMQOption.Instance.Password //用户密码
};
using var con = conFactory.CreateConnection(); //创建连接对象
using var channel = con.CreateModel(); //创建连接会话对象
channel.QueueDeclare(
queue: "HealthCheck", //消息队列名称
durable: false, //是否缓存
exclusive: false,
autoDelete: false,
arguments: null);
byte[] body = Encoding.UTF8.GetBytes("HealthCheck Test");
//发送消息
DateTime start = DateTime.Now;
channel.BasicPublish(exchange: "", routingKey: "HealthCheck", basicProperties: null, body: body);
item.Value = (DateTime.Now - start).TotalMilliseconds;
item.Details = "Success";
item.Level = 5;
}
catch (Exception ex)
{
item.Level = -1;
item.Details = ex.Message;
}
return(item);
}
//private readonly ILogManager _logManager;
public RabbitMqHelper(IConfigProvider configProvider)
{
_rabbitMqConnection = configProvider.GetRabbitMqConnection();
//创建连接工厂
var connectionFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = _rabbitMqConnection.HostName, //IP地址
Port = _rabbitMqConnection.Port, //端口号
UserName = _rabbitMqConnection.UserName, //用户账号
Password = _rabbitMqConnection.Password //用户密码
};
//创建连接
_connection = connectionFactory.CreateConnection();
//创建通道
_channel = _connection.CreateModel();
//声明交换机
_channel.ExchangeDeclare(_rabbitMqConnection.ExchangeName, ExchangeType.Topic);
}
public RabbitMQService()
{
try
{
RabbitMQConf = AppConfig.GetSection("RabbitMQ")?.GetBindData <RabbitMQEndPoint>();
var factory = new ConnectionFactory//创建连接工厂对象
{
HostName = RabbitMQConf.HostName,
Port = RabbitMQConf.Port,
UserName = RabbitMQConf.UserName,
Password = RabbitMQConf.Password,
RequestedHeartbeat = RabbitMQConf.HeartBeat,
AutomaticRecoveryEnabled = true //自动重连
};
Con = factory.CreateConnection(); //创建连接对象
}
catch (Exception ex)
{
Logger?.Error($"无法连接RabbitMQ:{ex.Message}-{ex.StackTrace}-{Serializer.Serialize(RabbitMQConf)}");
throw new Exception($"无法连接RabbitMQ:{ex.Message}-{ex.StackTrace}");
}
}
public void Recv()
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "192.168.200.112", //IP地址
UserName = "******", //账号
Password = "******", //密码
VirtualHost = "test-9825" //虚拟端口
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
String queueName = String.Empty;
queueName = "test-queue";
//声明一个队列
channel.QueueDeclare(
queue: queueName, //消息队列名称
durable: false, //是否缓存
exclusive: false,
autoDelete: false,
arguments: null
);
//创建消费者对象
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
Thread.Sleep(1000); //等待1秒,
byte[] message = ea.Body; //接收到的消息
Console.WriteLine("接收到信息为:" + Encoding.UTF8.GetString(message));
};
//消费者开启监听 自动确认
channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer);
Console.ReadKey();
}
}
}
public void Send()
{
Console.WriteLine("Start");
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "192.168.200.112", //IP地址
UserName = "******", //账号
Password = "******", //密码
VirtualHost = "test-9825" //虚拟端口
};
using (IConnection con = conFactory.CreateConnection()) //创建连接对象
{
using (IModel channel = con.CreateModel()) //创建连接会话对象
{
String queueName = String.Empty;
queueName = "test-queue";
//声明一个队列
channel.QueueDeclare(
queue: queueName, //消息队列名称
durable: false, //是否缓存(持久化) 如果队列已经存在 是不能修改的
exclusive: false,
autoDelete: false,
arguments: null
);
for (int i = 0; i < 50; i++)
{
String message = "[发送消息]:" + i;
//消息内容
byte[] body = Encoding.UTF8.GetBytes(message);
//发送消息
channel.BasicPublish(exchange: "", routingKey: queueName, basicProperties: null, body: body);
Console.WriteLine("成功发送消息:" + message);
}
}
}
}
/// <summary>
///通配符模式(topic) 生产者
/// </summary>
public static void ProductTopic()
{
string[] args = null;
//创建一个随机数,以创建不同的消息队列
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 = "******", //用户账号
Password = "******" //用户密码
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
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);
}
}
}
}
static void Main(string[] args)
{
if (args.Length == 0)
{
throw new ArgumentException("args");
}
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
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);
}
}
}
}
/// <summary>
/// 同步运行状态
/// </summary>
/// <returns></returns>
Task <bool> IMessageReceiver.LoopBegin()
{
ConcurrencySemaphore = new SemaphoreSlim(RabbitMQOption.Instance.Concurrency, RabbitMQOption.Instance.Concurrency);
cancellationToken = new CancellationTokenSource();
if (!RabbitMQOption.Instance.ItemOptions.TryGetValue(Service.ServiceName, out Option))
{
Option = new RabbitMQItemOption();
}
try
{
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = RabbitMQOption.Instance.HostName, //IP地址
Port = RabbitMQOption.Instance.Port, //端口号
UserName = RabbitMQOption.Instance.UserName, //用户账号
Password = RabbitMQOption.Instance.Password //用户密码
};
connection = conFactory.CreateConnection(); //创建连接对象
channel = connection.CreateModel(); //创建连接会话对象
switch (Option.WrokType)
{
case RabbitMQWrokType.Fanout:
{
//声明交换机
channel.ExchangeDeclare(exchange: Option.ExchangeName, type: "fanout");
var name = $"{Option.ExchangeName}_{RandomCode.Generate(6)}";
//声明队列
channel.QueueDeclare(
queue: name, //消息队列名称
durable: Option.Durable, //是否缓存
exclusive: Option.Exclusive,
autoDelete: Option.AutoDelete,
arguments: null);
//将队列与交换机进行绑定
channel.QueueBind(queue: name, exchange: Option.ExchangeName, routingKey: "");
}
break;
case RabbitMQWrokType.Direct:
{
//声明交换机
channel.ExchangeDeclare(exchange: Option.ExchangeName, type: "direct");
var name = $"{Option.ExchangeName}_{RandomCode.Generate(6)}";
//声明队列
channel.QueueDeclare(
queue: name, //消息队列名称
durable: Option.Durable, //是否缓存
exclusive: Option.Exclusive,
autoDelete: Option.AutoDelete,
arguments: null);
//匹配多个路由
channel.QueueBind(queue: name, exchange: Option.ExchangeName, routingKey: Service.ServiceName);
break;
}
case RabbitMQWrokType.Topic:
{
//声明交换机
channel.ExchangeDeclare(exchange: Option.ExchangeName, type: "topic");
var name = $"{Option.ExchangeName}_{RandomCode.Generate(6)}";
//声明队列
channel.QueueDeclare(
queue: name, //消息队列名称
durable: Option.Durable, //是否缓存
exclusive: Option.Exclusive,
autoDelete: Option.AutoDelete,
arguments: null);
//匹配多个路由
channel.QueueBind(queue: name, exchange: Option.ExchangeName, routingKey: Service.ServiceName);
}
break;
default:
//声明队列
channel.QueueDeclare(
queue: Service.ServiceName, //消息队列名称
durable: Option.Durable, //是否缓存
exclusive: Option.Exclusive,
autoDelete: Option.AutoDelete,
arguments: null);
break;
}
if (Option.Qos > 0)
{
channel.BasicQos(0, Option.Qos, false);//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
}
}
catch (Exception ex)
{
Logger.Exception(ex);
}
return(Task.FromResult(true));
}
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
//using (IConnection conn = connFactory.CreateConnection())
//{
// using (IModel channel = conn.CreateModel())
// {
// String queueName = String.Empty;
// if (args.Length > 0)
// queueName = args[0];
// else
// queueName = "lixin_Rabbit";
// //声明一个队列
// 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();
// }
//}
//创建连接
var connection = connFactory.CreateConnection();
//创建通道
var channel = connection.CreateModel();
//事件基本消费者
EventingBasicConsumer consumer = new EventingBasicConsumer(channel);
//接收到消息事件
consumer.Received += (ch, ea) =>
{
var message = Encoding.UTF8.GetString(ea.Body);
Console.WriteLine($"收到消息： {message}");
Console.WriteLine($"收到该消息[{ea.DeliveryTag}] 延迟10s发送回执");
Thread.Sleep(3000);
//确认该消息已被消费
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine($"已发送回执[{ea.DeliveryTag}]");
};
//启动消费者 设置为手动应答消息
channel.BasicConsume("hello", true, consumer);
Console.WriteLine("消费者已启动");
Console.ReadKey();
channel.Dispose();
connection.Close();
}
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
#region worker
//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);
// };
// //消费者开启监听
// //channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer);
// //将autoAck设置false 关闭自动确认
// channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);
// Console.ReadKey();
// }
//}
#endregion
//创建一个随机数,以创建不同的消息队列
int random = new Random().Next(1, 1000);
Console.WriteLine("Start" + random.ToString());
#region 发布订阅模式(fanout)
//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();
// }
//}
#endregion
#region 路由模式
//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.QueueBind(queue: queueName, exchange: exchangeName, routingKey: "route1");
// //声明为手动确认
// 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();
// }
//}
#endregion
#region 通配符模式(topic)
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
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.QueueBind(queue: queueName, exchange: exchangeName, routingKey: "route1");
//声明为手动确认
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();
}
}
#endregion
}
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
#region worker
//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);
// }
// }
//}
#endregion
#region 发布订阅模式(fanout)
//using (IConnection conn = conFactory.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);
// }
// }
//}
#endregion
#region 路由模式(direct)
//using (IConnection conn = conFactory.CreateConnection())
//{
// using (IModel channel = conn.CreateModel())
// {
// //交换机名称
// String exchangeName = "exchange2";
// //路由名称
// String routeKey = "route1";
// //声明交换机 路由交换机类型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);
// }
// }
//}
#endregion
#region 通配符模式(topic)
using (IConnection conn = conFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
String exchangeName = "exchange3";
//路由名称
String routeKey = "route1";
//声明交换机 通配符类型为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);
}
}
}
#endregion
}
static void Main(string[] args)
{
#region 简单队列模式,一个消息生产者,一个消息消费者,一个队列
//IConnectionFactory conFactory = new ConnectionFactory//创建连接工厂对象
//{
// HostName = "127.0.0.1",//IP地址
// Port = 5672,//端口号
// UserName = "******",//用户账号
// Password = "******"//用户密码
//};
//using (var con = conFactory.CreateConnection())
//{
// using (var channel = con.CreateModel())
// {
// //声明一个队列
// channel.QueueDeclare(
// queue: "queue1",//消息队列名称
// 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: "queue1", basicProperties: null, body: body);
// Console.WriteLine("成功发送消息:" + message);
// }
// }
//}
#endregion
#region 竞争消费模式 worker模式 一个消息生产者,多个消息消费者,一个队列
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
using (var con = conFactory.CreateConnection())
{
using (var channel = con.CreateModel())
{
//声明一个队列
channel.QueueDeclare(
queue: "queue1", //消息队列名称
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: "queue1", basicProperties: null, body: body);
Console.WriteLine("成功发送消息:" + message);
}
}
}
#endregion
}
static void Main(string[] args)
{
Console.WriteLine("Start");
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
//using (IConnection con = conFactory.CreateConnection())//创建连接对象
//{
// using (IModel channel = con.CreateModel())//创建连接会话对象
// {
// String queueName = String.Empty;
// if (args.Length > 0)
// queueName = args[0];
// else
// queueName = "lixin_Rabbit";
// //声明一个队列
// 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);
// }
// }
//}
//创建连接
var connection = conFactory.CreateConnection();
//创建通道
var channel = connection.CreateModel();
//声明一个队列
channel.QueueDeclare("hello", false, false, false, null);
Console.WriteLine("\nRabbitMQ连接成功，请输入消息，输入exit退出！");
string input;
do
{
input = Console.ReadLine();
var sendBytes = Encoding.UTF8.GetBytes(input);
//发布消息
channel.BasicPublish("", "hello", null, sendBytes);
} while (input.Trim().ToLower() != "exit");
channel.Close();
connection.Close();
}
/// <summary>
/// 通配符模式与路由模式一致,但是可以模糊匹配
/// </summary>
public static void 通配符模式()
{
Console.WriteLine("Start");
Console.WriteLine("host:");
var host = Console.ReadLine();
Console.WriteLine("port:");
var portstr = Console.ReadLine();
int.TryParse(portstr, out int port);
IConnectionFactory conFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = host, //IP地址
Port = port, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
Console.WriteLine("exchange name");
string exchangeName = Console.ReadLine();
Console.WriteLine("fanout_订阅发布,* direct_路由模式,topic_通配符模式");
string type = "topic";
Console.WriteLine("请输入要匹配的key,用'_'分割");
string routingKeyStr = Console.ReadLine();
string[] routingKeys = routingKeyStr.Split('_');
using (IConnection conn = conFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
channel.BasicQos(0, 1, false);
//声明一个队列
channel.ExchangeDeclare(
exchange: exchangeName,//消息队列名称
type: type
);
//创建消费者对象
var consumer = new EventingBasicConsumer(channel);
//创建队列
string queueName = exchangeName + "_" + Guid.NewGuid().ToString("N");
channel.QueueDeclare(queueName, false, false, false, null);
foreach (var routingKey in routingKeys)
{
//绑定队列与交换机
channel.QueueBind(queue: queueName, exchange: exchangeName, routingKey: routingKey);
}
consumer.Received += (model, ea) =>
{
byte[] message = ea.Body;//接收到的消息
int.TryParse(Encoding.UTF8.GetString(message), out int num);
Console.WriteLine("接收到信息为:" + Encoding.UTF8.GetString(message));
//手动确认
channel.BasicAck(ea.DeliveryTag, true);
};
//消费者开启监听(autoAck=false) 关闭自动确认
channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);
Console.ReadKey();
}
}
}
static void Main(string[] args)
{
#region 简单队列
//IConnectionFactory connFactory = new ConnectionFactory//创建连接工厂对象
//{
// HostName = "127.0.0.1",//IP地址
// Port = 5672,//端口号
// UserName = "******",//用户账号
// Password = "******"//用户密码
//};
//using (IConnection conn = connFactory.CreateConnection())
//{
// using (IModel channel = conn.CreateModel())
// {
// var 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();
// }
//}
#endregion
#region 竞争消费模式 worker模式 一个消息生产者,多个消息消费者,一个队列
//1.丢失数据:一旦其中一个宕机,那么另外接收者的无法接收原本这个接收者所要接收的数据
//2.无法实现能者多劳:如果其中的接收者接收的较慢,那么便会极大的浪费性能,所以需要实现接收快的多接收
//第二个接收者在接收数据途中宕机,第一个接收者也并没有去接收第二个接收者宕机后的数据
//,有的时候我们会有当接收者宕机后,其余数据交给其它接收者进行消费,那么该怎么进行处理呢,解决这个问题得方法就是改变其消息确认模式
// 在Rabbit中存在两种消息确认模式,
//自动确认: 只要消息从队列获取,无论消费者获取到消息后是否成功消费,都认为是消息成功消费,也就是说上面第二个接收者其实已经消费了它所接收的数据
// 手动确认:消费从队列中获取消息后,服务器会将该消息处于不可用状态,等待消费者反馈
// 也就是说我们只要将消息确认模式改为手动即可, 改为手动确认方式只需改两处,1.开启监听时将autoAck参数改为false,2.消息消费成功后返回确认
IConnectionFactory connFactory = new ConnectionFactory //创建连接工厂对象
{
HostName = "127.0.0.1", //IP地址
Port = 5672, //端口号
UserName = "******", //用户账号
Password = "******" //用户密码
};
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
var 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(3000); //等待3秒, ctrl+c执行宕机
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: true, consumer: consumer);
channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);
Console.ReadKey();
}
}
#endregion
}
