• 售前

  • 售后

热门帖子
入门百科

基于rabbitmq延迟插件实现分布式延迟任务

[复制链接]
里脊鱼鱼si 显示全部楼层 发表于 2022-1-13 09:02:36 |阅读模式 打印 上一主题 下一主题
一、延迟任务的使用场景

1、下单成功,30分钟未支付。支付超时,自动取消订单
2、订单签收,签收后7天未进行评价。订单超时未评价,系统默认好评
3、下单成功,商家5分钟未接单,订单取消
4、配送超时,推送短信提醒
5、三天会员试用期,三天到期后准时准点通知用户,试用产品到期了
......
对于延时比较长的场景、实时性不高的场景,我们可以采用任务调度的方式定时轮询处理。如:xxl-job。

今天我们讲解延迟队列的实现方式,而延迟队列有很多种实现方式,普遍会采用如下等方式,如:


  • 1.如基于RabbitMQ的队列ttl+死信路由策略:通过设置一个队列的超时未消费时间,配合死信路由策略,到达时间未消费后,回会将此消息路由到指定队列
  • 2.基于RabbitMQ延迟队列插件(rabbitmq-delayed-message-exchange):发送消息时通过在请求头添加延时参数(headers.put("x-delay", 5000))即可达到延迟队列的效果。(顺便说一句阿里云的收费版rabbitMQ当前可支持一天以内的延迟消息),局限性:目前该插件的当前设计并不真正适合包含大量延迟消息(例如数十万或数百万)的场景,详情参见 #/issues/72 另外该插件的一个可变性来源是依赖于 Erlang 计时器,在系统中使用了一定数量的长时间计时器之后,它们开始争用调度程序资源。

  • 3.使用redis的zset有序性,轮询zset中的每个元素,到点后将内容迁移至待消费的队列,(redisson已有实现)


  • 4.使用redis的key的过期通知策略,设置一个key的过期时间为延迟时间,过期后通知客户端(此方式依赖redis过期检查机制key多后延迟会比较严重;Redis的pubsub不会被持久化,服务器宕机就会被丢弃)。
二、组件安装

安装rabbitMQ需要依赖erlang语言环境,所以需要我们下载erlang的环境安装程序。网上有很多安装教程,这里不再贴图累述,需要注意的是:该延迟插件支持的版本匹配。
插件Git官方地址:https://github.com/rabbitmq/rabbitmq-delayed-message-exchange



当你成功安装好插件后运行起rabbitmq管理后台,在新建exchange里就可以看到type类型中多出了这个选项

三、RabbitMQ延迟队列插件的延迟队列实现

1、基本原理




  通过 x-delayed-message 声明的交换机,它的消息在发布之后不会立即进入队列,先将消息保存至 Mnesia(一个分布式数据库管理系统,适合于电信和其它需要持续运行和具备软实时特性的 Erlang 应用。目前资料介绍的不是很多)
  这个插件将会尝试确认消息是否过期,首先要确保消息的延迟范围是 Delay > 0, Delay =< ?ERL_MAX_T(在 Erlang 中可以被设置的范围为 (2^32)-1 毫秒),如果消息过期通过 x-delayed-type 类型标记的交换机投递至目标队列,整个消息的投递过程也就完成了。
2、核心组件开发走起

引入maven依赖
  1. <dependency>
  2.          <groupId>org.springframework.boot</groupId>
  3.          <artifactId>spring-boot-starter-amqp</artifactId>
  4. </dependency>
复制代码
application.yml简单配置
  1.   rabbitmq:
  2.     host: localhost
  3.     port: 5672
  4.     virtual-host: /
复制代码

RabbitMqConfig配置文件
  1. package com.example.code.bot_monomer.config;
  2. import org.springframework.amqp.core.Binding;
  3. import org.springframework.amqp.core.BindingBuilder;
  4. import org.springframework.amqp.core.CustomExchange;
  5. import org.springframework.amqp.core.Exchange;
  6. import org.springframework.amqp.core.ExchangeBuilder;
  7. import org.springframework.amqp.core.Queue;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import java.util.HashMap;
  11. import java.util.Map;
  12. /**
  13. * @author: shf description: date: 2022/1/5 15:00
  14. */
  15. @Configuration
  16. public class RabbitMQConfig {
  17.     /**
  18.      * 普通
  19.      */
  20.     public static final String EXCHANGE_NAME = "test_exchange";
  21.     public static final String QUEUE_NAME = "test001_queue";
  22.     public static final String NEW_QUEUE_NAME = "test002_queue";
  23.     /**
  24.      * 延迟
  25.      */
  26.     public static final String DELAY_EXCHANGE_NAME = "delay_exchange";
  27.     public static final String DELAY_QUEUE_NAME = "delay001_queue";
  28.     public static final String DELAY_QUEUE_ROUT_KEY = "key001_delay";
  29.     //由于阿里rabbitmq增加队列要额外收费,现改为各业务延迟任务共同使用一个queue:delay001_queue
  30.     //public static final String NEW_DELAY_QUEUE_NAME = "delay002_queue";
  31.    
  32.     @Bean
  33.     public CustomExchange delayMessageExchange() {
  34.         Map<String, Object> args = new HashMap<>();
  35.         args.put("x-delayed-type", "direct");
  36.         //自定义交换机
  37.         return new CustomExchange(DELAY_EXCHANGE_NAME, "x-delayed-message", true, false, args);
  38.     }
  39.     @Bean
  40.     public Queue delayMessageQueue() {
  41.         return new Queue(DELAY_QUEUE_NAME, true, false, false);
  42.     }
  43.     @Bean
  44.     public Binding bindingDelayExchangeAndQueue(Queue delayMessageQueue, Exchange delayMessageExchange) {
  45.         return new Binding(DELAY_QUEUE_NAME, Binding.DestinationType.QUEUE, DELAY_EXCHANGE_NAME, DELAY_QUEUE_ROUT_KEY, null);
  46.         //return BindingBuilder.bind(delayMessageQueue).to(delayMessageExchange).with("key001_delay").noargs();
  47.     }
  48.    
  49.     /**
  50.      * 交换机
  51.      */
  52.     @Bean
  53.     public Exchange orderExchange() {
  54.         return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
  55.         //return new TopicExchange(EXCHANGE_NAME, true, false);
  56.     }
  57.     /**
  58.      * 队列
  59.      */
  60.     @Bean
  61.     public Queue orderQueue() {
  62.         //return QueueBuilder.durable(QUEUE_NAME).build();
  63.         return new Queue(QUEUE_NAME, true, false, false, null);
  64.     }
  65.     /**
  66.      * 队列
  67.      */
  68.     @Bean
  69.     public Queue orderQueue1() {
  70.         //return QueueBuilder.durable(NEW_QUEUE_NAME).build();
  71.         return new Queue(NEW_QUEUE_NAME, true, false, false, null);
  72.     }
  73.     /**
  74.      * 交换机和队列绑定关系
  75.      */
  76.     @Bean
  77.     public Binding orderBinding(Queue orderQueue, Exchange orderExchange) {
  78.         //return BindingBuilder.bind(queue).to(exchange).with("#.delay").noargs();
  79.         return new Binding(QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "test001_common", null);
  80.     }
  81.     /**
  82.      * 交换机和队列绑定关系
  83.      */
  84.     @Bean
  85.     public Binding orderBinding1(Queue orderQueue1, Exchange orderExchange) {
  86.         //return BindingBuilder.bind(queue).to(exchange).with("#.delay").noargs();
  87.         return new Binding(NEW_QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "test001_common", null);
  88.     }
  89. }
复制代码
MqDelayQueueEnum枚举类
  1. package com.example.code.bot_monomer.enums;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Getter;
  4. import lombok.NoArgsConstructor;
  5. /**
  6. * @author: shf description: 延迟队列业务枚举类
  7. * date: 2021/8/27 14:03
  8. */
  9. @Getter
  10. @NoArgsConstructor
  11. @AllArgsConstructor
  12. public enum MqDelayQueueEnum {
  13.     /**
  14.      * 业务0001
  15.      */
  16.     YW0001("yw0001", "测试0001", "yw0001"),
  17.     /**
  18.      * 业务0002
  19.      */
  20.     YW0002("yw0002", "测试0002", "yw0002");
  21.     /**
  22.      * 延迟队列业务区分唯一Key
  23.      */
  24.     private String code;
  25.     /**
  26.      * 中文描述
  27.      */
  28.     private String name;
  29.     /**
  30.      * 延迟队列具体业务实现的 Bean 可通过 Spring 的上下文获取
  31.      */
  32.     private String beanId;
  33.     public static String getBeanIdByCode(String code) {
  34.         for (MqDelayQueueEnum queueEnum : MqDelayQueueEnum.values()) {
  35.             if (queueEnum.code.equals(code)) {
  36.                 return queueEnum.beanId;
  37.             }
  38.         }
  39.         return null;
  40.     }
  41. }
复制代码

模板接口处理类:MqDelayQueueHandle
  1. package com.example.code.bot_monomer.service.mqDelayQueue;
  2. /**
  3. * @author: shf description: RabbitMQ延迟队列方案处理接口
  4. * date: 2022/1/10 10:46
  5. */
  6. public interface MqDelayQueueHandle<T> {
  7.     void execute(T t);
  8. }
复制代码

具体业务实现处理类
  1. @Slf4j
  2. @Component("yw0001")
  3. public class MqTaskHandle01 implements MqDelayQueueHandle<String> {
  4.     @Override
  5.     public void execute(String s) {
  6.         log.info("MqTaskHandle01.param=[{}]",s);
  7.         //TODO
  8.     }
  9. }
复制代码

注意:@Component("yw0001") 要和业务枚举类MqDelayQueueEnum中对应的beanId保持一致。
统一消息体封装类
  1. /**
  2. * @author: shf description: date: 2022/1/10 10:51
  3. */
  4. @Data
  5. @NoArgsConstructor
  6. @AllArgsConstructor
  7. @Builder
  8. public class MqDelayMsg<T> {
  9.     /**
  10.      * 业务区分唯一key
  11.      */
  12.     @NonNull
  13.     String businessCode;
  14.     /**
  15.      * 消息内容
  16.      */
  17.     @NonNull
  18.     T content;
  19. }
复制代码

统一消费分发处理Consumer
  1. package com.example.code.bot_monomer.service.mqConsumer;
  2. import com.alibaba.fastjson.JSONObject;
  3. import com.example.code.bot_monomer.config.common.MqDelayMsg;
  4. import com.example.code.bot_monomer.enums.MqDelayQueueEnum;
  5. import com.example.code.bot_monomer.service.mqDelayQueue.MqDelayQueueHandle;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.amqp.core.Message;
  8. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
  9. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.context.ApplicationContext;
  12. import org.springframework.stereotype.Component;
  13. import lombok.extern.slf4j.Slf4j;
  14. /**
  15. * @author: shf description: date: 2022/1/5 15:12
  16. */
  17. @Slf4j
  18. @Component
  19. //@RabbitListener(queues = "test001_queue")
  20. @RabbitListener(queues = "delay001_queue")
  21. public class TestConsumer {
  22.     @Autowired
  23.     ApplicationContext context;
  24.     /**
  25.      * RabbitHandler 会自动匹配 消息类型(消息自动确认)
  26.      *
  27.      * @param msgStr
  28.      * @param message
  29.      */
  30.     @RabbitHandler
  31.     public void taskHandle(String msgStr, Message message) {
  32.         try {
  33.             MqDelayMsg msg = JSONObject.parseObject(msgStr, MqDelayMsg.class);
  34.             log.info("TestConsumer.taskHandle:businessCode=[{}],deliveryTag=[{}]", msg.getBusinessCode(), message.getMessageProperties().getDeliveryTag());
  35.             String beanId = MqDelayQueueEnum.getBeanIdByCode(msg.getBusinessCode());
  36.             if (StringUtils.isNotBlank(beanId)) {
  37.                 MqDelayQueueHandle<Object> handle = (MqDelayQueueHandle<Object>) context.getBean(beanId);
  38.                 handle.execute(msg.getContent());
  39.             } else {
  40.                 log.warn("TestConsumer.taskHandle:MQ延迟任务不存在的beanId,businessCode=[{}]", msg.getBusinessCode());
  41.             }
  42.         } catch (Exception e) {
  43.             log.error("TestConsumer.taskHandle:MQ延迟任务Handle异常:", e);
  44.         }
  45.     }
  46. }
复制代码

最后简单封装个工具类
  1. package com.example.code.bot_monomer.utils;
  2. import com.alibaba.fastjson.JSON;
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.example.code.bot_monomer.config.RabbitMQConfig;
  5. import com.example.code.bot_monomer.config.common.MqDelayMsg;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.lang.NonNull;
  11. import org.springframework.stereotype.Component;
  12. import java.time.LocalDateTime;
  13. import java.time.temporal.ChronoUnit;
  14. import java.util.Objects;
  15. import lombok.extern.slf4j.Slf4j;
  16. /**
  17. * @author: shf description: MQ分布式延迟队列工具类 date: 2022/1/10 15:20
  18. */
  19. @Slf4j
  20. @Component
  21. public class MqDelayQueueUtil {
  22.     @Autowired
  23.     private RabbitTemplate template;
  24.     @Value("${mqdelaytask.limit.days:2}")
  25.     private Integer mqDelayLimitDays;
  26.     /**
  27.      * 添加延迟任务
  28.      *
  29.      * @param bindId 业务绑定ID,用于关联具体消息
  30.      * @param businessCode 业务区分唯一标识
  31.      * @param content      消息内容
  32.      * @param delayTime    设置的延迟时间 单位毫秒
  33.      * @return 成功true;失败false
  34.      */
  35.     public boolean addDelayQueueTask(@NonNull String bindId, @NonNull String businessCode, @NonNull Object content, @NonNull Long delayTime) {
  36.         log.info("MqDelayQueueUtil.addDelayQueueTask:bindId={},businessCode={},delayTime={},content={}", bindId, businessCode, delayTime, JSON.toJSONString(content));
  37.         if (StringUtils.isAnyBlank(bindId, businessCode) || Objects.isNull(content) || Objects.isNull(delayTime)) {
  38.             return false;
  39.         }
  40.         try {
  41.             //TODO 延时时间大于2天的先加入数据库表记录,后由定时任务每天拉取2次将低于2天的延迟记录放入MQ中等待到期执行
  42.             if (ChronoUnit.DAYS.between(LocalDateTime.now(), LocalDateTime.now().plus(delayTime, ChronoUnit.MILLIS)) >= mqDelayLimitDays) {
  43.                 //TODO
  44.             } else {
  45.                 this.template.convertAndSend(
  46.                     RabbitMQConfig.DELAY_EXCHANGE_NAME,
  47.                     RabbitMQConfig.DELAY_QUEUE_ROUT_KEY,
  48.                     JSONObject.toJSONString(MqDelayMsg.<Object>builder().businessCode(businessCode).content(content).build()),
  49.                     message -> {
  50.                         //注意这里时间可使用long类型,毫秒单位,设置header
  51.                         message.getMessageProperties().setHeader("x-delay", delayTime);
  52.                         return message;
  53.                     }
  54.                 );
  55.             }
  56.         } catch (Exception e) {
  57.             log.error("MqDelayQueueUtil.addDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
  58.             return false;
  59.         }
  60.         return true;
  61.     }
  62.     /**
  63.      * 撤销延迟消息
  64.      * @param bindId 业务绑定ID,用于关联具体消息
  65.      * @param businessCode 业务区分唯一标识
  66.      * @return 成功true;失败false
  67.      */
  68.     public boolean cancelDelayQueueTask(@NonNull String bindId, @NonNull String businessCode) {
  69.         if (StringUtils.isAnyBlank(bindId,businessCode)) {
  70.             return false;
  71.         }
  72.         try {
  73.             //TODO 查询DB,如果消息还存在即可删除
  74.         } catch (Exception e) {
  75.             log.error("MqDelayQueueUtil.cancelDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
  76.             return false;
  77.         }
  78.         return true;
  79.     }
  80.     /**
  81.      * 修改延迟消息
  82.      * @param bindId 业务绑定ID,用于关联具体消息
  83.      * @param businessCode 业务区分唯一标识
  84.      * @param content      消息内容
  85.      * @param delayTime    设置的延迟时间 单位毫秒
  86.      * @return 成功true;失败false
  87.      */
  88.     public boolean updateDelayQueueTask(@NonNull String bindId, @NonNull String businessCode, @NonNull Object content, @NonNull Long delayTime) {
  89.         if (StringUtils.isAnyBlank(bindId, businessCode) || Objects.isNull(content) || Objects.isNull(delayTime)) {
  90.             return false;
  91.         }
  92.         try {
  93.             //TODO 查询DB,消息不存在返回false,存在判断延迟时长入库或入mq
  94.             //TODO 延时时间大于2天的先加入数据库表记录,后由定时任务每天拉取2次将低于2天的延迟记录放入MQ中等待到期执行
  95.             if (ChronoUnit.DAYS.between(LocalDateTime.now(), LocalDateTime.now().plus(delayTime, ChronoUnit.MILLIS)) >= mqDelayLimitDays) {
  96.                 //TODO
  97.             } else {
  98.                 this.template.convertAndSend(
  99.                     RabbitMQConfig.DELAY_EXCHANGE_NAME,
  100.                     RabbitMQConfig.DELAY_QUEUE_ROUT_KEY,
  101.                     JSONObject.toJSONString(MqDelayMsg.<Object>builder().businessCode(businessCode).content(content).build()),
  102.                     message -> {
  103.                         //注意这里时间可使用long类型,毫秒单位,设置header
  104.                         message.getMessageProperties().setHeader("x-delay", delayTime);
  105.                         return message;
  106.                     }
  107.                 );
  108.             }
  109.         } catch (Exception e) {
  110.             log.error("MqDelayQueueUtil.updateDelayQueueTask:bindId={}businessCode={}异常:", bindId, businessCode, e);
  111.             return false;
  112.         }
  113.         return true;
  114.     }
  115. }
复制代码

附上测试类:
  1. /**
  2. * description: 延迟队列测试
  3. *
  4. * @author: shf date: 2021/8/27 14:18
  5. */
  6. @RestController
  7. @RequestMapping("/mq")
  8. @Slf4j
  9. public class MqQueueController {
  10.     @Autowired
  11.     private MqDelayQueueUtil mqDelayUtil;
  12.     @PostMapping("/addQueue")
  13.     public String addQueue() {
  14.         mqDelayUtil.addDelayQueueTask("00001",MqDelayQueueEnum.YW0001.getCode(),"delay0001测试",3000L);
  15.         return "SUCCESS";
  16.     }
  17. }
复制代码

贴下DB记录表的字段设置



配合xxl-job定时任务即可。
  由于投递后的消息无法修改,设置延迟消息需谨慎!并需要与业务方配合,如:延迟时间在2天以内(该时间天数可调整,你也可以设置阈值单位为小时,看业务需求)的消息不支持修改与撤销。2天之外的延迟消息支持撤销与修改,需要注意的是,需要绑定关联具体操作业务唯一标识ID以对应关联操作撤销或修改。(PS:延迟时间设置在2天以外的会先保存到DB记录表由定时任务每天拉取到时2天内的投放到延迟对列)。
  再稳妥点,为了防止进入DB记录的消息有操作时间误差导致的不一致问题,可在消费统一Consumer消费分发前,查询DB记录表,该消息是否已被撤销删除(增加个删除标记字段记录),并且当前时间大于等于DB表中记录的到期执行时间才能分发出去执行,否则弃用。


此外,利用rabbitmq的死信队列机制也可以实现延迟任务,有时间再附上实现案例。

来源:https://blog.caogenba.net/ydcdm0011/article/details/122459908
免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!

帖子地址: 

回复

使用道具 举报

分享
推广
火星云矿 | 预约S19Pro,享500抵1000!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

草根技术分享(草根吧)是全球知名中文IT技术交流平台,创建于2021年,包含原创博客、精品问答、职业培训、技术社区、资源下载等产品服务,提供原创、优质、完整内容的专业IT技术开发社区。
  • 官方手机版

  • 微信公众号

  • 商务合作