Redis消息队列-基于List实现消息队列

一、前言：为什么用 Redis List 做消息队列？

在很多中小型项目中，引入 RabbitMQ 或 Kafka 显得"杀鸡用牛刀"------运维复杂、学习成本高。

而 Redis 的 List 数据结构 ，凭借其简单、高效、持久化 的特性，成为实现轻量级消息队列的理想选择。

本文将手把手教你：

如何用 LPUSH + BRPOP 构建可靠队列
如何在 Spring Boot 中集成
如何处理消费失败、幂等性等实际问题

二、核心原理：生产者-消费者模型

Redis List 实现消息队列的核心命令：

角色	命令	说明
生产者	`LPUSH queue message`	从左侧入队
消费者	`BRPOP queue timeout`	从右侧阻塞出队

✅ 优势：

FIFO（先进先出）

消息持久化（Redis 持久化开启后，重启不丢）

支持多消费者竞争消费

示例（Redis CLI）：

bash 复制代码

# 生产者：发送任务
> LPUSH task_queue "send_email:user_1001"
(integer) 1

# 消费者：阻塞等待任务（0 表示永久等待）
> BRPOP task_queue 0
1) "task_queue"
2) "send_email:user_1001"

三、Spring Boot 完整实现

步骤 1：添加依赖（已集成 Redis）

XML 复制代码

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

步骤 2：定义任务模型（建议 JSON 序列化）

java 复制代码

public class AsyncTask {
    private String taskId;
    private String type;      // 如 "SEND_EMAIL", "CREATE_COUPON"
    private Map<String, Object> data;
    private long createTime = System.currentTimeMillis();

    // getters/setters
}

步骤 3：封装 Redis List 队列工具类

java 复制代码

@Component
public class RedisQueueUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 生产消息（入队）
     */
    public void push(String queueName, Object message) {
        redisTemplate.opsForList().leftPush(queueName, message);
    }

    /**
     * 消费消息（阻塞出队，超时返回 null）
     */
    public Object pop(String queueName, long timeoutSeconds) {
        return redisTemplate.opsForList().rightPop(queueName, Duration.ofSeconds(timeoutSeconds));
    }
}

💡 注意：确保 RedisTemplate 的 valueSerializer 使用 Jackson2JsonRedisSerializer，以便自动序列化对象。

步骤 4：启动后台消费者线程

java 复制代码

@Component
public class TaskConsumer {

    @Autowired
    private RedisQueueUtil redisQueueUtil;

    @PostConstruct
    public void startConsumer() {
        Thread consumer = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 阻塞等待任务（最多等 30 秒，避免死循环）
                    Object msg = redisQueueUtil.pop("async_task_queue", 30);
                    if (msg != null) {
                        handleTask((AsyncTask) msg);
                    }
                } catch (Exception e) {
                    log.error("消费任务异常", e);
                    // 可选：短暂休眠防止 CPU 飙升
                    try { Thread.sleep(1000); } catch (InterruptedException ie) { break; }
                }
            }
        });
        consumer.setDaemon(true);
        consumer.setName("redis-task-consumer");
        consumer.start();
    }

    private void handleTask(AsyncTask task) {
        try {
            switch (task.getType()) {
                case "SEND_EMAIL":
                    emailService.send((String) task.getData().get("to"));
                    break;
                case "CREATE_COUPON":
                    couponService.createCoupon((Long) task.getData().get("userId"));
                    break;
                default:
                    log.warn("未知任务类型: {}", task.getType());
            }
        } catch (Exception e) {
            log.error("处理任务失败, taskId={}", task.getTaskId(), e);
            // TODO: 可扩展失败重试、死信队列等
        }
    }
}

步骤 5：业务中发送任务（生产者）

java 复制代码

@Service
public class UserService {

    @Autowired
    private RedisQueueUtil redisQueueUtil;

    public void registerUser(String email) {
        // 1. 保存用户
        User user = saveUser(email);

        // 2. 发送异步任务（不阻塞主流程）
        AsyncTask task = new AsyncTask();
        task.setTaskId(UUID.randomUUID().toString());
        task.setType("SEND_EMAIL");
        task.setData(Map.of("to", email, "userId", user.getId()));

        redisQueueUtil.push("async_task_queue", task);

        // 3. 立即返回
        log.info("用户注册成功，邮件任务已提交");
    }
}

✅ 效果：注册接口响应时间从 800ms 降至 50ms！

四、关键问题与解决方案

1️⃣ 消费失败怎么办？消息会丢失吗？

问题：BRPOP 一旦取出，消息就从队列删除。若处理失败，无法重试。
解决方案 ：
- 方案 A（简单） ：捕获异常后，重新 LPUSH 回队列（需防无限重试）
- 方案 B（推荐）：引入"处理中"状态，用 Lua 脚本实现可靠队列（见下文）

2️⃣ 如何实现 ACK 机制？（进阶）

虽然 List 本身不支持 ACK，但可通过 "预取 + 确认"双队列模拟：

Lua 复制代码

-- safe_pop.lua
local queue = KEYS[1]
local processing = KEYS[2]
local timeout = tonumber(ARGV[1])

-- 1. 从主队列取任务
local task = redis.call('RPOP', queue)
if not task then return nil end

-- 2. 放入"处理中"队列，并设置过期时间（防卡死）
redis.call('ZADD', processing, timeout, task)

return task

消费成功后，从 processing 队列删除；超时未确认的任务可被扫描重入主队列。

⚠️ 此方案较复杂，一般场景直接重试即可。

3️⃣ 如何保证幂等性？

每个任务携带唯一 taskId
消费前检查是否已处理（如查 DB 记录）
避免重复发券、重复发邮件

五、优缺点总结

✅ 优点：

零外部依赖：仅需 Redis
开发简单：几行代码搞定
性能高：内存操作，QPS > 1万
消息持久：开启 RDB/AOF 后不丢

❌ 缺点：

无原生 ACK：失败需手动处理
无消费者组：多实例需每台独立消费
无消息回溯：不能查看历史消息

📌 适用场景：

异步发邮件/短信

优惠券发放

日志收集

秒杀异步落库

六、结语

感谢您的阅读！如果你有任何疑问或想要分享的经验，请在评论区留言交流！