一、功能介绍
要实现一个消息的定时发送功能，也就是让消息可以在某一天某一个时间具体节点进行发送。而我们公司的业务场景是类似短信的业务，而且数量不小，用户会进行号码、消息内容、定时发送时间等信息的提交。等到了设定的定时时间，则进行消息的发送工作。
二、思考实现逻辑
前提准备：
MySQL
RocketMQ，最好broker开启队列自动创建的配置
刚开始我想的是基于MySQL去实现定时发送，后来觉得这种扫描方式单线程的时候并发能力不够，多线程也得需要做并发控制，还得做一些任务的调度，比如线程执行一半卡死或者异常的时候，还得做任务的补偿工作。所以，后面我选择了通过组件的方式实现，这是我想到了消息队列的延迟发送功能，刚好我司系统用到了RocketMQ，我就想通过该组件实现该消息的定时发送功能。RocketMQ的文件默认只保存72小时，这个要注意一下，有需要调整时间的需要调整一下。我也不建议调整的太大，这样容易引起系统的资源浪费。
具体实现逻辑如下：
1）用户创建消息，记录到数据库（号码，内容，定时发送时间）
2）如果是是可以立即发送的消息，发送消息到RocketMQ的立即发送主题（TOPIC_NOW_SEND）中，后续有线程消费该消息，直接进行数据发送。
3）如果是需要定时发送的消息，发送消息到RocketMQ的延迟发送主题（TOPIC_DELAY_SEND）中。
这里有一些细节设置：
tags：可以用于同一主题下区分不同类型的消息。此处可以设定为当前日期（我是用的是YYYYMMDD，例如：20220730），因为设定为需要发送的当天日期后，程序就可以通过该字段分辨是否需要处理。后续消费者就可以通过当天日期筛选需要当天发送的消息，过滤掉不是当天需要发送的消息。
keys：索引，可以用于查询消息。我们设定的格式可以是【订单号+消息定时发送的时间戳（可以是毫秒级）】，例如：FS20220730123456+16591914490001
4）启动两个（或者多个，这个和文件保存的时间有关系）消费者进行轮换，这里我称之为masterConsumer（启动时负责消费前一天的数据）和slaveConsumer（启动时负责消费当天的数据）。这里我设计的初衷是每天有自己的消费者，例如20220730消费tags=20220730的数据，20220731消费tags=20220731的数据。这里需要消费前一天的数据原因是，需要防止出现晚上23:59分提交消息的时候，当天没处理完。所以，需要在第二天进行额外的补偿操作。
程序启动第1天（例如当天是20220730）：
masterConsumer：MASTER_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220729
slaveConsumer：SLAVE_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220730
程序启动第2天（例如当天是20220731）：
slaveConsumer：SLAVE_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220730
masterConsumer：MASTER_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220731
程序启动第3天（例如当天是20220801）：
masterConsumer：MASTER_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220731
slaveConsumer：SLAVE_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220801
程序启动第4天（例如当天是20220802）：
slaveConsumer：SLAVE_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220801
masterConsumer：MASTER_CONSUMER_TOPIC_DELAY_SEND 消费tags=20220802
……
程序的masterConsumer和slaveConsumer就这样持续轮换消费数据。
5）消费者的消费数据逻辑：
消费者需要设置consumeFromWhere参数=CONSUME_FROM_FIRST_OFFSET（默认是ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET，从最新的位置开始消费），这样数据才可以第一次启动从队列的最前位置开始消费。
消费到数据之后，获取keys的内容，根据之前发送的设定获取消息定时发送的时间戳，然后和当前的时间进行比对。这里要比对的主要原因是当前 RocketMQ 不支持任意时间的延迟。 生产者发送延迟消息前需要设置几个固定的延迟级别，分别对应1s到2h的1到18个延迟级，消息消费失败会进入延迟消息队列，消息发送时间与设置的延迟级别和重试次数有关。
当前支持的消息延迟级别有：
private String messageDelayLevel = “1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h”;
如果比对时间<=1秒，则直接发送到RocketMQ的立即发送主题（TOPIC_NOW_SEND）中，后续有线程进行消费发送；否则，发送时间根据RocketMQhi吃的延迟级别进行选择，按照最大可支持的时间为准，等待后续的消息重新消费，直到最终消息符合条件，可以投递到RocketMQ的立即发送主题（TOPIC_NOW_SEND）为止。例如：如果比对时间>2h，则重新投递到延迟发送主题（TOPIC_DELAY_SEND）中，延迟发送的等级为18（也就是2h)。如果比对时间>2m，比对时间<3m，则重新投递到延迟发送主题（TOPIC_DELAY_SEND）中，延迟发送的等级为6（也就是2m)。
6）在第4步骤中的masterConsumer和slaveConsumer的轮换逻辑支持，即在过了0点之后，前一天的consumer需要进行重置。
以上就是我的实现逻辑。
三、敲代码
1、定义延迟级别与时间的对应关系
package cn.lxw.mq.constant; import java.util.Arrays; public enum MessageDelayLevel { SECOND_1(1, 1 * 1000L), SECOND_5(2, 5 * 1000L), SECOND_10(3, 10 * 1000L), SECOND_30(4, 30 * 1000L), MINUTE_1(5, 1 * 60 * 1000L), MINUTE_2(6, 2 * 60 * 1000L), MINUTE_3(7, 3 * 60 * 1000L), MINUTE_4(8, 4 * 60 * 1000L), MINUTE_5(9, 5 * 60 * 1000L), MINUTE_6(10, 6 * 60 * 1000L), MINUTE_7(11, 7 * 60 * 1000L), MINUTE_8(12, 8 * 60 * 1000L), MINUTE_9(13, 9 * 60 * 1000L), MINUTE_10(14, 10 * 60 * 1000L), MINUTE_20(15, 20 * 60 * 1000L), MINUTE_30(16, 30 * 60 * 1000L), HOUR_1(17, 1 * 60 * 60 * 1000L), HOUR_2(18, 2 * 60 * 60 * 1000L), ; // 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h private Integer level; private Long mills; MessageDelayLevel(Integer level, Long mills) { this.level = level; this.mills = mills; } public Integer getLevel() { return level; } public void setLevel(Integer level) { this.level = level; } public Long getMills() { return mills; } public void setMills(Long mills) { this.mills = mills; } /** * 功能描述: <br> * 〈计算需等待的时间，最长2小时〉 * @Param: [timeMills] * @Return: {@link MessageDelayLevel} * @Author: luoxw * @Date: 2022/7/26 16:33 */ public static MessageDelayLevel getMaxLevel(long timeMills){ long millsBwt = timeMills - System.currentTimeMillis(); if(millsBwt < 1000L){ millsBwt = 1000L; } final long paramMills = millsBwt; return Arrays.asList(MessageDelayLevel.values()).stream().filter(p -> p.mills.compareTo(paramMills) <= 0).max((c1,c2) -> c1.getLevel().compareTo(c2.getLevel())).orElse(HOUR_2); } public static void main(String[] args) { getMaxLevel(2 * 60 * 60 * 1000L); getMaxLevel(2 * 60 * 60 * 1000L + 1); getMaxLevel(2 * 60 * 60 * 1000L - 1); getMaxLevel( 6 * 1000L); getMaxLevel( 5 * 1000L); getMaxLevel( System.currentTimeMillis()); } }
2、延迟消息消费逻辑
package cn.lxw.task; import cn.hutool.core.thread.ThreadUtil; import com.alibaba.rocketmq.client.consumer.DefaultMQPushConsumer; import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext; import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus; import com.alibaba.rocketmq.client.consumer.listener.MessageListenerConcurrently; import com.alibaba.rocketmq.client.producer.DefaultMQProducer; import com.alibaba.rocketmq.client.producer.SendResult; import com.alibaba.rocketmq.common.message.MessageExt; import cn.lxw.Consumer; import cn.lxw.DateUtil; import cn.lxw.constant.LogConst; import cn.lxw.context.AppEnvContext; import cn.lxw.enums.EnumMQTopic; import cn.lxw.mq.constant.MessageDelayLevel; import cn.lxw.util.ProducerUtil; import lombok.extern.slf4j.Slf4j; import java.util.Date; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; @Slf4j public class Send_DelayMessageTask implements Runnable { private DefaultMQProducer defaultSendProducer; private DefaultMQProducer defaultDelayProducer; private static volatile String currentDate = DateUtil.operateDate(new Date(), 0); private DefaultMQPushConsumer masterDelayConsumer; private static volatile String lastDate = DateUtil.operateDate(new Date(), -1); private DefaultMQPushConsumer slaveDelayConsumer; // 2个消费者的时候，奇数更新master消费者，偶数更新slave消费者 private static volatile AtomicInteger closeCnt = new AtomicInteger(); public Send_DelayMessageTask() { try { String rocketMQAddr = AppEnvContext.getPropValue("rocketmq.address"); defaultSendProducer = ProducerUtil.init(rocketMQAddr, "PRODUCER_TOPIC_NOW_SEND"); defaultDelayProducer = ProducerUtil.init(rocketMQAddr, "PRODUCER_TOPIC_DELAY_SEND"); // 主从消费者交替进行数据消费。 // 初始化的时候，主消费者消费昨天（1月1日）的数据，从消费者消费今天（1月2日）的数据。 int consumeThreadMin = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeThreadMin", 10); int consumeThreadMax = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeThreadMax", 10); int consumeMessageBatchMaxSize = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeMessageBatchMaxSize", 10); masterDelayConsumer = Consumer.getInstance( "TOPIC_DELAY_SEND", "MASTER_CONSUMER_TOPIC_DELAY_SEND", rocketMQAddr, lastDate, consumeThreadMin, consumeThreadMax, consumeMessageBatchMaxSize ); slaveDelayConsumer = Consumer.getInstance( "TOPIC_DELAY_SEND", "SLAVE_CONSUMER_TOPIC_DELAY_SEND", rocketMQAddr, currentDate, consumeThreadMin, consumeThreadMax, consumeMessageBatchMaxSize ); } catch (Exception e) { log.error(LogConst.PREFIX + "初始化异常", e); } } // 消费者重启 private void restartConsumer(DefaultMQPushConsumer consumer, String consumerName) throws Exception { String rocketMQAddr = AppEnvContext.getPropValue("rocketmq.address"); consumer.shutdown(); int consumeThreadMin = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeThreadMin", 10); int consumeThreadMax = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeThreadMax", 10); int consumeMessageBatchMaxSize = AppEnvContext.getPropValueIntOrDefault("delay.consumer.consumeMessageBatchMaxSize", 10); consumer = Consumer.getInstance( "TOPIC_DELAY_SEND", consumerName, rocketMQAddr, currentDate, consumeThreadMin, consumeThreadMax, consumeMessageBatchMaxSize ); MessageListenerConcurrently listener = getDelayListener(); consumer.registerMessageListener(listener); consumer.start(); closeCnt.incrementAndGet(); } // 重新初始化消费者 private synchronized void reInitComsumer(){ try { String thisDate = DateUtil.operateDate(new Date(), 0); int lastCloseCnt = closeCnt.get(); // 初始化的时候不执行 and 时间没跨度的时候不执行，只有当第二天的时候才执行数据 if(lastCloseCnt > 0 && !thisDate.equals(currentDate)){ // 获取今天的时间 currentDate = thisDate; // 如果时间对2取余的值为1，则更新主消费者，之前的昨天（1月1日）更新为第二天（1月3日）的数据 if(closeCnt.get() % 2 == 1) { restartConsumer(masterDelayConsumer, "MASTER_CONSUMER_TOPIC_DELAY_SEND"); } // 如果时间对2取余的值为0，则更新从消费者，之前的今天（1月2日）更新为第三天（1月4日）的数据 if(closeCnt.get() % 2 == 0){ restartConsumer(slaveDelayConsumer, "SLAVE_CONSUMER_TOPIC_DELAY_SEND"); } } } catch (Exception e) { log.error(LogConst.PREFIX + "消费者重新初始化异常", e); } } // 消费逻辑 private MessageListenerConcurrently getDelayListener(){ MessageListenerConcurrently listener = (List<MessageExt> list, ConsumeConcurrentlyContext context) -> { for (MessageExt msg : list) { String msgBody = null; try { msgBody = new String(msg.getBody()); String msgKeys = msg.getKeys(); // 订单号+发送时间戳 String[] split = msgKeys.split("//+"); if(split.length == 2) { String delaySendTimeStr = split[1]; long time = DateUtil.parseStr2TimeMills(delaySendTimeStr); // 时间比对，获取最大支持的延迟级别 MessageDelayLevel maxLevel = MessageDelayLevel.getMaxLevel(time); Integer level = maxLevel.getLevel(); // 如果延迟级别=1，也就是小于等于1秒的时候，直接发送到立即发送主题（TOPIC_NOW_SEND） if (MessageDelayLevel.SECOND_1.getLevel().equals(level)) { SendResult sendResult = ProducerUtil.syncSend( defaultSendProducer, "TOPIC_NOW_SEND", msg.getTags(), msg.getKeys(), msgBody ); log.info(LogConst.PREFIX + "定时消息[{}]发送到[立即发送主题]结果:{}", msgBody, sendResult); } else { SendResult sendResult = ProducerUtil.syncSendDelay( defaultDelayProducer, "TOPIC_DELAY_SEND", msg.getTags(), msg.getKeys(), level, msgBody ); log.info(LogConst.PREFIX + "定时消息[{}]发送到[延迟发送主题]结果:{}", msgBody, sendResult); } } } catch (Exception ex) { log.error(LogConst.PREFIX + "定时消息[{}]发送异常", msgBody, ex); } } return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; }; return listener; } @Override public void run() { try { MessageListenerConcurrently masterListener = getDelayListener(); masterDelayConsumer.registerMessageListener(masterListener); MessageListenerConcurrently slaveListener = getDelayListener(); slaveDelayConsumer.registerMessageListener(slaveListener); // 启动消费者 masterDelayConsumer.start(); slaveDelayConsumer.start(); }catch (Exception ex){ log.error(LogConst.PREFIX + "定时消息消费程序启动异常", ex); } while (true){ // 一分钟检查一次是否需要轮换消费者 ThreadUtil.sleep(60 * 1000); reInitComsumer(); } } }
3、其余的逻辑就不展示了，可以根据自己实际业务情况进行处理。
四、总结
这是我实现的一个方式，其实是不太完美的，因为量大的时候性能也是有问题的，因为根据RocketMQ文件保存的时间（默认72小时）因素决定。如果保存的时间太长，消息太多，而我们的程序第一次启动从队列的最前位置开始消费，此时的消息数据是巨大的。不管是对RocketMQ组件，还是对我们程序都是一个压力，而且目前的消息过滤功能只能在客户端进行处理。所以，这里我建议的是一天一个主题，以定时发送的当天进行发送。例如：20220730需要发送的数据用TOPIC_DELAY_SEND_20220730主题；20220731需要发送的数据用TOPIC_DELAY_SEND_20220731主题。这样的话，数据消费的时候也不需要通过tags进行过滤了，只需要通过keys的时间戳数据进行判断，消费逻辑大致和文中写法一样，只需要调整延迟发送的主题名为【TOPIC_DELAY_SEND_YYYYMMDD】，发送和轮换的延迟发送主题也需要根据发送时间进行调整。
以上思路仅供各位参考使用，有更好的实现方式可以在下方进行留言。谢谢大家的观看！衷心感谢！
