public void Get(MessagingConfiguration messagingConfiguration, IRabbitMessageHandler messageHandler)
{
using (var messageConsumer = new TSubscriber())
{
messageConsumer.Get(messagingConfiguration, messageHandler);
}
}
public void Consume(IRabbitMessageHandler messageHandler)
{
if (_rabbitConfiguration == null)
{
throw new ApplicationException("Rabbit configuration is missing.");
}
if (messageHandler == null)
{
throw new ArgumentNullException(nameof(messageHandler));
}
_consumer = new EventingBasicConsumer(_channel);
_consumer.Received += (model, result) =>
{
try
{
_channel.BasicAck(result.DeliveryTag, false);
messageHandler.Handle(model, result);
}
catch (Exception ex)
{
//Log exception
}
};
_channel.BasicConsume(_rabbitConfiguration.Queue, false, _consumer);
}
public void Get(string exchange, string queue, IRabbitMessageHandler messageHandler, string routingKey = "", string type = "fanout", bool durable = false)
{
var rabbitConfiguration = new RabbitConfiguration(_connectionFactory, exchange, routingKey, type, durable, queue);
using (var messageConsumer = new TConsumer())
{
messageConsumer.Setup(rabbitConfiguration).Get(messageHandler);
}
}
public Guid Subscribe(MessagingConfiguration messagingConfiguration, IRabbitMessageHandler messageHandler)
{
var consumer = new TSubscriber();
var consumerId = Guid.NewGuid();
_consumers.TryAdd(consumerId, consumer);
consumer.Consume(messagingConfiguration, messageHandler);
return(consumerId);
}
public BatchSubscriptionHost(
IObservableConnection connection,
IRabbitMessageHandler <IEnumerable <T> > handler,
IBatchSubscriptionConfig config, ILogger logger
// ,
// IEnumerable<IBatchRabbitMessageInterceptor<T>> interceptors
)
{
logger.InfoFormat("Subscribing handler: {0} with Id {1}", config.Name, config.Id);
Subscription = connection.SubscribeOnQueueToMessage(config, handler);
}
public Guid Subscribe(string exchange, string queue, IRabbitMessageHandler messageHandler, string routingKey = "", string type = "fanout", bool durable = false)
{
var rabbitConfiguration = new RabbitConfiguration(_connectionFactory, exchange, routingKey, type, durable, queue);
var consumer = new TConsumer();
var consumerId = Guid.NewGuid();
_consumers.TryAdd(consumerId, consumer);
consumer.Setup(rabbitConfiguration).Consume(messageHandler);
return(consumerId);
}
public void Get(MessagingConfiguration messagingConfiguration, IRabbitMessageHandler messageHandler)
{
SetupChannel(messagingConfiguration);
var result = _channel.BasicGet(messagingConfiguration.QueueName, true);
while (result != null)
{
messageHandler.Handle(result);
result = _channel.BasicGet(messagingConfiguration.QueueName, true);
}
}
public void Get(IRabbitMessageHandler messageHandler)
{
if (_rabbitConfiguration == null)
{
throw new ApplicationException("Rabbit configuration is missing.");
}
var result = _channel.BasicGet(_rabbitConfiguration.Queue, true);
while (result != null)
{
messageHandler.Handle(result);
result = _channel.BasicGet(_rabbitConfiguration.Queue, true);
}
}
public void Consume(MessagingConfiguration messagingConfiguration, IRabbitMessageHandler messageHandler)
{
SetupChannel(messagingConfiguration);
_consumer = new EventingBasicConsumer(_channel);
_consumer.Received += (model, result) =>
{
try
{
_channel.BasicAck(result.DeliveryTag, false);
messageHandler.Handle(model, result);
}
catch (Exception ex)
{
//Log exception
}
};
_consumerTag = _channel.BasicConsume(messagingConfiguration.QueueName, false, _consumer);
}
public string Listening()
{
string strMessage = "";
_cts = new CancellationTokenSource();
running = true;
foreach (var type in queueTypeMap.Keys)
{
Task.Factory.StartNew(() =>
{
MessageSyncTypeMapInfo mapInfo;
queueTypeMap.TryGetValue(type, out mapInfo);
using (var client = clientFactory.Create(mapInfo.QueueName, mapInfo.ExchangeName, mapInfo.ExchangeType))
{
client.OnMessageReceived += (sender, e) =>
{
HandleResponse response = null;
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
string message = System.Text.Encoding.UTF8.GetString(e.Body);
try
{
IRabbitMessageHandler handler = IocManager.Resolve <IRabbitMessageHandler>(type);
response = handler.HandleRabbitMessage(message);
//strMessage += message;
Loger.Write(message);
}
catch (Exception ex)
{
response = new HandleResponse(HandleResult.失败, ex.Message);
response.Exception = ex;
}
switch (response.Result)
{
case HandleResult.成功:
case HandleResult.处理:
break;
default:
//包装为原消息同步接口格式，可以通过老工具进行二次处理
break;
}
//不管成功还是失败，都发送ack， 异常消息手动处理。
client.Commit();
};
client.OnError += (sender, e) =>
{
};
client.Subscribe(mapInfo.RountingKeys);
client.Listening(_pollingDelay, _cts.Token);
}
}, _cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).ContinueWith(task =>
{
if (task.Exception != null && task.Exception.InnerExceptions != null & task.Exception.InnerExceptions.Count > 0)
{
var innerException = task.Exception.InnerExceptions[0];
}
},
TaskContinuationOptions.OnlyOnFaulted);
}
_compositeTask = Task.WhenAll();
return(strMessage);
}
public PipelineDescriptor Use(IRabbitMessageHandler handler)
{
this.rabbitMessageHandlers.Add(handler);
return(this);
}
public static string GetGenericTypeName <TMessage>(IRabbitMessageHandler <TMessage> handler) where TMessage : IMessage
{
return(handler.GetType().GetGenericArguments()[0].ToString());
}
public static IDisposable SubscribeOnQueueToMessage <T>(this IObservableConnection connection, IBatchSubscriptionConfig config, IRabbitMessageHandler <IEnumerable <T> > handler)
{
return(SubscribeWithAck(connection.Queue(config.QueueName)
.Open()
.Stream <T>()
.Buffer(config.BufferTimeout, config.BufferSize)
.Where(m => m.Any())
.Select(l => l.AsEnumerable()), l =>
{
var rabbitMessages = l.ToArray();
handler.Handle(rabbitMessages.Select(m => m.Message));
}));
}
public static IDisposable SubscribeOnQueueToMessage <T>(this IObservableConnection connection, ISubscriptionConfig config, IRabbitMessageHandler <T> handler)
{
return(connection.Queue(config.QueueName)
.Open()
.Stream <T>()
.SubscribeWithAck(rm => { handler.Handle(rm.Message); }));
}
public static IDisposable SubscribeOnQueueToMessage <T>(this IObservableConnection connection, string exchange, string subscriberQueue, IRabbitMessageHandler <T> handler)
{
return(connection.SubscribeOnQueueToMessage(new DefaultSubscriptionConfig(subscriberQueue), handler));
}
internal PipelineDescriptor UseFirst(IRabbitMessageHandler handler)
{
this.rabbitMessageHandlers.Insert(0, handler);
return(this);
}
public static TMessage GetData <TMessage>(this IRabbitMessageHandler <TMessage> handler, byte[] body) where TMessage : IMessage
{
string jsonBody = Encoding.UTF8.GetString(body);
return(JsonSerializer.DeserializeFromString <TMessage>(jsonBody));
}
