/// <summary>
/// 初始化
/// </summary>
private void Init()
{
var channel = _pool.Rent();
try
{
routeKey = _options.Queue;
//创建队列
channel.QueueDeclare(_options.Queue, true, false, false, new Dictionary <string, object>()
{
//{ "x-message-ttl",60 * 60 * 1000 * 24 * 7},
});
//创建绑定
if (!string.IsNullOrWhiteSpace(_options.Exchange))
{
routeKey = $"Key_{routeKey}";
channel.ExchangeDeclare(_options.Exchange, "direct", true);
channel.QueueBind(_options.Queue, _options.Exchange, routeKey);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
_pool.Return(channel);
}
public override Task <OperateResult> PublishAsync(string keyName, string content)
{
var channel = _connectionChannelPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(content);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
channel.BasicPublish(_exchange, keyName, null, body);
_logger.LogDebug($"RabbitMQ topic message [{keyName}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
finally
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
public async Task <Result> PublishAsync(string topic, string message)
{
var channel = _connectionChannelPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(message);
channel.ExchangeDeclare(_options.ExchangeName, _options.ExchangeType, true);
channel.BasicPublish(_options.ExchangeName, topic, null, body);
//_logger.LogDebug($"RabbitMQ topic message [{topic}] has been published.");
await Task.CompletedTask;
return(Result.Success());
}
catch (Exception ex)
{
return(Result.Failed(ex.Message));
}
finally
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
public RedisMQConsumerClient(string queueName,
IConnectionChannelPool connectionChannelPool,
IOptions <RedisMQOptions> options)
{
_queueName = queueName;
_connectionChannelPool = connectionChannelPool;
_redisMQOptions = options.Value;
_channel = connectionChannelPool.Rent();
_redisReliableQueues = new List <RedisReliableQueue <string> >();
}
public void Publish(object objmsg)
{
var channel = connectionChannelPool.Rent();
try
{
channel.ConfirmSelect();
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(objmsg));
channel.ExchangeDeclare(exchange: Exchange, type: ExchangeType, true);
channel.QueueDeclare(queue: Queue, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: Queue, exchange: Exchange, routingKey: RoutingKey);
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
channel.BasicPublish(exchange: Exchange, routingKey: RoutingKey, mandatory: true, basicProperties: properties, body: body);
if (channel.WaitForConfirms())
{
BasicAcks(objmsg);
}
else
{
BasicNacks(objmsg);
}
}
catch (Exception ex)
{
logger.LogError($"{ServiceKey}发送消息出错：{ex.StackTrace}");
throw;
}
finally
{
var returned = connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
public override Task <OperateResult> PublishAsync(string keyName, string content)
{
#region 个人添加的
var items = keyName.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries);
if (items.Length != 2)
{
throw new Exception("传入的keyName必须包含routingKey和queueName，并且以短杠隔开！");
}
var routingKey = items[0];
var queueName = items[1];
#endregion
var channel = _connectionChannelPool.Rent();
try
{
var body = Encoding.UTF8.GetBytes(content);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
#region 个人添加的
var arguments = new Dictionary <string, object>
{
{ "x-message-ttl", _rabbitMQOptions.QueueMessageExpires }
};
channel.QueueDeclare(queueName, true, false, false, arguments);
channel.QueueBind(queueName, _exchange, routingKey);
#endregion
channel.BasicPublish(_exchange, routingKey, null, body);
_logger.LogDebug($"RabbitMQ topic message [{routingKey}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wapperEx, errors)));
}
finally
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
IModel channel = null;
try
{
channel = _connectionChannelPool.Rent();
channel.ConfirmSelect();
var props = channel.CreateBasicProperties();
props.DeliveryMode = 2;
props.Headers = message.Headers.ToDictionary(x => x.Key, x => (object)x.Value);
channel.ExchangeDeclare(_exchange, RabbitMQOptions.ExchangeType, true);
channel.BasicPublish(_exchange, message.GetName(), props, message.Body);
channel.WaitForConfirmsOrDie(TimeSpan.FromSeconds(5));
_logger.LogDebug($"RabbitMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
finally
{
if (channel != null)
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
FullRedis channel = null;
try
{
channel = _connectionChannelPool.Rent();
var queue = channel.GetQueue <string>(message.GetName());
queue.Add(JsonConvert.SerializeObject(message));
_logger.LogDebug($"RedisMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
// finally
// {
// if (channel != null)
// {
// //var returned = _connectionChannelPool.Return(channel);
// if (!returned)
// {
// channel.Dispose();
// }
// }
// }
}
public Task <OperateResult> SendAsync(TransportMessage message)
{
NetMQSocket channel = null;
try
{
channel = _connectionChannelPool.Rent();
NetMQMessage msg = new NetMQMessage();
msg.Append(message.GetName());
msg.Append(System.Text.Json.JsonSerializer.Serialize(message.Headers.ToDictionary(x => x.Key, x => (object)x.Value)));
msg.Append(message.Body);
channel.SendMultipartMessage(msg);
_logger.LogDebug($"ZeroMQ topic message [{message.GetName()}] has been published.");
return(Task.FromResult(OperateResult.Success));
}
catch (Exception ex)
{
var wrapperEx = new PublisherSentFailedException(ex.Message, ex);
var errors = new OperateError
{
Code = ex.HResult.ToString(),
Description = ex.Message
};
return(Task.FromResult(OperateResult.Failed(wrapperEx, errors)));
}
finally
{
if (channel != null)
{
var returned = _connectionChannelPool.Return(channel);
if (!returned)
{
channel.Dispose();
}
}
}
}
public virtual void Start()
{
for (int i = 0; i < ConsumerTotal; i++)
{
var channel = connectionChannelPool.Rent();
channel.QueueDeclare(queue: Queue, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.BasicQos(0, 1, false);
var consumer = new EventingBasicConsumer(channel);
consumer.Registered += Registered;
consumer.Shutdown += Shutdown;
consumer.Unregistered += Unregistered;
consumer.Received += (s, e) =>
{
try
{
Received(s, e);
if (!AutoAck)
{
channel.BasicAck(e.DeliveryTag, false);
}
}
catch (Exception ex)
{
logger.LogError(ex, $"{ServiceKey}服务消费失败!");
if (!AutoAck)
{
channel.BasicReject(e.DeliveryTag, true);
}
throw;
}
};
channel.BasicConsume(queue: Queue, autoAck: AutoAck, consumer: consumer);
}
}
/// <summary>
/// Publish the specified channel and message.
/// </summary>
/// <returns>The publish.</returns>
/// <param name="channel">Channel.</param>
/// <param name="message">Message.</param>
public void Publish(string channel, EasyCachingMessage message)
{
var _publisherChannel = _connectionChannelPool.Rent();
try
{
var body = _serializer.Serialize(message);
_publisherChannel.ExchangeDeclare(_rabbitMQBusOptions.TopicExchangeName, ExchangeType.Topic, true, false, null);
_publisherChannel.BasicPublish(_rabbitMQBusOptions.TopicExchangeName, channel, false, null, body);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
var returned = _connectionChannelPool.Return(_publisherChannel);
if (!returned)
{
_publisherChannel.Dispose();
}
}
}
