public void Publish(IntegrationEvent @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = RetryPolicy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex, "Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", @event.Id, $"{time.TotalSeconds:n1}", ex.Message);
});
var eventName = @event.GetType().Name;
_logger.LogTrace("Creating RabbitMQ channel to publish event: {EventId} ({EventName})", @event.Id, eventName);
using (var channel = _persistentConnection.CreateModel())
{
_logger.LogTrace("Declaring RabbitMQ exchange to publish event: {EventId}", @event.Id);
channel.ExchangeDeclare(exchange: BROKER_NAME, type: ExchangeType.Direct);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; // persistent
_logger.LogTrace("Publishing event to RabbitMQ: {EventId}", @event.Id);
channel.BasicPublish(
exchange: BROKER_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body);
});
}
}
public void Publish(IntegrationEvent @event)
{
var factory = new ConnectionFactory()
{
HostName = "rabbitmq"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel()) {
channel.ExchangeDeclare(exchange: BrokerName, type: ExchangeType.Direct);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: BrokerName,
routingKey: @event.GetType().Name,
basicProperties: null,
body: body);
}
}
private void CreateModelAndPublish(IntegrationEvent @event, RetryPolicy policy)
{
using (var channel = _persister.CreateModel())
{
var eventName = @event.GetType().Name;
channel.ExchangeDeclare(BROKER_NAME, BROKER_TYPE);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
channel.BasicPublish(BROKER_NAME, eventName, true, properties, body);
});
}
}
public async Task PublishAsync(IntegrationEvent @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var eventName = @event.GetType().Name;
_logger.Information("Creating RabbitMQ channel to publish event: {0} {1})", @event.Id, eventName);
try
{
using (var channel = _persistentConnection.CreateModel())
{
_logger.Information("Declaring RabbitMQ exchange to publish event: {0}", @event.Id);
channel.ExchangeDeclare(exchange: BROKER_NAME, ExchangeType.Direct);
channel.QueueBind(_queueName, BROKER_NAME, eventName);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
await _retryPolicy.ExecuteAsync(async() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; // persistent
_logger.Information("Publishing event to RabbitMQ: {0}", @event.Id);
channel.BasicPublish(exchange: BROKER_NAME, routingKey: eventName, mandatory: true,
basicProperties: properties, body: body);
});
}
}
catch (Exception ex)
{
_logger.Error("Could not publish event: {0} after ({1})", @event.Id, ex.Message);
throw;
}
}
public void Publish(IntegrationEvent @event)
{
if (!_persister.IsConnected)
{
_persister.TryConnect();
}
var policyBuilder = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>();
var policy = policyBuilder.WaitAndRetry(
_retryCount,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(ex, time)
=> _logger.LogWarning(
ex,
$"Não foi possível publicar o evento {@event.EventId} após {time.TotalSeconds:N1}s",
ex.Message));
CreateModelAndPublish(@event, policy);
}
public void Publish(IntegrationEvent @event)
{
if (!persistentConnection.IsConnected)
{
persistentConnection.TryConnect();
}
var retryPolicy = RetryPolicy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(retryCount, nextRetry => TimeSpan.FromSeconds(30), (ex, time) =>
{
logger.LogWarning(ex, $"Cannot publish event: {@event.Id} Error: {ex.Message} ");
});
var eventName = @event.GetType().Name;
logger.LogTrace($"Creating RabbitMQ channel to publish event {@event.Id} {eventName}");
using (var channel = persistentConnection.CreateModel())
{
channel.ExchangeDeclare(exchange: BROKER_NAME, type: ExchangeType.Fanout);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
retryPolicy.Execute(() =>
{
var basicProperties = channel.CreateBasicProperties();
basicProperties.DeliveryMode = 2;
logger.LogTrace($"Publishing event to RabbitMQ {@event.Id}");
channel.BasicPublish(
exchange: BROKER_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: basicProperties,
body: body);
});
}
}
public void Publish(IntegrationEvent @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(ex, time) =>
{
//_logger.LogWarning(ex.ToString());
});
using (var channel = _persistentConnection.CreateModel())
{
var eventName = @event.GetType()
.Name;
channel.ExchangeDeclare(exchange: BROKER_NAME,
type: "direct");
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; // persistent
channel.BasicPublish(exchange: BROKER_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body);
});
}
}
public void Publish(IntegrationEvent @event)
{
if (!_rabbitMQPersistentConnection.IsConnected)
{
_rabbitMQPersistentConnection.TryConnect();
}
var eventName = @event.GetType().Name;
Log.Information("Creating RabbitMQ channel to publish event: {EventId} ({EventName})",
@event.Id, eventName);
using (var channel = _rabbitMQPersistentConnection.CreateModel())
{
Log.Information("Declaring RabbitMQ exchange to publish event: {EventId}",
@event.Id);
channel.ExchangeDeclare(exchange: BROKER_NAME,
type: ExchangeType.Direct);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; // persistent
Log.Information("Publishing event to RabbitMQ: {EventId}",
@event.Id);
//The routing algorithm behind a direct exchange is simple - a message goes to the queues
//whose binding key exactly matches the routing key of the message.
channel.BasicPublish(exchange: BROKER_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: properties,
body: body);
}
}
/// <summary>
/// 摘要：
/// 表示一个发布事件的方法
/// 说明：
/// 将数据类型作为消息发布到RabbitMQ服务器
/// </summary>
/// <param name="event">事件类型</param>
public void Publish(IntegrationEvent @event)
{
var eventName = @event.GetType().Name;//获取事件类型名称
var factory = new ConnectionFactory()
{
HostName = _connectionString
};
using (var connection = factory.CreateConnection()) //建立socket连接
using (var channel = connection.CreateModel()) //建立通道
{
channel.ExchangeDeclare(exchange: _brokerName,
type: "direct"); //声明direct类型的交换机
string message = JsonConvert.SerializeObject(@event); //序列化事件类型（参数）
var body = Encoding.UTF8.GetBytes(message); //转化事件类型（参数）为RabbitMQ传递的消息类型（即二进制块）
//发布消息到交换机。
channel.BasicPublish(exchange: _brokerName, //将代理名称作为交换机的名称
routingKey: eventName, //将事件类型名称作为队列名称
basicProperties: null,
body: body);
}
}
/// <summary>
/// 发布
/// </summary>
/// <param name="event"></param>
public void Publish(IntegrationEvent @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
//重试机制...
var policy = RetryPolicy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Console.WriteLine("Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", @event.Id, $"{time.TotalSeconds:n1}", ex.Message);
});
//获取名称
var eventName = @event.GetType().Name;
//创建信道
using (var channel = _persistentConnection.CreateModel())
{
//创建一个type=direct的交换器 (可以简化ExchangeDeclare(Exchange_Name,"direct"))
channel.ExchangeDeclare(exchange: Exchange_Name, type: ExchangeType.Direct);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
//构造一个完全空的内容头，以便与基本内容类一起使用。
var properties = channel.CreateBasicProperties();
//指定为2 消息持久化
properties.DeliveryMode = 2;
//properties.Persistent = true; 持久化另一种写法
//发布
channel.BasicPublish(exchange: Exchange_Name,
routingKey: eventName,
mandatory: true,////指定mandatory: true告知服务器当根据指定的routingKey和消息找不到对应的队列时，直接返回消息给生产者。
basicProperties: properties,
body: body);
}
}
public T Publish <T>(IntegrationEvent @event)
{
_logger.LogDebug($"Publish<T> -> EVENTID - {@event.Id}");
string guidId = Guid.NewGuid().ToString();
PublishEvent(@event, true, guidId);
string responseMsg = string.Empty;
Dictionary <string, string> resData;
while (_responseMessage.TryTake(out resData, -1))
{
if (resData.ContainsKey(guidId))
{
responseMsg = resData[guidId];
break;
}
}
_logger.LogDebug($"RESPONSE MSG - {responseMsg}");
var responseData = JsonConvert.DeserializeObject <T>(responseMsg);
return(responseData);
}
public void Publish(IntegrationEvent @event)
{
PublishEvent(@event);
}
