.net core 下使用 Kafka 批量发送消息，使用事务(四)

批量发送消息，使用事务，要么全失败要么全成功

重要提示 必须设置事物ID

producerConfig.TransactionalId =Guid.NewGuid().ToString();//必须设置事物id

        /// <summary>
        /// 批量发送
        /// </summary>
        /// <param name="msglist"></param>

        public void BatchSends(List<string> msglist)
        {
            ProducerConfig producerConfig = this.CreateProducerConnection();
            producerConfig.MessageTimeoutMs = 5000;//失败重试时间
            producerConfig.EnableIdempotence = true;///幂等性:如果生产者发送失败不重复发消息失败重试
            producerConfig.TransactionalId =Guid.NewGuid().ToString();//必须设置事物id
            var builder = new ProducerBuilder<string, string>(producerConfig);
            builder.SetDefaultPartitioner(RoundRobinPartitioner);//委托:调用负载均衡方法
            using (var producer = builder.Build())
            {
                // 1、初始化事务
                producer.InitTransactions(TimeSpan.FromSeconds(60));
                try
                {
                    // 2、开发事务
                    producer.BeginTransaction();
                    foreach (var item in msglist)
                    {
                        //这里就是测试
                       // var OrderJson = JsonConvert.SerializeObject(item);
                       // var dr = producer.ProduceAsync("order-create", new Message<string, string> { Key = "order", Value = OrderJson }).GetAwaiter().GetResult();
                        var dr = producer.ProduceAsync(KafkaTopic.Topic, new Message<string, string> { Key = "order", Value = item }).GetAwaiter().GetResult();
                        _logger.LogInformation("发送事件 {0} 到 {1} 成功", dr.Value, dr.TopicPartitionOffset);
                    }
                    // 3、提交事务
                    producer.CommitTransaction();
                }
                catch (ProduceException<string, string> ex)
                {
                    _logger.LogError(ex, "发送事件到 {0} 失败，原因 {1} ", "order", ex.Error.Reason);
                    // 4、关闭事务
                    producer.AbortTransaction();
                }
            }
        }

消费消息

        /// <summary>
        /// 消费消息 redis 存储 offset 偏移量
        /// </summary>
        public void Reveice()
        {
            ConsumerConfig consumerConfig = this.CreateConsumerConnection();
            //AutoOffsetReset.Latest 这里是kafka 停止重启 从最新产生的数据开始消费
            //AutoOffsetReset.Earliest 这里是kafka 停止重启 从第0个索引开始消费
            //earliest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
            //latest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
            consumerConfig.AutoOffsetReset = AutoOffsetReset.Earliest;
            consumerConfig.GroupId = "order";//分组为order组
            //consumerConfig.EnableAutoCommit = true;
            //EnableAutoCommit = true//自动确认 如果设置false 会被重复消费
            //缺陷 当业务逻辑 失败时候 可以自动确认 导致 消息丢失
            //所以 要手动确认 但是如果手动确认时候 kafka服务宕机 重启时候会导致重复消费
            //此时就需要 偏移量+1 重置 确保偏移量 是最新的
            var builder = new ConsumerBuilder<string, string>(consumerConfig);
            string redisValue = this._distributedCache.GetString(KafkaTopic.Topic);
            int offset = 0;
            if (!string.IsNullOrEmpty(redisValue))
            {
                offset = int.Parse(redisValue);
            }
            this._distributedCache.SetString(KafkaTopic.Topic, (offset + 1).ToString());
            using (var consumer = builder.Build())
            {
                //offset重置
                //consumer.Assign(new TopicPartition(KafkaTopic.Topic, new Partition(1)));
                consumer.Assign(new TopicPartitionOffset(KafkaTopic.Topic, new Partition(0), offset + 1));
                while (true)
                {
                    // 订阅 生产者的主题
                    consumer.Subscribe(KafkaTopic.Topic);
                    // 消息 获取
                    var result = consumer.Consume();
                    // 获取偏移量
                    _logger.LogInformation($"订单消息偏移量：Offset:{result.Offset}");
                    // 把kafka队列中偏移量存起来。redis mysql
                    // redis存储 kafka队列的偏移量
                    _distributedCache.SetString("create-order", result.Offset.Value.ToString());
                    string key = result.Key;
                    string value = result.Value;
                    //使用了redis 缓存 offset 重置 就不需要手动确认了
                    //consumer.Commit(result);
                    //consumer.StoreOffset(result);
                    this._logger.LogError($" 收到消息了:{value} / offset:{result.Offset}/Partition: {result.Partition} ");
                }
            }
        }

消费消息调用 辅助角色项目 使用的上一篇代码 没有改变

using KafkaCommom;

namespace KafKaWorker
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly KafKaSevice _kafKaSevice;
        public Worker(ILogger<Worker> logger, KafKaSevice kafKaSevice)
        {
            _logger = logger;
            _kafKaSevice = kafKaSevice;
        }

        protected override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            _kafKaSevice.Reveice();
            return Task.CompletedTask;
        }
    }
}

 

webapi 调用批量发送消息

 /// <summary>
        /// 批量发送消息
        /// </summary>
        /// <param name="msglist"></param>
        /// <returns></returns>
        [HttpPost("BatchSend")]
        public string BatchSend(List<string> msglist) {

            this._kafKaSevice.BatchSends(msglist);
            return "";
        }

测试