RabbitMQ实现延时任务（代码实例）

Nacos配置

spring:
  rabbitmq:
    host: <rabbitMQ地址>
    port: <开放端口>
    username: <账号>
    password: <密码>
    dynamic: true
    listener:
      simple:
        acknowledge-mode: manual
        default-requeue-rejected: false
        # 消费端最小并发数
        concurrency: 1
        # 消费端最大并发数
        max-concurrency: 10
        # 一次请求中预处理的消息数量
        prefetch: 3
    virtual-host: /
#mq版本----多环境同MQ区分
mqVersion: test

Maven配置

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
            <version>4.0.2</version>
 </dependency>

Config类

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

/**
 * @description:
 * @Author sq.cai
 * @Date 2023/5/19 9:52
 * @Version 1.0
 */
@Configuration
@Data
@RefreshScope
@Component
@Slf4j
public class RabbitConfig {
	/**
		MQ版本
	*/
    @Value("${mqVersion}")
    private String mq_version;

    public static String mqVersion;

    @PostConstruct
    public void setConfig() {
        mqVersion = mq_version;
        //测试任务
        DAEMON_MODEL_DELAY_QUEUE = mqVersion + ".test.model.queue";
        DELAY_EXCHANGE_DAEMON_MODEL = mqVersion + ".test.model.exchange";
        DELAY_ROUTING_KEY_DAEMON_MODEL = mqVersion + ".test.model.rk.delay.001";
    }

    /**
     * 测试任务
     */
    public static String DAEMON_MODEL_DELAY_QUEUE;
    public static String DELAY_EXCHANGE_DAEMON_MODEL;
    public static String DELAY_ROUTING_KEY_DAEMON_MODEL;

    /**
     * 声明延迟交换机
     */
    @Bean("daemonModelExchange")
    public CustomExchange daemonModelExchange() {
        Map<String, Object> args = new HashMap<>(1);
        args.put("x-delayed-type", "direct");
        return new CustomExchange(DELAY_EXCHANGE_DAEMON_MODEL, "x-delayed-message", false, false, args);
    }

    /**
     * 声明业务队列
     */
    @Bean("daemonModel")
    public Queue daemonModel() {
        log.info("mq >>  {}", DAEMON_MODEL_DELAY_QUEUE);
        return QueueBuilder.durable(DAEMON_MODEL_DELAY_QUEUE).build();
    }

    /**
     * 声明延迟队列和延迟交换机的绑定关系
     */
    @Bean
    public Binding delayDaemonModelBinding(Queue daemonModel, CustomExchange daemonModelExchange) {
        return BindingBuilder.bind(daemonModel).to(daemonModelExchange).with(DELAY_ROUTING_KEY_DAEMON_MODEL).noargs();
    }

}

生产者

import com.example.tkyk.config.RabbitConfig;
import com.example.tkyk.entity.vo.LazyQueueVO;
import com.cxlh.tkyk.daemon.enums.DaemonLazyEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

/**
 * @description:
 * @Author sq.cai
 * @Date 2023/5/19 9:54
 * @Version 1.0
 */
@Component
@Slf4j
public class LazyProducer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    /**
     * 测试任务
     *
     * @param msg
     * @param delaySeconds
     */
    public void doDaemonModel(String msg, Long delaySeconds) {
        log.info("MQ测试任务：{}， 延时时间：{} ms，发送时间：{}", msg, delaySeconds,
                LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        MessagePostProcessor messagePostProcessor = message -> {
            message.getMessageProperties().setHeader("x-delay", delaySeconds);
            return message;
        };
        rabbitTemplate.convertAndSend(RabbitConfig.DELAY_EXCHANGE_DAEMON_MODEL, RabbitConfig.DELAY_ROUTING_KEY_DAEMON_MODEL, msg, messagePostProcessor);
    }
}

消费者

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.StopWatch;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @description:
 * @Author sq.cai
 * @Date 2023/5/19 9:57
 * @Version 1.0
 */
@Component
@Slf4j
public class LazyConsumer {
	//消费test任务
	@RabbitListener(queues = "#{daemonModel.name}")
    public void daemonModel(Message message, Channel channel) throws IOException {
        StopWatch s = new StopWatch();
        s.start();
        String msg = new String(message.getBody());
        log.info("收到测试任务消息：{}，当前时间：{}", msg, LocalDateTime.now());
        try {
            //操作具体业务   todo
            //消费成功
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            log.error("任务对象消费失败：{}", e);
            // 消息消费异常后，返回一个nack响应
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
        }finally {
            s.stop();
            log.info("-----rabbitMq收到任务消息花费  >>  {}", s.getTotalTimeMillis() + "ms");
        }
    }
}

------优化消费能力，防止MQ将服务当作不健康服务，不推送消息
------RabbitMQ需要安装rabbitmq_delayed_message_exchange插件，防止任务到期阻塞不执行

应用

//延迟时间（毫秒）
Long relyTime = 1000L;
//延时1秒
lazyProducer.doDaemonModel(JSONUtil.toJsonStr(<对象>), relyTime);