//public BasicMasstransitConsumer(IServiceProvider provider) { }
async Task IConsumer <T> .Consume(ConsumeContext <T> context)
{
using (var scope = IocContext.Instance.Scope())
{
var logger = scope.ServiceProvider.Resolve_ <ILogger <BasicMasstransitConsumer <T> > >();
var all_subscribers = scope.ServiceProvider.ResolveConsumerOptional <T>();
foreach (var c in all_subscribers)
{
try
{
#if DEBUG
logger.LogInformation($"消费：{context.Message?.ToJson()}");
#endif
var message = new BasicMessageConsumeContext <T>(context.Message);
await c.Consume(message);
}
catch (Exception e)
{
logger.AddErrorLog(e.Message, e);
}
}
}
}
async Task __fetch_and_consume__()
{
var bs = (byte[])await this.redisDatabaseSelector.Database.ListRightPopAsync(this.config.QueueName);
var model = ValidateHelper.IsNotEmpty(bs) ?
this.serializeProvider.DeserializeFromBytes <T>(bs) :
null;
if (model == null)
{
await this.__wait__();
return;
}
using var scope = this.provider.CreateScope();
var all_subscribers = scope.ServiceProvider.ResolveConsumerOptional <T>();
foreach (var c in all_subscribers)
{
try
{
#if DEBUG
this.logger.LogInformation($"消费：{model.ToJson()}");
#endif
var message = new BasicMessageConsumeContext <T>(model);
await c.Consume(message);
}
catch (Exception e)
{
this.logger.AddErrorLog(e.Message, e);
}
}
}
public async Task PublishAsync <T>(string key, T model, CancellationToken cancellationToken) where T : class, IMessageBody
{
var consumers = this.provider.ResolveConsumerOptional <T>();
foreach (var c in consumers)
{
try
{
var message = new BasicMessageConsumeContext <T>(model);
await c.Consume(message);
}
catch (Exception e)
{
this.logger.AddErrorLog(e.Message, e);
}
}
}
public override async Task OnMessageReceived(IMessageConsumeContext <MessageType> message)
{
var model = message.Message;
using var s = this.provider.CreateScope();
var consumers = s.ServiceProvider.ResolveConsumerOptional <MessageType>();
foreach (var c in consumers)
{
#if DEBUG
this.logger.LogInformation($"消费：{model.ToJson()}");
#endif
var data = new BasicMessageConsumeContext <MessageType>(model);
await c.Consume(data);
}
}
public override async Task <bool> OnMessageReceived(ConsumerMessage <T> message)
{
using var s = this.provider.CreateScope();
var consumers = s.ServiceProvider.ResolveConsumerOptional <T>();
var model = message.MessageModel;
foreach (var c in consumers)
{
#if DEBUG
this.logger.LogInformation($"消费：{model.ToJson()}");
#endif
var data = new BasicMessageConsumeContext <T>(model);
await c.Consume(data);
}
return(true);
}
public RabbitMqConsumerBase(IServiceProvider provider, ILogger logger, IConnection connection, ConsumeOption option)
{
provider.Should().NotBeNull();
logger.Should().NotBeNull();
connection.Should().NotBeNull();
option.Should().NotBeNull();
this.provider = provider;
this.logger = logger;
this._option = option;
this._serializer = provider.ResolveSerializer();
this._channel = connection.CreateModel();
//qos
if (this._option.ConcurrencySize != null)
{
this._channel.BasicQos(prefetchSize: 0, prefetchCount: this._option.ConcurrencySize.Value, global: false);
}
//异步消费
this._consumer = new AsyncEventingBasicConsumer(this._channel);
//注册消费事件
this._consumer.Received += async(sender, args) =>
{
using var s = this.provider.CreateScope();
var body = this.__deserialize__(args.Body.ToArray());
if (body == null)
{
return;
}
var context = new BasicMessageConsumeContext <T>(body);
if (!this._option.AutoAck)
{
context.AckHandler = async(success) =>
{
if (success)
{
this._channel.BasicAck(args.DeliveryTag, multiple: true);
}
else
{
this._channel.BasicNack(args.DeliveryTag, multiple: true, requeue: true);
}
await Task.CompletedTask;
};
}
try
{
await this.OnMessageReceived(context);
await context.Ack(true);
}
catch (Exception e)
{
//log errors
this.logger.AddErrorLog($"rabbitmq消费发生异常:{e.Message}", e);
await context.Ack(false);
}
};
}
