<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.16.6</version>
</dependency>
import com.alibaba.fastjson.JSON;
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 javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Component
public class RedisDelayedQueueInit implements ApplicationContextAware {
private static Logger logger = LoggerFactory.getLogger(RedisDelayedQueueInit.class);
@Autowired
RedissonClient redissonClient;
@Resource
private RedisDelayedQueue redisDelayedQueue;
@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());
}
}
private <T> void startThread(String queueName, RedisDelayedQueueListener redisDelayedQueueListener) {
RBlockingQueue<T> blockingFairQueue = redissonClient.getBlockingQueue(queueName);
Thread thread = new Thread(() -> {
logger.info("启动监听队列线程" + queueName);
redisDelayedQueue.addQueue(null, 3, TimeUnit.SECONDS, queueName);
while (true) {
try {
T t = blockingFairQueue.take();
logger.info("监听队列线程{},获取到值:{}", queueName, JSON.toJSONString(t));
new Thread(() -> {
redisDelayedQueueListener.invoke(t);
}).start();
} catch (Exception e) {
logger.info("监听队列线程错误,", e);
try {
Thread.sleep(10000);
} catch (InterruptedException ex) {
}
}
}
});
thread.setName(queueName);
thread.start();
}
}
public interface RedisDelayedQueueListener<T> {
void invoke(T t);
}
@Component
public class TimeOverListener implements RedisDelayedQueueListener<String> {
@Override
public void invoke(String str) {
if (StringUtils.isNotBlank(str)) {
}
}
}
@Resource
private RedisDelayedQueue redisDelayedQueue;
Date startTime = new Date();
Date endTime = new Date();
long difference = endTime.getTime() - startTime.getTime();
long seconds = difference / 1000;
redisDelayedQueue.addQueue(id, seconds, TimeUnit.SECONDS, TimeOverListener .class.getName());