Spring Boot + Redis 实现延迟队列

Spring Boot + Redis 实现延迟队列

在许多实际应用场景中，我们经常需要在特定时间后执行某些任务，例如订单超时未支付自动取消、延时消息发送等。延迟队列是一种非常实用的解决方案。本文将详细介绍如何使用 Spring Boot 和 Redis 实现延迟队列，包括其原理、具体实现步骤和代码示例。

延迟队列的原理

延迟队列是一种特殊的队列，其元素在加入队列时会附带一个延迟时间，只有在延迟时间到达之后，元素才会被处理。我们可以利用 Redis 的有序集合（Sorted Set）来实现延迟队列，因为 Redis 的有序集合支持为每个元素设置一个分数（score），并按照分数进行排序。我们将延迟任务的执行时间作为分数，当时间到达时，取出相应的元素进行处理。

实现步骤

1. 将任务加入延迟队列：将任务及其执行时间戳作为元素和分数，存入 Redis 的有序集合。
2. 轮询检查任务：定期检查有序集合中是否有到期的任务。
3. 处理到期任务：取出到期任务并执行相应操作。

环境准备

首先，确保你已经安装并配置好了 Redis 服务器，并在你的 Spring Boot 项目中添加了 Redis 依赖。你可以在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

代码实现

1. 配置 Redis

在 application.properties 文件中添加 Redis 配置：

spring.redis.host=localhost
spring.redis.port=6379

2. 创建任务模型

创建一个简单的任务模型 DelayedTask：

public class DelayedTask {
    private String id;
    private String message;

    // Constructors, getters, and setters
}

3. 创建 Redis 配置类

创建一个配置类 RedisConfig 用于配置 RedisTemplate：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

4. 创建延迟队列服务类

创建 DelayedQueueService 来处理任务的添加和执行：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.Set;

@Service
public class DelayedQueueService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String DELAYED_QUEUE = "delayed_queue";

    public void addTask(DelayedTask task, long delay) {
        long executeTime = System.currentTimeMillis() + delay;
        redisTemplate.opsForZSet().add(DELAYED_QUEUE, task, executeTime);
        System.out.println("Task added: " + task.getId() + " will execute in " + delay + "ms");
    }

    @Scheduled(fixedRate = 1000)
    public void processTasks() {
        long currentTime = System.currentTimeMillis();
        Set<ZSetOperations.TypedTuple<Object>> tasks = redisTemplate.opsForZSet().rangeByScoreWithScores(DELAYED_QUEUE, 0, currentTime);
        if (tasks != null && !tasks.isEmpty()) {
            for (ZSetOperations.TypedTuple<Object> task : tasks) {
                System.out.println("Processing task: " + ((DelayedTask) task.getValue()).getId());
                redisTemplate.opsForZSet().remove(DELAYED_QUEUE, task.getValue());
                // Here you can add your task processing logic
            }
        }
    }
}

5. 创建任务控制器

创建一个简单的控制器 TaskController 来测试我们的延迟队列：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TaskController {

    @Autowired
    private DelayedQueueService delayedQueueService;

    @PostMapping("/addTask")
    public String addTask(@RequestBody DelayedTask task, @RequestParam long delay) {
        delayedQueueService.addTask(task, delay);
        return "Task added";
    }
}

6. 启动 Spring Boot 应用

确保你的主应用程序类上有 @EnableScheduling 注解，以启用定时任务：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class DelayedQueueApplication {

    public static void main(String[] args) {
        SpringApplication.run(DelayedQueueApplication.class, args);
    }
}

测试

启动你的 Spring Boot 应用，并通过 HTTP 请求添加任务：

curl -X POST -H "Content-Type: application/json" -d '{"id":"task1","message":"This is a test task"}' "http://localhost:8080/addTask?delay=5000"

这将向延迟队列中添加一个任务，延迟 5000 毫秒（5 秒）后执行。在 5 秒后，你应该会在控制台看到任务被处理的日志输出。

总结

通过本文的介绍，我们了解了如何使用 Spring Boot 和 Redis 实现一个简单的延迟队列。延迟队列能够有效地处理需要在特定时间点或延迟一段时间后执行的任务。在实际应用中，可以根据需求进一步扩展和优化该方案，例如增加任务重试机制、错误处理等。

希望这篇文章对你有所帮助！如果有任何问题或需要进一步的说明，请随时告诉我。