Redis实现消息队列

本文介绍了如何利用Redis实现轻量级的消息队列服务,特别适用于短信服务的场景。通过SpringMVC框架,详细阐述了配置Redis生产者消费者模式、引入Maven依赖以及代码实现过程,包括消息的发送和监听。

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

基于Redis消息队列-实现短信服务化

1.Redis实现消息队列原理

常用的消息队列有RabbitMQ,ActiveMQ,个人觉得这种消息队列太大太重,本文介绍下基于Redis的轻量级消息队列服务。
一般来说,消息队列有两种模式,一种是发布者订阅模式,另外一种是生产者和消费者模式。Redis的消息队列,也是基于这2种原理的实现。
发布者和订阅者模式:发布者发送消息到队列,每个订阅者都能收到一样的消息。
生产者和消费者模式:生产者将消息放入队列,多个消费者共同监听,谁先抢到资源,谁就从队列中取走消息去处理。注意,每个消息只能最多被一个消费者接收。

2.Redis消息队列使用场景

在我们的项目中,使用消息队列来实现短信的服务化,任何需要发送短信的模块,都可以直接调用短信服务来完成短信的发送。比如用户系统登录注册短信,订单系统的下单成功的短信等。

3.SpringMVC中实现Redis消息队列

因为我们短信只需要发送一次,所以我们使用的是消息队列的生产者和消费者模式。

3.1引入Maven依赖

引入Redis相应的maven依赖,这里需要spring-data-redis和jedis

    //pom.xml
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.6.0.RELEASE</version>
    </dependency>

      <!-- jedis -->
      <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
             <version>2.5.1</version>
        </dependency>
3.2配置redis生成者消费者模式
    //applicationContext-redis.xml
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:redis="http://www.springframework.org/schema/redis"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-34.0.xsd     
                            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
                            http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/cache http:/
<think>我们被要求使用Redis实现消息队列。根据引用[1]和引用[2],Redis提供了三种方式:基于List结构、PubSub(发布订阅)和Stream结构。其中,引用[1]和引用[2]都提到,基于Stream的方式是比较完善的消息队列模型,推荐使用。 下面分别介绍这三种方式: ### 1. 基于List结构 Redis的List是一个双向链表,我们可以利用其`LPUSH`(或`RPUSH`)和`BRPOP`(或`BLPOP`)命令实现消息队列。 - 生产者使用`LPUSH`将消息放入队列的左侧(头部)。 - 消费者使用`BRPOP`从队列的右侧(尾部)阻塞地取出消息。 **优点**: - 实现简单,利用Redis已有的数据结构。 - 支持阻塞等待(使用`BRPOP`),避免消费者轮询。 **缺点**: - 不支持多消费者(一个消息只能被一个消费者消费)。 - 没有消息确认机制,如果消费者处理失败,消息就丢失了。 - 没有消息回溯功能。 #### 示例代码(生产者): ```java Jedis jedis = new Jedis("localhost"); // 向队列list1中放入消息 jedis.lpush("list1", "message1"); ``` #### 示例代码(消费者): ```java Jedis jedis = new Jedis("localhost"); // 阻塞地从队列list1中取出消息,0表示无限等待 List<String> result = jedis.brpop(0, "list1"); String message = result.get(1); ``` ### 2. 基于PubSub(发布订阅) Redis的发布订阅模式允许消息被多个消费者接收(广播)。 - 生产者发布消息到指定频道(channel)。 - 消费者订阅频道,接收消息。 **优点**: - 支持一对多的消息发布。 - 实时性较好。 **缺点**: - 消息是即时的,没有持久化。如果消费者不在线,消息就丢失了。 - 不支持消息的存储,因此无法回溯历史消息。 - 没有消息确认机制。 #### 示例代码(生产者): ```java Jedis jedis = new Jedis("localhost"); // 向频道channel1发布消息 jedis.publish("channel1", "message1"); ``` #### 示例代码(消费者): ```java Jedis jedis = new Jedis("localhost"); // 创建订阅对象 jedis.subscribe(new JedisPubSub() { @Override public void onMessage(String channel, String message) { // 处理消息 System.out.println("Received: " + message); } }, "channel1"); ``` ### 3. 基于Stream(推荐) Redis 5.0引入了Stream数据结构,它提供了更完善的消息队列功能: - 支持消息持久化。 - 支持消费者组(Consumer Group):多个消费者可以组成一个组,共同消费一个队列,每条消息只会被组内的一个消费者消费。 - 提供消息确认机制(ACK),确保消息被成功处理。 - 支持消息回溯。 #### 基本命令: - `XADD`:添加消息到流。 - `XREAD`:读取消息(可以阻塞)。 - `XGROUP`:创建消费者组。 - `XREADGROUP`:通过消费者组读取消息。 - `XACK`:确认消息已被处理。 #### 示例代码(生产者): ```java Jedis jedis = new Jedis("localhost"); // 向名为stream1的流中添加消息,消息包含字段key1和value1 jedis.xadd("stream1", StreamEntryID.NEW_ENTRY, Collections.singletonMap("key1", "value1")); ``` #### 示例代码(消费者组): 首先,创建消费者组: ```bash # 在Redis命令行中创建消费者组 XGROUP CREATE stream1 mygroup 0 ``` 然后,在Java使用消费者组消费: ```java Jedis jedis = new Jedis("localhost"); // 消费者组mygroup中的消费者consumer1读取消息 Map.Entry<String, StreamEntryID> streamQuery = new AbstractMap.SimpleEntry<>("stream1", StreamEntryID.UNRECEIVED_ENTRY); List<Map.Entry<String, List<StreamEntry>>> result = jedis.xreadGroup("mygroup", "consumer1", 1, 0, // 读取1条消息,0表示阻塞直到有消息 streamQuery); // 处理消息 for (StreamEntry entry : result.get(0).getValue()) { System.out.println("Received: " + entry.getFields()); // 确认消息 jedis.xack("stream1", "mygroup", entry.getID()); } ``` ### 总结 - **List结构**:适用于简单的消息队列,单消费者,无持久化要求。 - **PubSub**:适用于广播消息,实时性要求高,但消息可丢失的场景。 - **Stream**:适用于需要持久化、多消费者组、消息确认等高级功能的场景,是最接近专业消息队列实现[^1][^2]。 在实际应用中,根据需求选择合适的方式。对于需要可靠消息队列的场景,推荐使用Stream结构。 ### 相关问题 1. Redis Stream 如何实现消息的持久化和重放? 2. 在 Redis 中,如何监控消息队列的运行状态? 3. Redis 作为消息队列与专业的消息队列(如 RabbitMQ)相比有哪些优缺点?</think>### Redis 实现消息队列的三种方式 Redis 提供了三种主要方式实现消息队列,根据引用[1][2][3]的内容整理如下: #### 1. 基于 List 结构(双向链表) ```bash # 生产者 LPUSH myqueue "message1" # 左侧插入消息 LPUSH myqueue "message2" # 消费者 BRPOP myqueue 0 # 阻塞式右侧弹出(0=无限等待) ``` **特点**: - 支持阻塞式弹出(`BRPOP`) - 消息持久化存储 - 简单高效,适合基本队列需求 - **缺点**:不支持多消费者组[^1][^2] #### 2. 基于 PubSub(发布订阅) ```bash # 消费者订阅 SUBSCRIBE channel1 # 生产者发布 PUBLISH channel1 "message" ``` **特点**: - 实时广播消息 - 支持多消费者 - **缺点**:消息不持久化(离线消费者丢失消息)[^1][^2] #### 3. 基于 Stream(推荐方式) ```bash # 生产者添加消息 XADD mystream * key1 "value1" key2 "value2" # 消费者组消费 XGROUP CREATE mystream mygroup 0 XREADGROUP GROUP mygroup consumer1 COUNT 1 STREAMS mystream > ``` **特点**: - 消息持久化存储 - 支持消费者组(同组内竞争消费) - 消息确认机制(ACK) - 支持消息回溯 - 提供阻塞读取能力[^1][^2] ### 完整 Java 实现示例(使用 Jedis + Stream) ```java import redis.clients.jedis.Jedis; import redis.clients.jedis.StreamEntry; import redis.clients.jedis.StreamEntryID; public class RedisStreamQueue { private static final String STREAM_KEY = "orders"; private static final String GROUP_NAME = "order_processor"; public static void main(String[] args) { // 初始化消费者组 initConsumerGroup(); // 启动生产者线程 new Thread(RedisStreamQueue::producer).start(); // 启动消费者线程 new Thread(RedisStreamQueue::consumer).start(); } private static void initConsumerGroup() { try (Jedis jedis = new Jedis("localhost")) { jedis.xgroupCreate(STREAM_KEY, GROUP_NAME, new StreamEntryID(), true); } } private static void producer() { try (Jedis jedis = new Jedis("localhost")) { int count = 1; while (true) { String order = "订单-" + count++; // 添加消息到流 jedis.xadd(STREAM_KEY, null, Map.of("order_id", order, "amount", String.valueOf(count * 10))); System.out.println("生产: " + order); Thread.sleep(1500); } } catch (Exception e) { e.printStackTrace(); } } private static void consumer() { try (Jedis jedis = new Jedis("localhost")) { while (true) { // 从消费者组读取消息 var result = jedis.xreadGroup( GROUP_NAME, "consumer-1", 1, 0, true, Map.of(STREAM_KEY, ">") ); if (!result.isEmpty()) { for (var stream : result) { for (var entry : stream.getValue()) { System.out.println("消费: " + entry.getFields()); // 处理成功后确认消息 jedis.xack(STREAM_KEY, GROUP_NAME, entry.getID()); } } } Thread.sleep(1000); } } catch (Exception e) { e.printStackTrace(); } } } ``` ### 三种方式对比 | **特性** | **List** | **PubSub** | **Stream** | |------------------|----------|------------|------------| | 消息持久化 | ✓ | ✗ | ✓ | | 阻塞式消费 | ✓ | ✗ | ✓ | | 多消费者组 | ✗ | ✗ | ✓ | | 消息确认(ACK) | ✗ | ✗ | ✓ | | 消息回溯 | ✗ | ✗ | ✓ | | 广播消息 | ✗ | ✓ | ✗ | | 适用场景 | 简单队列 | 实时通知 | 企业级队列 | ### 使用建议 1. **基本需求**:使用 List 结构(`LPUSH`+`BRPOP`) 2. **实时通知**:使用 PubSub(广播场景) 3. **企业级应用**:推荐使用 Stream 结构(支持消费者组和ACK)[^1][^2] Redis Stream 是目前最接近专业消息队列(如 Kafka/RabbitMQ)的实现方式,适合需要消息持久化、消费确认和多消费者组的场景[^3]。 ### 相关问题 1. Redis Stream 如何实现消息的持久化和重放? 2. 在 Redis 中,如何监控消息队列的运行状态? 3. Redis 作为消息队列与专业的消息队列(如 RabbitMQ)相比有哪些优缺点?
评论 17
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值