/**
 * 隊(duì)列事件監(jiān)聽(tīng)接口，需要實(shí)現(xiàn)這個(gè)方法
 *
 * @module
 * @author frank
 * @date 2021/8/19 10:50
 */
public interface RedisDelayedQueueListener<T> {
    /**
     * 執(zhí)行方法
     *
     * @param t
     */
    void invoke(T t);
}

import com.sxmaps.netschool.common.redisson.RedisDelayedQueueListener;
import com.sxmaps.netschool.service.vo.school.SchoolAccountPayStateReqVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 支付二維碼監(jiān)聽(tīng)器
 *
 * @module
 * @author frank
 * @date 2021/8/19 10:49
 */
@Component
public class PayQCordListener implements RedisDelayedQueueListener<SchoolAccountPayStateReqVO> {

    private final Logger logger = LoggerFactory.getLogger(PayQCordListener.class);
    @Autowired
    private SchoolAccountService schoolAccountService;

    @Override
    public void invoke(SchoolAccountPayStateReqVO payStateReqVO) {
        logger.info("支付二維碼-延遲失效,內(nèi)容:{}", payStateReqVO);
         //處理業(yè)務(wù)，更新二維碼狀態(tài)
        logger.info("支付二維碼-延遲失效,內(nèi)容:{},處理結(jié)果:{}", payStateReqVO,respDTO);
    }
}

import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 增加延遲信息
 *
 * @author frank
 * @module
 * @date 2021/8/19 10:49
 */
@Component
public class RedisDelayedQueue {

    private final Logger logger = LoggerFactory.getLogger(RedisDelayedQueue.class);

    @Autowired
    RedissonClient redissonClient;

    /**
     * 添加隊(duì)列
     *
     * @param t        DTO傳輸類(lèi)
     * @param delay    時(shí)間數(shù)量
     * @param timeUnit 時(shí)間單位
     * @param <T>      泛型
     */
    private <T> void addQueue(T t, long delay, TimeUnit timeUnit, String queueName) {
        logger.info("添加延遲隊(duì)列,監(jiān)聽(tīng)名稱:{},時(shí)間:{},時(shí)間單位:{},內(nèi)容:{}" , queueName, delay, timeUnit,t);
        RBlockingQueue<T> blockingFairQueue = redissonClient.getBlockingQueue(queueName);
        RDelayedQueue<T> delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
        delayedQueue.offer(t, delay, timeUnit);
    }

    /**
     * 添加隊(duì)列-秒
     *
     * @param t     DTO傳輸類(lèi)
     * @param delay 時(shí)間數(shù)量
     * @param <T>   泛型
     */
    public <T> void addQueueSeconds(T t, long delay, Class<? extends RedisDelayedQueueListener> clazz) {
        addQueue(t, delay, TimeUnit.SECONDS, clazz.getName());
    }

    /**
     * 添加隊(duì)列-分
     *
     * @param t     DTO傳輸類(lèi)
     * @param delay 時(shí)間數(shù)量
     * @param <T>   泛型
     */
    public <T> void addQueueMinutes(T t, long delay, Class<? extends RedisDelayedQueueListener> clazz) {
        addQueue(t, delay, TimeUnit.MINUTES, clazz.getName());
    }

    /**
     * 添加隊(duì)列-時(shí)
     *
     * @param t     DTO傳輸類(lèi)
     * @param delay 時(shí)間數(shù)量
     * @param <T>   泛型
     */
    public <T> void addQueueHours(T t, long delay, Class<? extends RedisDelayedQueueListener> clazz) {
        addQueue(t, delay, TimeUnit.HOURS, clazz.getName());
    }
    /**
     * 添加隊(duì)列-天
     *
     * @param t     DTO傳輸類(lèi)
     * @param delay 時(shí)間數(shù)量
     * @param <T>   泛型
     */
    public <T> void addQueueDays(T t, long delay, Class<? extends RedisDelayedQueueListener> clazz) {
        addQueue(t, delay, TimeUnit.DAYS, clazz.getName());
    }
}

import org.redisson.api.RBlockingQueue;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 初始化隊(duì)列監(jiān)聽(tīng)
 *
 * @module
 * @author frank
 * @date 2021/8/19 10:49
 */
@Component
public class RedisDelayedQueueInit implements ApplicationContextAware {

    private final Logger logger = LoggerFactory.getLogger(RedisDelayedQueueInit.class);
    @Autowired
    RedissonClient redissonClient;

    /**
     * 獲取應(yīng)用上下文并獲取相應(yīng)的接口實(shí)現(xiàn)類(lèi)
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, RedisDelayedQueueListener> map = applicationContext.getBeansOfType(RedisDelayedQueueListener.class);
        for (Map.Entry<String, RedisDelayedQueueListener> taskEventListenerEntry : map.entrySet()) {
            String listenerName = taskEventListenerEntry.getValue().getClass().getName();
            startThread(listenerName, taskEventListenerEntry.getValue());
        }
    }

    /**
     * 啟動(dòng)線程獲取隊(duì)列*
     *
     * @param queueName                 queueName
     * @param redisDelayedQueueListener 任務(wù)回調(diào)監(jiān)聽(tīng)
     * @param <T>                       泛型
     * @return
     */
    private <T> void startThread(String queueName, RedisDelayedQueueListener redisDelayedQueueListener) {
        RBlockingQueue<T> blockingFairQueue = redissonClient.getBlockingQueue(queueName);
        //服務(wù)重啟后，無(wú)offer，take不到信息。
        redissonClient.getDelayedQueue(blockingFairQueue);
        //由于此線程需要常駐，可以新建線程，不用交給線程池管理
        Thread thread = new Thread(() -> {
            logger.info("啟動(dòng)監(jiān)聽(tīng)隊(duì)列線程" + queueName);
            while (true) {
                try {
                    T t = blockingFairQueue.take();
                    logger.info("監(jiān)聽(tīng)隊(duì)列線程，監(jiān)聽(tīng)名稱：{},內(nèi)容:{}", queueName, t);
                    redisDelayedQueueListener.invoke(t);
                } catch (Exception e) {
                    logger.info("監(jiān)聽(tīng)隊(duì)列線程錯(cuò)誤,", e);
                }
            }
        });
        thread.setName(queueName);
        thread.start();
    }

}

@Autowired
RedisDelayedQueue queue;
.................

queue.addQueueHours(new SchoolAccountPayStateReqVO(dto.getPayNo()),2, PayQCordListener.class);