【使用redisson完成延迟队列的功能】使用redisson配合线程池完成异步执行功能，延迟队列和不需要延迟的队列

打乒乓球只会抽

已于 2024-03-22 10:24:09 修改

阅读量2k

点赞数 6

CC 4.0 BY-SA版权

文章标签： redis

于 2024-03-22 10:05:55 首次发布

本文链接：https://blog.csdn.net/qq_60969145/article/details/136929220

本文介绍了如何在SpringBoot项目中使用Redisson库实现延迟队列功能，包括添加、获取和删除延迟队列操作，以及与之相对的非延迟队列操作。同时提到了如何配置和监控队列执行器，以及启动队列监测扫描。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 使用redisson完成延迟队列的功能

引入依赖

spring-boot-starter-actuator是Spring Boot提供的一个用于监控和管理应用程序的模块
用于查看应用程序的健康状况、审计信息、指标和其他有用的信息。这些端点可以帮助你监控应用程序的运行状态、性能指标和健康状况。
已经有了其他的监控和管理工具，不需要使用Spring Boot Actuator提供的功能。

<!-- redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </exclusion>
    </exclusions>
</dependency>

1.1 延时队列工具类

添加延迟队列时使用，监测扫描时也会用这个工具类进行获取消息

package cn.creatoo.common.redis.queue;

import cn.creatoo.common.core.utils.StringUtils;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 分布式延时队列工具类
 * @author
 */
@Component
@ConditionalOnBean({
   
   RedissonClient.class})
public class RedisDelayQueueUtil {
   
   

    private static final Logger log = LoggerFactory.getLogger(RedisDelayQueueUtil.class);

    @Resource
    private RedissonClient redissonClient;

    /**
     * 添加延迟队列
     *
     * @param value     队列值
     * @param delay     延迟时间
     * @param timeUnit  时间单位
     * @param queueCode 队列键
     * @param <T>
     */
    public <T> boolean addDelayQueue(@NonNull T value, @NonNull long delay, @NonNull TimeUnit timeUnit, @NonNull String queueCode) {
   
   
        if (StringUtils.isBlank(queueCode) || Objects.isNull(value)) {
   
   
            return false;
        }
        try {
   
   
            RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueCode);
            RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
            delayedQueue.offer(value, delay, timeUnit);
            //delayedQueue.destroy();
            log.info("(添加延时队列成功) 队列键：{}，队列值：{}，延迟时间：{}", queueCode, value, timeUnit.toSeconds(delay) + "秒");
        } catch (Exception e) {
   
   
            log.error("(添加延时队列失败) {}", e.getMessage());
            throw new RuntimeException("(添加延时队列失败)");
        }
        return true;
    }

    /**
     * 获取延迟队列
     *
     * @param queueCode
     * @param <T>
     */
    public <T> T getDelayQueue(@NonNull String queueCode) throws InterruptedException {
   
   
        if (StringUtils.isBlank(queueCode)) {
   
   
            return null;
        }
        RBlockingDeque<Map> blockingDeque = redissonClient.getBlockingDeque(queueCode);
        RDelayedQueue<Map> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
        T value = (T) blockingDeque.poll();
        return value;
    }
    /**
     * 删除指定队列中的消息
     *
     * @param o 指定删除的消息对象队列值(同队列需保证唯一性)
     * @param queueCode 指定队列键
     */
    public boolean removeDelayedQueue(@NonNull Object o, @NonNull String queueCode) {
   
   
        if (StringUtils.isBlank(queueCode) || Objects.isNull(o)) {
   
   
            return false;
        }
        RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueCode);
        RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(block