概述
冻结的本质是往 Redis 写一个 USER_FREEZE_ 前缀的 key,那么解冻就只剩一件事,把这个 key 删掉。这里覆盖解冻接口的完整实现(userUnfreeze,天然幂等),以及管理后台用户列表/详情接口的改造:把「冻结中」这个不在数据库里的状态动态回填到响应里。
纲要
- 解冻接口设计
POST /manage/users/unfreeze,请求参数只有userId有用,reasons(解冻原因)在纯 Redis 方案下用不上ManagerService.userUnfreeze:拼 key →redisTemplate.delete(key)→ 返回提示- 为什么天然幂等:
DEL对不存在的 key 返回 0,不报错 - 查询用户数据的改造
UserInfo新增userStatus字段:@TableField(exist = false)非表字段,默认"1"findUserById:查完详情后hasKey判断,命中则置"2"findAllUsers:分页结果逐个回填冻结状态- 「查询后回填」模式的性能代价与 MGET 优化思路
- 架构讨论:非表字段与「Redis 为唯一事实源」
- 如果要持久化:MySQL 加字段 + 双写
- 全链路时序图、坑表、可复现验证
解冻的实现:一次 DELETE 就够了
先看 YAPI 接口文档的约定:请求体传 userId 和 reasons(解冻原因)。因为冻结数据存在 Redis 里,reasons 目前没有任何落库的地方,服务端只用 userId。
mf-admin 工程中 ManagerController 追加解冻方法:
package com.mf.admin.controller;
import com.mf.admin.service.ManagerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
@RequestMapping("/manage")
public class ManagerController {
@Autowired
private ManagerService managerService;
//用户解冻
@PostMapping("/users/unfreeze")
public ResponseEntity unfreeze(@RequestBody Map params) {
Map map = managerService.userUnfreeze(params);
return ResponseEntity.ok(map);
}
}
ManagerService.userUnfreeze 的实现只有三步:取 userId、拼 key、删 key。
package com.mf.admin.service;
import com.mf.commons.utils.Constants;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
@Service
public class ManagerService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
//用户解冻
public Map userUnfreeze(Map params) {
String userId = params.get("userId").toString();
String key = Constants.USER_FREEZE + userId;
//删除redis数据
redisTemplate.delete(key);
Map retMap = new HashMap();
retMap.put("message", "解冻成功");
return retMap;
}
}
其中 Constants.USER_FREEZE 就是冻结篇里用的那个前缀:
public static final String USER_FREEZE = "USER_FREEZE_";
对比冻结(SET 一个带过期时间的 key),解冻只是对称的 DEL。这里有一个值得点名的性质:天然幂等。Redis 的 DEL 对不存在的 key 不抛异常,只是返回「删除了 0 个」;映射到 redisTemplate.delete(key) 就是返回 false,方法照常走到「解冻成功」。所以对一个本来就没被冻结的用户调解冻接口,结果依然是正确的,不需要先 hasKey 判断再删,那种写法反而引入了一次额外的 RTT,还可能在判断和删除之间被并发解冻打穿。
也不存在「解冻残留」问题需要额外清理:key 一删,C 端 UserFreezeService.checkUserStatus 里 opsForValue().get(key) 拿到 null,校验直接放行,登录、评论、发动态全部恢复。
涉及的文件
mf
├── mf-admin # 管理后台服务
│ └── src/main/java/com/mf/admin
│ ├── controller
│ │ └── ManagerController.java # 改:新增 POST /manage/users/unfreeze
│ └── service
│ └── ManagerService.java # 改:新增 userUnfreeze;改造 findAllUsers/findUserById
├── mf-commons
│ └── src/main/java/com/mf/commons/utils
│ └── Constants.java # 已有:USER_FREEZE = "USER_FREEZE_"
└── mf-model
└── src/main/java/com/mf/model/domain
└── UserInfo.java # 改:新增 userStatus 非表字段
| 文件 | 改动 | 说明 |
|---|---|---|
ManagerController.java | 新增 unfreeze 方法 | POST /manage/users/unfreeze |
ManagerService.java | 新增 userUnfreeze | 拼 key + delete,幂等 |
ManagerService.java | 改造 findAllUsers / findUserById | 查询后回填冻结状态 |
UserInfo.java | 新增 userStatus 字段 | @TableField(exist = false),默认 "1" |
Constants.java | 无改动 | 复用 USER_FREEZE_ 前缀 |
查询用户数据的改造:把「冻结中」展示出来
管理后台页面上的用户状态列(正常 / 已冻结)取自响应里的 userStatus 字段。这个字段数据库里没有,冻结状态以 Redis 为唯一事实源,所以它只能是一个动态回填的字段。YAPI 文档约定:userStatus 为 String 类型,"1" 正常、"2" 已冻结。
UserInfo 新增非表字段
UserInfo 是 MyBatis-Plus 的实体类,直接加字段会在 CRUD 时拼出不存在的列名报 SQL 错误。@TableField(exist = false) 声明「此属性不映射数据库列」,让它只活在 Java 对象和 JSON 响应里。给默认值 "1",是为了让没被冻结的用户不用任何处理就是正常状态,代码改动最小:
package com.mf.model.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo implements Serializable {
// ...原有字段省略...
//不映射此属性
@TableField(exist = false)
private String userStatus = "1";
}
根据详情的回填:findUserById
查完数据库详情后,再问一次 Redis:key 存在就说明用户在冻结期,把状态改成 "2"。
package com.mf.admin.service;
import com.mf.commons.utils.Constants;
import com.mf.dubbo.api.UserInfoApi;
import com.mf.model.domain.UserInfo;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class ManagerService {
@DubboReference
private UserInfoApi userInfoApi;
@Autowired
private RedisTemplate<String, String> redisTemplate;
//根据id查询
public UserInfo findUserById(Long userId) {
UserInfo userInfo = userInfoApi.findById(userId);
//查询redis中的冻结状态
String key = Constants.USER_FREEZE + userId;
if (redisTemplate.hasKey(key)) {
userInfo.setUserStatus("2");
}
return userInfo;
}
}
用户列表的回填:findAllUsers
列表接口返回 IPage<UserInfo>,分页查完之后对每一行做同样的判断。这里能直观看到「查询后回填」模式的形态:数据库一次分页查询 + 每行一次 Redis EXISTS。
//用户列表
public PageResult findAllUsers(Integer page, Integer pagesize) {
IPage<UserInfo> iPage = userInfoApi.findAll(page, pagesize);
List<UserInfo> list = iPage.getRecords();
for (UserInfo userInfo : list) {
String key = Constants.USER_FREEZE + userInfo.getId();
if (redisTemplate.hasKey(key)) {
userInfo.setUserStatus("2");
}
}
return new PageResult(page, pagesize, iPage.getTotal(), iPage.getRecords());
}
「查询后回填」的代价
这个模式的逻辑很干净:事实源只有 Redis,查询侧按需读取。代价是每行一次额外的 Redis 往返。pagesize = 10 时一页列表就是 10 次 hasKey,串行执行,列表接口的 Redis 开销随页大小线性增长。
工程里是逐个 hasKey,教学代码可读性优先。生产上更合理的做法是把 N 次 EXISTS 合并成一次批量读,两种思路:
- MGET 一次取值:
redisTemplate.opsForValue().multiGet(keys)拿到 value 列表,非null的即冻结中。顺带还能拿到冻结 JSON(解冻原因、冻结范围),展示信息更全; - Pipeline 聚合 EXISTS:只想判断存在性时,pipeline 把 N 个
EXISTS打包成一个网络往返。
// MGET 批量回填的优化写法(思路示例)
public PageResult findAllUsers(Integer page, Integer pagesize) {
IPage<UserInfo> iPage = userInfoApi.findAll(page, pagesize);
List<UserInfo> list = iPage.getRecords();
List<String> keys = new ArrayList<>();
for (UserInfo userInfo : list) {
keys.add(Constants.USER_FREEZE + userInfo.getId());
}
List<String> values = redisTemplate.opsForValue().multiGet(keys);
for (int i = 0; i < list.size(); i++) {
if (values.get(i) != null) {
list.get(i).setUserStatus("2");
}
}
return new PageResult(page, pagesize, iPage.getTotal(), list);
}
另外注意,findUserById 用的是 hasKey(EXISTS),其实换成 get 一次取回 value 更省,判断存在性和读内容在这里是同一件事。
架构讨论:非表字段与唯一事实源
userStatus 用 @TableField(exist = false) 挡在数据库外面,是整个方案的关键决策:冻结状态以 Redis 为唯一事实源,MySQL 完全不知情。带来的收益和代价都很明确:
| 维度 | Redis 唯一事实源(本方案) | MySQL 持久化 + 双写 |
|---|---|---|
| 写路径 | 冻结 SET、解冻 DEL,一步到位 | 冻结/解冻要更新 MySQL,再同步 Redis |
| 过期恢复 | TTL 到点自动解冻,零代码 | 需要定时任务扫描过期冻结记录或查询时比对时间 |
| 可靠性 | Redis 挂了/数据被清,冻结全部丢失,用户瞬间「越狱」 | 有兜底,Redis 重建后可从表恢复 |
| 审计 | 无冻结历史,谁在何时因何被冻结无据可查 | 表里天然留存操作记录 |
| 一致性 | 无双写问题 | 冻结写库成功写缓存失败,需要补偿 |
配套工程方案选前者,图的是实现简单和 TTL 自动解冻。如果将来要持久化,升级路径也不复杂:
tb_user_info加user_status字段(1正常 /2冻结),userFreeze/userUnfreeze改为「先更库、再写/删缓存」,即经典的 Cache Aside 双写;- 冻结时长一并入库(
freeze_deadline时间戳),到点解冻交给查询时比对或定时任务,不再依赖 Redis TTL; userStatus字段就可以去掉exist = false,列表回填逻辑整体删除,一次 JOIN 就够;- 双写引入新问题:写库成功、写缓存失败怎么办?要么事务消息/MQ 补偿,要么接受短暂不一致(C 端校验仍以 Redis 为准,与库对不上时以先恢复的时间为准)。这正好呼应「标记只是缓存」的定位,Redis 里的冻结 key 本质是一份带 TTL 的标记缓存,事实源上移到 MySQL 后它依然是缓存。
全链路时序
从管理端冻结到解冻、再到两端状态变化的完整链路:
坑表
| 坑 | 现象 | 原因与解法 |
|---|---|---|
| 解冻后 Redis 残留 | 页面已提示「解冻成功」,用户仍被冻结 | key 拼接不一致最常见:冻结时用了 userId 字符串,解冻时传了别的形式(带空格、科学计数)。解法:统一 Constants.USER_FREEZE + userId 拼法,解冻后用 redis-cli 确认 key 确实没了 |
| 列表回填性能 | 用户量大时列表接口变慢 | 逐个 hasKey 是 N 次 RTT。解法:MGET 或 pipeline 合并为 1 次往返,见上文优化写法 |
userStatus 动态置值的并发 | 列表展示「正常」,点进详情却「已冻结」(或反之) | 查询和展示之间存在时间窗,冻结/解冻恰好发生在两次查询之间。这是回填模式的固有现象,属预期行为;要求强一致就得让前端进详情时重新拉取 |
| 冻结时长单位错误 | 选「冻结 3 天」实际只冻 3 分钟 | userFreeze 里 set(key, value, days, TimeUnit.MINUTES) 把天数当分钟传了(前文已实测定位)。这里解冻是 DEL 不涉及时长,但测试冻结-解冻闭环时要知道:3 天的冻结 3 分钟后就自动解冻了 |
| Redis 无持久化的事实源风险 | Redis 重启/清库后所有冻结「集体解除」 | 冻结数据只存在 Redis,没有 MySQL 兜底。短期方案接受该风险并做好 Redis 持久化(AOF/RDB);长期走「MySQL 加字段 + 双写」升级路径 |
reasons 参数被忽略 | 解冻原因传了但查不到 | 纯 Redis 方案没有落库位置,服务端只读 userId。需要审计就先把解冻原因写到日志或数据库 |
验证:可复现的完整闭环
前置:mf-admin、mf-app-server、Redis、Dubbo 相关服务均已启动。以 106 号用户为例。
# 1. 初始状态:确认无冻结数据
redis-cli KEYS "USER_FREEZE_*"
# (empty array)
# 2. 管理后台对 106 号用户执行冻结(选冻结3天),确认 key 写入
redis-cli KEYS "USER_FREEZE_*"
# 1) "USER_FREEZE_106"
redis-cli GET USER_FREEZE_106
# {"freezingRange":"1","freezingTime":"1","reasons":"...","userId":"106"}
# 3. 用户列表/详情应显示"已冻结"
curl "http://localhost:18081/manage/users?page=1&pagesize=10"
# 对应行的 userStatus 为 "2"
# 4. C 端登录应被拦截(checkUserStatus 抛"用户被冻结")
# 5. 执行解冻
curl -X POST "http://localhost:18081/manage/users/unfreeze" \
-H "Content-Type: application/json" \
-d '{"userId":"106","reasons":"测试解冻"}'
# {"message":"解冻成功"}
# 6. redis-cli 确认 key 已删除
redis-cli EXISTS USER_FREEZE_106
# (integer) 0
# 7. 列表/详情恢复 userStatus="1",C 端登录恢复正常
再补一个幂等性验证:对从未冻结的 107 号用户直接调解冻接口,返回仍是 {"message":"解冻成功"},Redis 中无任何变化,服务端无异常,这就是 DEL 语义带来的天然幂等。
常见误解澄清
| 误解 | 事实 |
|---|---|
解冻前要先 hasKey 判断,否则会报错 | DEL 对不存在的 key 返回 0,不抛异常。先判断再删反而多一次 RTT,还引入竞态 |
| 解冻要同步改 MySQL 用户状态 | 本方案 MySQL 里根本没有状态字段,userStatus 是 exist = false 的展示字段,删掉 Redis key 即完成解冻 |
userStatus 是数据库字段,列表查询会带出来 | 它不映射任何列,默认 "1",只有代码里显式 setUserStatus("2") 才会变 |
| 冻结到期后需要管理端手动解冻 | 有 TTL 的 key 到点自动消失,等效于自动解冻;只有「永久冻结」(无 TTL)才必须手动解冻 |
逐个 hasKey 就是批量查询 | 那是 N 次独立往返;真正的批量是 MGET / pipeline,一次网络往返 |
| 解冻原因会存到数据库 | 纯 Redis 方案下 reasons 参数被服务端丢弃,无任何持久化 |
官方文档
- Redis DEL 命令,删除给定 key,不存在的 key 被忽略,返回删除个数
- Redis EXISTS 命令,判断 key 是否存在
- Redis MGET 命令,批量取值,不存在的 key 返回 nil
- Spring Data Redis 官方文档,
RedisTemplate的delete/hasKey/multiGet - MyBatis-Plus TableField 注解,
exist = false表示该属性不映射数据库字段
总结
- 解冻 = 删 key。
userUnfreeze三行核心逻辑,DEL的「不存在不报错」语义让它天然幂等,对未冻结用户调用也安全。 - 查询改造走「查询后回填」:
UserInfo.userStatus用@TableField(exist = false)挡在表外、默认"1",查询后按 Redis 命中与否置"2"。详情接口一次hasKey,列表接口逐行回填,教学可用,生产该换 MGET/pipeline。 - 冻结状态以 Redis 为唯一事实源,代价是「无持久化、无审计」;升级路径是 MySQL 加字段 + Cache Aside 双写,届时
userStatus可以从非表字段转正,回填逻辑整体退役。 - 测试闭环时记得
TimeUnit.MINUTES那个单位 bug(前文已定位):选「3 天」实际 3 分钟就自动解冻,别误判成解冻逻辑有问题。
下一篇把管理后台的行为接到 C 端:修改交友系统,让登录、评论、发动态真正感知冻结与解冻(用户冻结解冻:修改交友系统验证冻结解冻效果)。
406



被折叠的 条评论
为什么被折叠?



