概述
管理员在后台冻结用户后,C 端必须「立刻」感知:登录要被拒、在线用户要被踢。这一篇把冻结的完整代码链路落地,管理端写 Redis、C 端读 Redis,两个独立服务靠共享 Redis 完成实时联动。
纲要
- 整体设计
- 冻结状态存哪里:Redis 的
USER_FREEZE_key - 管理端写 → C 端读的跨服务联动模型
- 涉及文件清单(mf-admin / mf-app-server / mf-commons)
- 管理端冻结接口
ManagerController的POST /manage/users/freezeManagerService.userFreeze():构造 key、构造 TTL、写入 Redis- C 端冻结校验
UserFreezeService.checkUserStatus():读 Redis、比对冻结范围、抛业务异常- 落点一:登录链路(
UserService.sendMsg(),实读确认的唯一调用点) - 落点二:在线请求拦截(
TokenInterceptor实读未实现,文末给补全方案) - 跨系统联动的数据流(时序图)
- 常见坑:key 拼错、校验漏一处、Redis 丢数据、提示语信息量
- 验证:redis-cli + curl 全链路复现
整体设计:冻结状态放在 Redis
先说结论:这套实现里,冻结状态的唯一事实源是 Redis,MySQL 里的 tb_user_info 表不存冻结字段。后台「冻结/解冻」操作的本质就是写/删一个 Redis key,C 端在关键动作前读这个 key 决定放不放行。
分工是这样的:
| 系统 | 工程 | 职责 |
|---|---|---|
| 管理后台 | mf-admin | 接收冻结请求,把冻结状态写入 Redis |
| C 端服务 | mf-app-server | 登录、发布等动作前读 Redis,命中冻结则拒绝 |
| 公共模块 | mf-commons | 提供 Constants.USER_FREEZE 常量,保证两个工程拼出同一个 key |
Constants 里就一行定义,两个工程都依赖它:
package com.mf.commons.utils;
public class Constants {
/** 用户冻结 key 前缀,拼接 userId 后使用,如 USER_FREEZE_106 */
public static final String USER_FREEZE = "USER_FREEZE_";
}
为什么放 Redis 而不是数据库?两个原因:
- 跨服务实时性。
mf-admin和mf-app-server是两个独立部署的服务,各自连自己的数据库表是读不到对方写入的(项目项目里两个工程的 MySQL 共库但不共表逻辑,更关键的是 C 端不应该为了一次冻结去查管理库)。Redis 是两边都连着的公共组件,管理端写进去,C 端立刻能读到,它在这里充当实时性通道。这一点和前面好友关系「双写不一致要靠消息队列对账」是同一个问题的另一面:跨服务的数据一致性,要么走异步消息对账,要么像这里一样干脆选一个公共存储做实时通道,代价是公共存储挂了状态就丢了(后面坑表会讲)。 - TTL 天然匹配业务。冻结三天、七天这类「到点自动解封」的需求,用 Redis 的过期时间实现是零代码的,写数据库反而要加定时任务扫描。
涉及文件(均在 10-数据统计与内容审核/01-代码/mf/mf 工程快照中实读确认):
mf
├── mf-commons
│ └── src/main/java/com/mf/commons/utils
│ └── Constants.java # USER_FREEZE key 前缀
├── mf-admin # 管理后台
│ └── src/main/java/com/mf/admin
│ ├── controller
│ │ └── ManagerController.java # 冻结/解冻接口入口
│ └── service
│ └── ManagerService.java # userFreeze():写 Redis
└── mf-app-server # C 端服务
└── src/main/java/com/mf/server
├── service
│ ├── UserFreezeService.java # checkUserStatus():读 Redis 校验
│ └── UserService.java # sendMsg():登录链路调用校验
└── interceptor
├── TokenInterceptor.java # token 解析(冻结校验补全落点)
└── WebConfig.java # 拦截器注册
| 文件 | 新增/修改 | 这里关注点 |
|---|---|---|
Constants.java | 已有 | USER_FREEZE 前缀 |
ManagerController.java | 新增 freeze 方法 | 接口入口 POST /manage/users/freeze |
ManagerService.java | 新增 userFreeze 方法 | 拼 key、算 TTL、写 Redis |
UserFreezeService.java | 新建 | 统一的冻结校验方法 |
UserService.java | 修改 sendMsg | 登录链路接入校验 |
TokenInterceptor.java | 实读未改 | 在线拦截为扩展点 |
管理端冻结接口
ManagerController
接口文档约定的请求参数是一个 JSON 对象,管理端直接用 Map 接收,不建 DTO,后台接口,参数就三个字段,没必要为它写实体类:
package com.mf.admin.controller;
import com.mf.admin.service.ManagerService;
import com.mf.model.domain.UserInfo;
import com.mf.model.vo.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController
@RequestMapping("/manage")
public class ManagerController {
@Autowired
private ManagerService managerService;
//用户冻结:请求体形如 {"userId":"106","freezingRange":"1","freezingTime":1}
@PostMapping("/users/freeze")
public ResponseEntity freeze(@RequestBody Map params) {
//业务逻辑下沉到 service,返回 {"message":"冻结成功"}
Map map = managerService.userFreeze(params);
return ResponseEntity.ok(map);
}
//用户解冻(下一篇展开)
@PostMapping("/users/unfreeze")
public ResponseEntity unfreeze(@RequestBody Map params) {
Map map = managerService.userUnfreeze(params);
return ResponseEntity.ok(map);
}
//……省略用户列表、查询详情等已有方法
}
注意返回值:接口文档约定返回 {message: "冻结成功"} 这样的结构,最终响应给前端的是 JSON,所以 service 直接返回 Map,由 Spring 序列化,不需要再包一层 DTO。
ManagerService.userFreeze:三步写入 Redis
核心方法,逻辑就三步:构造 key → 构造失效时间 → 写 Redis。
package com.mf.admin.service;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.mf.commons.utils.Constants;
import com.mf.dubbo.api.MovementApi;
import com.mf.dubbo.api.UserInfoApi;
import com.mf.dubbo.api.VideoApi;
import com.mf.model.domain.UserInfo;
import com.mf.model.mongo.Movement;
import com.mf.model.vo.MovementsVo;
import com.mf.model.vo.PageResult;
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;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Service
public class ManagerService {
@Autowired
private RedisTemplate<String,String> redisTemplate;
//用户冻结
public Map userFreeze(Map params) {
//1、构造key:USER_FREEZE_ + 用户id
String userId = params.get("userId").toString();
String key = Constants.USER_FREEZE + userId;
//2、构造失效时间:1为冻结3天,2为冻结7天,3为永久冻结
Integer freezingTime = Integer.valueOf(params.get("freezingTime").toString());
int days = 0;
if(freezingTime == 1) {
days = 3;
}else if(freezingTime == 2) {
days = 7;
}
//freezingTime == 3 时 days 保持 0,走下面的无过期分支,即永久冻结
//3、将参数整体序列化后存入redis,value 里保留了 freezingRange(冻结范围)
String value = JSON.toJSONString(params);
if(days>0) {
//有期限:set(key, value, 时长, 单位)
redisTemplate.opsForValue().set(key,value,days, TimeUnit.MINUTES);
}else {
//永久冻结:不设置过期时间
redisTemplate.opsForValue().set(key,value);
}
Map retMap = new HashMap();
retMap.put("message","冻结成功");
return retMap;
}
}
三步的关键决策:
| 步骤 | 决策 | 说明 |
|---|---|---|
| key | USER_FREEZE_ + userId | 前缀来自公共 Constants,管理端和 C 端必须拼出同一个 key |
| value | JSON.toJSONString(params) | 把请求参数整体存进去,C 端要靠里面的 freezingRange 判断冻结范围,不存值就无法区分「禁登录」还是「禁发布」 |
| TTL | freezingTime 映射天数,3=永久不设过期 | 到期 Redis 自动删 key,解冻零代码 |
一个要指出的细节:代码里 TTL 单位用的是 TimeUnit.MINUTES,演示时为了不用真等三天验证,故意把「3 天」降级成「3 分钟」。days 这个变量名和 if 判断都还是按天语义写的,生产落地时这里应改为 TimeUnit.DAYS,这也是个典型的「演示代码与语义不一致」的坑,面试聊到这段可以主动提。
mf-admin/src/main/java/com/mf/admin
├── controller
│ └── ManagerController.java # POST /manage/users/freeze → userFreeze()
└── service
└── ManagerService.java # 拼 key → 算 TTL → set 进 Redis
C 端校验:UserFreezeService
统一校验方法
C 端把「读 Redis 判断冻结」抽成一个独立 service,各业务点调用它即可,避免每个接口自己拼 key 自己解析:
package com.mf.server.service;
import com.alibaba.fastjson.JSON;
import com.mf.commons.utils.Constants;
import com.mf.model.vo.ErrorResult;
import com.mf.server.exception.BusinessException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Map;
@Service
public class UserFreezeService {
@Autowired
private RedisTemplate<String,String> redisTemplate;
/**
* 判断用户是否被冻结,已被冻结则抛出异常
* @param state 冻结范围:传 "1" 表示校验登录冻结
* @param userId 用户id
* 检测登录:checkUserStatus("1", 106L)
*/
public void checkUserStatus(String state, Long userId) {
//1、拼接key,从redis中查询数据(与管理端同一个前缀)
String key = Constants.USER_FREEZE + userId;
String value = redisTemplate.opsForValue().get(key);
//2、key 不存在说明未冻结,直接放行
if(!StringUtils.isEmpty(value)) {
//3、key 存在,解析出冻结范围,与本次校验的范围比对
Map map = JSON.parseObject(value, Map.class);
String freezingRange = (String) map.get("freezingRange");
if(state.equals(freezingRange)) {
//范围一致:该用户在当前业务上确实被冻结,抛业务异常
throw new BusinessException(ErrorResult.builder().errMessage("用户被冻结").build());
}
}
}
}
这里的设计点是冻结范围(freezingRange):管理端冻结时不一定封所有功能,"1" 表示冻结登录,其他值对应评论、发动态等范围。校验方法把范围作为参数传进来,key 命中但范围不匹配时照样放行,比如用户被「禁发布动态」但仍可登录浏览。state.equals(freezingRange) 把常量写在 equals 左边,天然防 NPE。
落点一:登录链路(实读确认的唯一调用点)
实读当前工程快照,checkUserStatus 在 C 端只有一处调用,UserService.sendMsg(),即发送短信验证码之前。这个位置选得很巧:登录的第一步就是拿验证码,在这里拦住,后面 loginVerification() 根本走不到,整条登录链路就被间接封死了:
package com.mf.server.service;
import com.mf.autoconfig.template.SmsTemplate;
import com.mf.dubbo.api.UserApi;
import com.mf.model.domain.User;
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;
import java.time.Duration;
@Service
public class UserService {
@Autowired
private SmsTemplate template;
@Autowired
private RedisTemplate<String,String> redisTemplate;
@Autowired
private UserFreezeService userFreezeService;
@DubboReference
private UserApi userApi;
/**
* 发送短信验证码(登录第一步)
*/
public void sendMsg(String phone) {
//校验用户状态:先按手机号查用户,存在则检查是否被冻结(范围"1"=登录)
User user = userApi.findByMobile(phone);
if(user != null) {
//已注册用户才可能被冻结;新手机号直接放行走注册流程
userFreezeService.checkUserStatus("1", user.getId());
}
//1、随机生成6位数字验证码
//String code = RandomStringUtils.randomNumeric(6);
String code = "123456";
//2、调用template对象,发送手机短信(演示环境 mock)
//template.sendSms(phone,code);
//3、将验证码存入redis,5分钟有效
redisTemplate.opsForValue().set("CHECK_CODE_"+phone, code, Duration.ofMinutes(5));
}
}
(代码与工程实读一致,只省略了 loginVerification 等与冻结无关的方法;import 中 HuanXinTemplate、JwtUtils、MqMessageService 等属于其余方法所需,一并省略。)
有一个容易忽略的边界:if (user != null) 不可省。被冻结的前提是用户已注册,一个全新手机号在 tb_user 里查不到记录,没有 userId,也没必要校验,直接放行让它走注册。如果这里不判空就调 user.getId(),新用户注册功能直接 NPE。
落点二:在线请求拦截(实读未实现,给出补全方案)
实读 TokenInterceptor,它的 preHandle 只做了三件事:取 Authorization 头、解析 JWT、把 User 塞进 ThreadLocal,没有任何冻结校验。也就是说配套工程当前版本只做到了「登录必拒」,没有做到「在线即踢」:已登录用户拿到 token 后,冻结期间依然能继续发动态、发评论,直到 token 自然过期。配套资料也注明「发布动态和发布评论等接口也需要做相应的校验工作」,属于留的扩展题。
要补全「两处都校验」的方案,最小改动是在拦截器里加一次 Redis 查询:
package com.mf.server.interceptor;
import com.mf.commons.utils.Constants;
import com.mf.commons.utils.JwtUtils;
import com.mf.model.domain.User;
import com.mf.model.vo.ErrorResult;
import com.mf.server.exception.BusinessException;
import io.jsonwebtoken.Claims;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class TokenInterceptor implements HandlerInterceptor {
//拦截器不是 Spring 管理的 Bean(WebConfig 里 new 出来注册),
//redisTemplate 需在 WebConfig 构造拦截器时通过构造器传入
private final RedisTemplate<String,String> redisTemplate;
public TokenInterceptor(RedisTemplate<String,String> redisTemplate) {
this.redisTemplate = redisTemplate;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1、获取请求头
String token = request.getHeader("Authorization");
//2、解析token,获取id和手机号码,构造User对象,存入ThreadLocal
Claims claims = JwtUtils.getClaims(token);
String mobile = (String) claims.get("mobile");
// 数值字段按大小选型:小值(如教学 106)反序列化为 Integer,真实雪花 ID(远超 2^31)为 Long。
// 统一按 Object 读取再 toString,避免 (Integer) 强转在真实 ID 上抛 ClassCastException
Object idObj = claims.get("id");
Long id = Long.valueOf(idObj.toString());
User user = new User();
user.setId(id);
user.setMobile(mobile);
UserHolder.set(user);
//3、【补全】校验登录范围冻结:key 命中即踢出(在线用户的后续请求全部拒绝)
String freezeKey = Constants.USER_FREEZE + user.getId();
if (Boolean.TRUE.equals(redisTemplate.hasKey(freezeKey))) {
throw new BusinessException(ErrorResult.builder().errMessage("账号已被冻结").build());
}
//4、放行
return true;
}
}
这段是工程快照之外的补全,不是实读代码,标注清楚。放在拦截器而不是每个业务 service 里,理由是:登录范围冻结意味着该用户所有需要登录的接口都应拒绝,属于横切关注点,拦截器一处搞定,业务代码零改动。另一个更细粒度的做法是只拦截发动态、发评论对应的冻结范围(freezingRange 为 2、3 等值),那就要把 checkUserStatus("2", userId) 落到具体业务 service 里,按产品语义选位置,两种写法不冲突。
mf-app-server/src/main/java/com/mf/server
├── service
│ ├── UserFreezeService.java # checkUserStatus(state, userId):核心校验
│ └── UserService.java # sendMsg():登录链路接入校验(实读唯一调用点)
└── interceptor
├── WebConfig.java # 拦截 /**,排除 /user/login、/user/loginVerification
└── TokenInterceptor.java # 实读无冻结校验;补全方案见上文
跨系统联动的数据流
把整条链路串起来:管理端写、C 端读,Redis 是两个服务之间唯一的状态载体。
对比一下前面好友关系「双写 + 对账」的方案:那次是两个库各自存一份数据,靠消息队列事后对账;这次干脆只存一份在 Redis,两边读写同一个 key,天然一致。代价是 Redis 成为单点事实源,数据丢了冻结就失效。两种模式对应两种取舍:要强实时就共享存储,要最终一致就双写对账。
常见坑
| 坑 | 现象 | 排查/规避 |
|---|---|---|
| 冻结 key 拼错 | 管理端显示冻结成功,C 端却还能登录 | 两个工程必须用同一个 Constants.USER_FREEZE 前缀;手写字符串 "USER_FREEZE"(少了尾部下划线)或一边手写一边用常量,就会出现「写 A 读 B」。redis-cli 先 KEYS USER_FREEZE_* 确认 key 真实存在 |
| C 端只拦了登录、没拦在线 | 冻结后新登录被拒,但已登录用户照常操作 | 实读工程就处于这个状态(checkUserStatus 只有 sendMsg 一个调用点,TokenInterceptor 无校验)。按上文补全拦截器,并回归测试「已登录 token 请求」 |
| Redis 数据丢失,冻结失效 | Redis 重启/主从切换后,被冻结用户又能登录了 | 冻结状态只存 Redis、不落库,就是拿持久性换实时性。要求高的场景应把冻结记录同步落库,Redis 读不到时回调查询库兜底;至少给永久冻结设监控告警 |
| freezingRange 类型强转异常 | (String) map.get("freezingRange") 抛 ClassCastException | 前端传数字 1 而不是字符串 "1" 时,fastjson 反序列化回 Map 得到的是 Integer,强转 String 直接炸。取值改用 JSON.parseObject(value).getString("freezingRange"),或与前端约定传字符串 |
| 冻结提示语信息量不足 | 用户只看到「用户被冻结」,不知道原因和解封时间 | 提示语是否告知原因/期限是产品决策:告知可减少客诉,但也暴露了风控规则。建议至少带解封时间;生产系统常见话术是「账号存在违规行为,暂时无法登录」 |
| TTL 单位与语义不符 | 冻结「3 天」实际只冻结 3 分钟 | 配套工程代码用 TimeUnit.MINUTES 方便本地演示,上线必须改成 TimeUnit.DAYS,review 时重点盯这个参数 |
验证:从冻结到踢出的完整复现
按顺序执行,每一步都有可观察的结果(管理端服务默认端口以本地实际为准,下面用 :8090/:8080 示意):
# 1、管理端发起冻结:冻结用户 106 的登录(freezingRange=1),选项 1(演示环境对应 3 分钟)
curl -X POST http://localhost:8090/manage/users/freeze \
-H "Content-Type: application/json" \
-d '{"userId":"106","freezingRange":"1","freezingTime":1}'
# 期望返回:{"message":"冻结成功"}
# 2、redis-cli 确认 key 已写入(带 TTL 时会显示过期秒数)
redis-cli KEYS 'USER_FREEZE_*'
# 期望输出:1) "USER_FREEZE_106"
redis-cli TTL USER_FREEZE_106
# 期望输出:180(TimeUnit.MINUTES 语义下为 3 分钟)
redis-cli GET USER_FREEZE_106
# 期望输出:{"userId":"106","freezingRange":"1","freezingTime":1}
# 3、C 端登录第一步(发验证码)被拒
curl -X POST http://localhost:8080/user/login \
-H "Content-Type: application/json" \
-d '{"phone":"13800000001"}'
# 期望返回:{"errMessage":"用户被冻结"},验证码未下发
# 4、已登录 token 请求被拒(需先落地拦截器补全,未补全时此步仍放行——即上面坑表的第二条)
curl http://localhost:8080/movements/all \
-H "Authorization: <用户106的有效token>"
# 期望返回:{"errMessage":"账号已被冻结"}
# 5、删除 key 模拟到期解冻(真实解冻接口见下一篇)
redis-cli DEL USER_FREEZE_106
# 期望输出:1
# 6、再次登录,恢复正常
curl -X POST http://localhost:8080/user/login \
-H "Content-Type: application/json" \
-d '{"phone":"13800000001"}'
# 期望返回:{"token":"...","isNew":false}
常见误解澄清
| 误解 | 事实 |
|---|---|
| 冻结状态存在 MySQL 里 | 配套资料概述里写「写入数据库」,但实读代码:管理端只写 Redis,C 端只读 Redis,MySQL 的 tb_user_info 没有冻结字段。唯一沾边的是列表页用 @TableField(exist = false) 的 userStatus 展示字段,值也是查 Redis 得来的 |
| 冻结后会立刻把在线用户踢下线 | 实读工程不会。token 依然有效,TokenInterceptor 没有冻结校验,「在线即踢」属于留的扩展点,需按上文补全 |
| 永久冻结是设置一个超长 TTL | 是不设置 TTL 的 set(key, value),key 不过期即永久。设超长时间(如 100 年)也能跑但语义差,且占内存 |
| 冻结等于封号(物理删除) | 不是。冻结是临时惩罚措施,key 过期或管理员解冻后用户一切功能恢复,数据都在 |
| 每个业务接口要各自实现冻结判断 | 判断逻辑收敛在 UserFreezeService.checkUserStatus() 一处,业务点只负责调用并传入冻结范围 |
官方文档
- Spring Data Redis - RedisTemplate:
opsForValue().set(key, value, timeout, unit)与无过期重载的行为差异 - Redis EXPIRE 与 key 过期:TTL 语义、过期删除策略,理解「到期自动解冻」的底层机制
- JSON.toJSONString - Fastjson:value 序列化与
getString()安全取值
总结
- 冻结的代码实现就三步:拼
USER_FREEZE_{userId}key、按freezingTime算 TTL(3 对应永久不设过期)、把含freezingRange的参数整体 JSON 写入 Redis。 - C 端校验收敛在
UserFreezeService.checkUserStatus(),实读唯一调用点是登录链路的sendMsg();在线请求拦截工程里没做,用拦截器补一行hasKey即可踢出在线用户。 - 这条链路的架构价值在于跨服务联动方式:
mf-admin和mf-app-server两个独立服务共享 Redis,写读同一个 key 实现实时生效,代价是 Redis 成为事实源、宕机即失效,和好友关系「双写 + 对账」是同一问题的两种解法。 - 演示代码留了两个尾巴:TTL 单位用了
MINUTES,生产要改DAYS;freezingRange的类型强转对前端传参格式敏感,取值建议走getString()。
下一篇接着拆解冻:管理端怎么删 key、以及后台用户列表页如何改造才能实时显示每个用户的冻结状态,用户解冻的代码实现和查询用户数据的改造。
1950



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



