# Redis 在 IM 系统种的 5 种应用场景：从缓存到去重
在 IM 系统中，Redis 用于缓存、存储和去重。本文介绍 AQChat 项目中 Redis 的五种应用场景。
## 一、用户信息缓存（String 结构，30 分钟过期）
### 应用场景
用户登录后，需要频繁的查询用户信息（用户名、头像等）。如果每次都查数据库，会增加数据库压力。

### 实现方案
使用 Redis String 数据结构缓存用户信息，设置 30 分钟过期时间。

**Key 格式**：`AQChat:userInfo:{userId}`

**数据结构**：
```java
{
  "userId": "user123",
  "userName": "张三",
  "userAvatar": "https://example.com/avatar.jpg",
  "roomId": "room456",
  "joinRoomTime": 1699000000000
}
```
**代码实现**
```java
@Component
public class AQUserHolder implements IUserHolder {
    
    @Resource
    private RedisCacheHelper redisCacheHelper;
    
    // 保存用户信息（30分钟过期）
    @Override
    public void saveUserInfo(UserGlobalInfoDto userGlobalInfoDto) {
        redisCacheHelper.setCacheObject(
            AQRedisKeyPrefix.AQ_USER_INFO_PREFIX + userGlobalInfoDto.getUserId(),
            userGlobalInfoDto,
            AQBusinessConstant.USER_INFO_CACHE_TIME,  // 30分钟
            TimeUnit.SECONDS
        );
    }
    
    // 获取用户信息
    @Override
    public UserGlobalInfoDto getUserInfo(String userId) {
        return redisCacheHelper.getCacheObject(
            AQRedisKeyPrefix.AQ_USER_INFO_PREFIX + userId,
            UserGlobalInfoDto.class
        );
    }
    
    // 用户离线时，延长过期时间（给用户重连时间）
    @Override
    public void offline(String userId) {
        redisCacheHelper.expire(
            AQRedisKeyPrefix.AQ_USER_INFO_PREFIX + userId,
            AQBusinessConstant.USER_OFFLINE_CACHE_TIME,  // 更长的过期时间
            TimeUnit.SECONDS
        );
    }
}
```

### 技术要点
1.过期时间：30 分钟，平均缓存命中率和数据一致性

2.离线处理：用户离线时延长过期时间，便于重连回复

3.自动过期：Redis 自动清理过期数据，无需手动清理

### 性能提升
* 数据库查询：20-30 ms
* Redis 查询：< 1ms
* 提升：20-30 倍

## 二、房间信息存储（Hash 结构，info + member）
### 应用场景
房间信息包含多个属性：房间基本信息（房间ID、房间名、房间类型）和成员列表。如果每个属性都用独立的 Key，会产生大量 Key。

### 实现方案
使用 Redis Hash 结构，每一个房间一个 Key，每一个 Field 存储不同属性。

**Key 格式**：`AQChat:room:roomData:{roomId}`

**Hash 结构**：
```
Key: AQChat:room:roomData:room123
Field: info -> RoomInfoDto (JSON)
Field: member -> Map<userId, UserGlobalInfoDto> (JSON)
Field: conversation -> List<MessageRecord> (JSON)
Field: aiSpaceStatus -> int
```

**代码实现**
```java
@Component
public class AQRoomHolder implements IRoomHolder {
    
    @Resource
    private RedisCacheHelper redisCacheHelper;
    
    // 保存房间信息
    @Override
    public void saveRoomInfo(String roomId, RoomInfoDto roomInfoDto) {
        redisCacheHelper.setCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_INFO_PREFIX,  // Field: "info"
            roomInfoDto
        );
    }
    
    // 保存房间成员
    @Override
    public void saveRoomMember(String roomId, String userId) {
        // 获取现有的成员列表
        Map<String, UserGlobalInfoDto> roomMembers = redisCacheHelper.getCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MEMBER_PREFIX  // Field: "member"
        );
        
        // 获取用户信息
        UserGlobalInfoDto userInfo = redisCacheHelper.getCacheObject(
            AQRedisKeyPrefix.AQ_USER_INFO_PREFIX + userId,
            UserGlobalInfoDto.class
        );
        
        if (roomMembers == null) {
            roomMembers = new HashMap<>();
        }
        roomMembers.put(userId, userInfo);
        
        // 更新 Hash 中的 member 字段
        redisCacheHelper.setCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MEMBER_PREFIX,
            roomMembers
        );
    }
    
    // 获取房间成员列表
    @Override
    public List<UserGlobalInfoDto> getRoomMembers(String roomId) {
        Map<String, UserGlobalInfoDto> roomMembers = redisCacheHelper.getCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MEMBER_PREFIX
        );
        
        if (roomMembers == null) {
            return null;
        }
        
        return new ArrayList<>(roomMembers.values());
    }
}
```

### 技术要点
1.减少 Key 数量：一个房间一个 Key，多个 Field 存储不同属性

2.部分更新：可以单独更新某个 Field，不需要整体替换

3.内存优化：Hash 结构比存多个 Key 更省内存

### 优势对比
#### 方案一：多个 String Key（不推荐）
```
AQChat:room:info:room123 -> RoomInfoDto
AQChat:room:member:room123 -> Map
AQChat:room:conversation:room123 -> List
```
#### 方案二：Hahs 结构（推荐）
```
AQChat:room:roomData:room123 -> Hash
  - info -> RoomInfoDto
  - member -> Map
  - conversation -> List
```
优势：Key 数量少，管理简单，节省内存，支持部分更新

## 三、消息去重（List 结构，contains 检查）
### 应用场景
网络重传或者客户端重试可能导致同一条消息被处理多次，需要去重，保证幂等性。

### 实现方案
使用 Redis List 结构存储房间内已发送的消息 ID，发送前检查是否已经存在。

**Key 格式**：`AQChat:room:roomData:{roomId}`（Hash 的 message 字段）

**数据结构**
```
Key: AQChat:room:roomData:room123
Field: message -> List<String> (消息ID列表)
```

**代码实现**
```java
@Component
public class AQMessageHolder implements IMessageHolder {
    
    @Resource
    private RedisCacheHelper redisCacheHelper;
    
    // 添加消息ID
    @Override
    public void putMessageId(String roomId, String msgId) {
        List<String> messageIds = redisCacheHelper.getCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MESSAGE_PREFIX  // Field: "message"
        );
        
        if (messageIds == null) {
            messageIds = new ArrayList<>();
        }
        messageIds.add(msgId);
        
        redisCacheHelper.setCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MESSAGE_PREFIX,
            messageIds
        );
    }
    
    // 检查消息ID是否存在
    @Override
    public boolean isExistMessageId(String roomId, String msgId) {
        List<String> messageIds = redisCacheHelper.getCacheMapValue(
            AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId,
            AQRedisKeyPrefix.AQ_ROOM_MESSAGE_PREFIX
        );
        
        if (messageIds == null) {
            return false;
        }
        
        return messageIds.contains(msgId);  // O(n) 时间复杂度
    }
}
```

**使用场景**
```java
// 在 SendMsgCmdHandler 中
@Override
public void handle(ChannelHandlerContext ctx, AQChatMsgProtocol.SendMsgCmd cmd) {
    String msgId = cmd.getMsgId();
    String roomId = cmd.getRoomId();
    
    // 检查消息是否已发送（去重）
    if (messageHolder.isExistMessageId(roomId, msgId)) {
        LOGGER.info("当前消息已发送: msgId = {}", msgId);
        // 返回成功，避免重复处理
        return;
    }
    
    // 处理消息...
    
    // 标记消息已发送
    messageHolder.putMessageId(roomId, msgId);
}
```

### 技术要点
1.幂等性：保证同一条消息只处理一次

2.性能：List.contains() 是 O(n)，但消息ID数量通常不大（几百到几千），性能可接受

3.优化建议：如果消息ID数量很大（> 10000），建议改用 Redis Set 结构，使用 SISMEMBER 命令，O(1)时间复杂度

### 优化方案（如果消息量很大）
```java
// 使用 Set 结构（优化版）
public boolean isExistMessageId(String roomId, String msgId) {
    // Redis 命令：SISMEMBER AQChat:room:message:room123 msgId
    // 时间复杂度：O(1)
    return redisTemplate.opsForSet().isMember(
        AQRedisKeyPrefix.AQ_ROOM_MESSAGE_PREFIX + roomId,
        msgId
    );
}
```

## 四、OSS 凭证缓存（临时凭证管理）
### 应用场景
文件上传需要阿里云 OSS 临时凭证（STS）。每次请求都调用 STS API 会产生延迟和成本。

### 实现方案
使用 Redis String 结构缓存 STS 凭证，设置 1 小时过期时间（阿里云 STS 凭证有效期通常也是 1 小时）。

**Key 格式**：`AQChat:alioOssSts`

**数据结构**
```
{
  "accessKeyId": "STS.xxx",
  "accessKeySecret": "xxx",
  "securityToken": "xxx",
  "bucket": "aqchat",
  "region": "cn-hangzhou",
  "ossEndpoint": "oss-cn-shenzhen.aliyuncs.com"
}
```

**代码实现**
```java
@Component
public class AliOssProvider {
    
    @Resource
    private RedisCacheHelper redisCacheHelper;
    
    // 获取 STS 凭证（带缓存）
    public AliOssStsDto getAliOssSts() {
        // 1. 先尝试从缓存获取
        AliOssStsDto aliOssStsDto = getCacheAliOssSts();
        if (aliOssStsDto != null) {
            return aliOssStsDto;  // 缓存命中，直接返回
        }
        
        // 2. 缓存未命中，调用 STS API
        try {
            DefaultAcsClient client = new DefaultAcsClient(profile);
            AssumeRoleRequest request = new AssumeRoleRequest();
            request.setRoleArn(roleArn);
            request.setDurationSeconds(3600);  // 1小时有效期
            
            AssumeRoleResponse response = client.getAcsResponse(request);
            
            aliOssStsDto = new AliOssStsDto();
            aliOssStsDto.setAccessKeyId(response.getCredentials().getAccessKeyId());
            aliOssStsDto.setAccessKeySecret(response.getCredentials().getAccessKeySecret());
            aliOssStsDto.setSecurityToken(response.getCredentials().getSecurityToken());
            
            // 3. 缓存凭证
            cacheAliOssSts(aliOssStsDto);
            
            return aliOssStsDto;
        } catch (ClientException e) {
            LOGGER.error("获取 STS 凭证失败", e);
            return null;
        }
    }
    
    // 缓存 STS 凭证（1小时过期）
    private void cacheAliOssSts(AliOssStsDto aliOssStsDto) {
        if (aliOssStsDto != null) {
            redisCacheHelper.setCacheObject(
                AQRedisKeyPrefix.ALI_OSS_STS,
                aliOssStsDto,
                AQBusinessConstant.ALI_OSS_STS_CACHE_TIME,  // 1小时
                TimeUnit.SECONDS
            );
        }
    }
    
    // 获取缓存的 STS 凭证
    private AliOssStsDto getCacheAliOssSts() {
        return redisCacheHelper.getCacheObject(
            AQRedisKeyPrefix.ALI_OSS_STS,
            AliOssStsDto.class
        );
    }
}
```

### 技术要点
1.缓存时间：1 小时，与 STS 凭证有效期一致

2.全局共享：所有用户共享一个 STS 凭证（Key 不包含 userId）

3.自动过期：Redis 自动清理过期凭证，无需手动删除

### 性能提升
* STS API 调用：100-200ms
* Redis 查询：< 1ms
* 提升：100-200 倍

### 成本优化
假设每天 10000 次文件上传请求：
* 不适用缓存：10000 次 STS API 调用
* 使用缓存（假设 50% 命中率）：5000 次 STS API 调用
* 节省：50% 的 API 调用成本

## 五、房间号映射（roomNo -> roomId）
### 应用场景
用户是通过房间号（如 12345）加入房间，但系统内部使用房间ID（如"room_abc123"）。需要建立房间号到房间ID的映射。

### 实现方案
使用 Redis String 结构存储房间号到房间ID的映射，永久存储（不过期）。

**Key 格式**：`AQChat:room:roomNo:{roomNo}`

**Value**：房间Id（String）

**代码实现**
```java
@Component
public class AQRoomHolder implements IRoomHolder {
    
    @Resource
    private RedisCacheHelper redisCacheHelper;
    
    // 保存房间号和房间ID的映射
    @Override
    public void saveNoAndId(Integer roomNo, String roomId) {
        redisCacheHelper.setCacheObject(
            AQRedisKeyPrefix.AQ_ROOM_NO_PREFIX + roomNo,
            roomId
            // 不设置过期时间，永久存储
        );
    }
    
    // 根据房间号获取房间ID
    @Override
    public String getRoomId(Integer roomNo) {
        return redisCacheHelper.getCacheObject(
            AQRedisKeyPrefix.AQ_ROOM_NO_PREFIX + roomNo,
            String.class
        );
    }
    
    // 根据房间号获取房间信息
    @Override
    public RoomInfoDto getRoomInfoByNo(Integer roomNo) {
        // 1. 先根据房间号获取房间ID
        String roomId = getRoomId(roomNo);
        if (roomId == null) {
            return null;
        }
        
        // 2. 根据房间ID获取房间信息
        return getRoomInfoById(roomId);
    }
    
    // 删除房间时，同时删除映射
    @Override
    public void removeRoomInfo(Integer roomNo) {
        String roomId = getRoomId(roomNo);
        // 删除房间信息
        redisCacheHelper.deleteObject(AQRedisKeyPrefix.AQ_ROOM_PREFIX + roomId);
        // 删除房间号映射
        redisCacheHelper.deleteObject(AQRedisKeyPrefix.AQ_ROOM_NO_PREFIX + roomNo);
    }
}
```

**使用场景**
```java
// 用户加入房间
@Override
public void handle(ChannelHandlerContext ctx, AQChatMsgProtocol.JoinRoomCmd cmd) {
    int roomNo = cmd.getRoomNo();  // 用户输入的房间号：12345
    
    // 根据房间号获取房间ID
    String roomId = roomHolder.getRoomId(roomNo);
    if (roomId == null) {
        // 房间不存在
        return;
    }
    
    // 使用房间ID进行后续操作
    globalChannelHolder.joinRoom(roomId, userId, ctx.channel());
}
```

### 技术要点
1.永久存储：房间号映射不过期，知道房间被删除

2.快速查询：O(1) 时间复杂度，比数据库查询快

3.数据一致性：房间删除时，同时删除映射关系

### 性能提升
* 数据库查询：10-20ms
* Redis 查询：< 1ms
* 提升：10-20 倍

## 六、Redis Key 设计规范
### Key 命名规范
```
系统名:模块:业务:标识
```
**示例**：
* `AQChat:userInfo:user123` - 用户信息
* `AQChat:room:roomData:room123` - 房间数据（Hash）
* `AQChat:room:roomNo:12345` - 房间号映射
* `AQChat:aliOssSts` - Oss 凭证

### 过期时间策略
| 数据类型 | 过期时间 | 原因 |
|--------|--------|------|
| 用户信息 | 30 分钟 | 平衡缓存命中率和数据一致性 |
| OSS 凭证 | 1 小时 | 与 STS 凭证有效期一致 |
| 房间信息 | 永久 | 房间数据需要持久化 |
| 房间号映射 | 永久 | 映射关系需要持久化 | 
| 消息去重 | 永久 | 需要长期去重 |

## 七、总结
Redis 在 IM 系统中的 5 种应用场景：
1.用户信息缓存：String 结构，30 分钟过期，提升查询性能 20-30 倍
2.房间信息存储：Hash 结构，减少 Key 数量，支持部分更新
3.消息去重：List 结构（可优化为 Set），保证消息幂等性
4.OSS 凭证缓存：String 结构，1 小时过期，减少 API 调用成本
5.房间号映射：String 结构，永久存储，快速查询房间ID

### 性能提升总结
| 场景 | 数据库查询 | Redis 查询 | 性能提升 |
|------|--------|--------|--------|
| 用户信息 | 20-30ms | < 1ms | 20-30 倍 |
| 房间信息 | 10-20ms | < 1ms | 10-20 倍 |
| 房间号映射 | 10-20ms | < 1ms | 10-20 倍 |
| OSS 凭证 | 100-200ms | < 1ms | 100-200 倍 |

通过合理使用 Redis，IM 系统在保证功能完整性的同时，大幅提升了性能和用户体验。

在 IM 系统中，Redis 用于缓存、存储和去重。本文介绍 AQChat 项目中 Redis 的五种应用场景。

Redis 在 IM 系统中的 5 种应用场景：从缓存到去重

数据库

网络与通信

后端

Redis在IM系统中5大应用场景：用户信息缓存提升20-30倍性能，Hash结构存储房间信息减少Key数量，List/Set实现消息去重保证幂等性，OSS凭证缓存降低API成本，房间号映射实现快速查询。合理使用Redis显著提升IM系统性能。

数据一致性

数据结构

Redis

JSON

云数据库采购特惠，高性能、高可靠、高安全，超值优惠等你享！


腾讯云 IM，全球通信，1折起


AI驱动 智领未来

tencentdb-catalog

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Redis 在 IM 系统中的 5 种应用场景：从缓存到去重-腾讯云开发者社区-腾讯云

Redis 在 IM 系统中的 5 种应用场景：从缓存到去重

Redis 在 IM 系统中的 5 种应用场景：从缓存到去重

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐