.net core 下使用 Kafka 延迟队列(四)

在电商业务中存在一个场景，用户生成订单，超过30分钟，将订单修改未支付，延迟队列就可以解决该场景问题

 

    public class KafkaTopic
    {
        public static string Topic = "create-order";

        public static string DelayOrderTopic = "order-delay";
    }

 

/// <summary>
        /// 延迟消费消息
        /// </summary>
        public void DelayReveice()
        {
            ConsumerConfig consumerConfig = this.CreateConsumerConnection();
            consumerConfig.AutoOffsetReset = AutoOffsetReset.Earliest;
            consumerConfig.GroupId = "order";//分组为order组
                                             //consumerConfig.FetchMinBytes = 170;//批量取:一次最少取多少消息大小
                                             //consumerConfig.FetchMaxBytes = 3060;//批量取:一次最多取多少消息大小
            var builder = new ConsumerBuilder<string, string>(consumerConfig);
            using (var consumer = builder.Build())
            {
                // 1、订阅
                consumer.Subscribe(KafkaTopic.DelayOrderTopic);
                // 2、偏移量恢复
                string redisValue = this._distributedCache.GetString(KafkaTopic.DelayOrderTopic);
                int offset = 0;
                if (!string.IsNullOrEmpty(redisValue))
                {
                    offset = int.Parse(redisValue);
                }
                this._distributedCache.SetString(KafkaTopic.DelayOrderTopic, (offset + 1).ToString());

                //offset重置
                //consumer.Assign(new TopicPartition(KafkaTopic.Topic, new Partition(1)));
                consumer.Assign(new TopicPartitionOffset(KafkaTopic.DelayOrderTopic, new Partition(0), offset + 1));
                //循环消费消息
                while (true)
                {
                    // 1、恢复消息
                    new Timer((s) =>
                    {
                        consumer.Resume(new List<TopicPartition> { new TopicPartition(KafkaTopic.DelayOrderTopic, new Partition(0)) });
                    }, null, Timeout.Infinite, Timeout.Infinite).Change(60*1000, 60*5000);//5秒之后回复

                    //Change(int dueTime, int period)
                    //dueTime：在首次调用回调方法之前要等待多少毫秒。
                    //    如希望立刻调用回调方法，
                    //    该参数指定为0即可。
                    //period：指定了以后每次调用回调方法之前要等待多少毫秒
                    //    （理解成下一次和本次调用的时间间隔即可）。
                    //    如果为该参数传递Timeout.Infinite(或者直接写 - 1)，
                    //    线程池线程只调用回调方法一次（那也就没有必要用计时器了）。

                    // 1.1、消费暂停
                    consumer.Pause(new List<TopicPartition> { new TopicPartition(KafkaTopic.DelayOrderTopic, new Partition(0)) });

                    // 2、消费消息
                    var result = consumer.Consume(); //批量获取消息，根据-----》字节数
                    try
                    {
                        // 2.1、获取偏移量
                        _logger.LogInformation($"订单消息偏移量：Offset:{result.Offset}");
                        // 3、业务处理
                        string key = result.Key;
                        string value = result.Value;
                        _logger.LogInformation($"创建商品：Key:{key}");
                        _logger.LogInformation($"创建商品：Order:{value}");
                        // redis存储 kafka队列的偏移量
                        _distributedCache.SetString(KafkaTopic.DelayOrderTopic, result.Offset.Value.ToString());
                    }
                    catch (Exception)
                    {

                        throw;
                    }
                    finally
                    {
                        consumer.Pause(new List<TopicPartition> { new TopicPartition(KafkaTopic.DelayOrderTopic, 0) });
                        Console.WriteLine($"暂停消费");
                    }
                }
            }
        }

 

 调用延迟消费

using KafkaCommom;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            _kafKaSevice.DelayReveice();
            await Task.CompletedTask;
        }
    }
}

 

webapi 调用发送消息

 /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        [HttpGet]
        public string Get(string msg)
        {
            this._kafKaSevice.Send(msg);
            return "";
        }

 

测试消费 现在每隔 1分钟消费一次 做到了延迟消费