feat(basic): 添加模板片段更新状态缓存支持

- 在FaceStatusManager中新增按模板ID区分的人脸片段更新状态缓存键
- 更新TaskTaskServiceImpl以设置模板渲染状态
- 在任务回调逻辑中增加对模板渲染状态的更新操作
- 修改任务删除逻辑为更新状态加10的临时解决方案
- 移除旧有的切割任务状态更新逻辑,统一使用模板渲染状态管理
This commit is contained in:
2025-12-17 15:28:32 +08:00
parent a9c33352f7
commit 00890c764e
17 changed files with 994 additions and 401 deletions

View File

@@ -0,0 +1,348 @@
package com.ycwl.basic.biz;
import com.ycwl.basic.enums.FaceCutStatus;
import com.ycwl.basic.enums.FacePieceUpdateStatus;
import com.ycwl.basic.enums.TemplateRenderStatus;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* 人脸状态缓存管理器
* 统一管理人脸相关的Redis缓存状态
*/
@Slf4j
@Component
public class FaceStatusManager {
/**
* 人脸切片状态缓存Key
* 格式: face:status:cut:{faceId}
* 过期时间: 1天
*/
private static final String FACE_CUT_STATUS_KEY = "face:status:cut:%s";
/**
* 人脸片段更新状态缓存Key(全局)
* 格式: face:status:piece:update:{faceId}
* 过期时间: 1天
* 键存在 = 无新片段,键不存在 = 有新片段
*/
private static final String FACE_PIECE_UPDATE_KEY = "face:status:piece:update:%s";
/**
* 人脸模板片段更新状态缓存Key(按模板)
* 格式: face:status:piece:update:{faceId}:{templateId}
* 过期时间: 1天
* 键存在 = 无新片段,键不存在 = 有新片段
*/
private static final String FACE_TEMPLATE_PIECE_UPDATE_KEY = "face:status:piece:update:%s:%s";
/**
* 人脸模板渲染状态缓存Key
* 格式: face:status:render:{faceId}:{templateId}
* 过期时间: 永久(或根据业务需要设置)
*/
private static final String FACE_TEMPLATE_RENDER_KEY = "face:status:render:%s:%s";
/**
* 默认过期时间:1天
*/
private static final long DEFAULT_EXPIRE_SECONDS = 86400L;
@Autowired
private RedisTemplate<String, String> redisTemplate;
// ==================== 切片状态相关方法 ====================
/**
* 设置人脸切片状态
* @param faceId 人脸ID
* @param status 切片状态
*/
public void setFaceCutStatus(Long faceId, FaceCutStatus status) {
if (faceId == null || status == null) {
log.warn("设置切片状态参数为空: faceId={}, status={}", faceId, status);
return;
}
String key = String.format(FACE_CUT_STATUS_KEY, faceId);
redisTemplate.opsForValue().set(key, String.valueOf(status.getCode()), DEFAULT_EXPIRE_SECONDS, TimeUnit.SECONDS);
log.debug("设置切片状态: faceId={}, status={}", faceId, status.getDescription());
}
/**
* 获取人脸切片状态
* @param faceId 人脸ID
* @return 切片状态,缓存不存在时返回 COMPLETED(已完成)
*/
public FaceCutStatus getFaceCutStatus(Long faceId) {
if (faceId == null) {
log.warn("获取切片状态参数为空: faceId={}", faceId);
return FaceCutStatus.COMPLETED;
}
String key = String.format(FACE_CUT_STATUS_KEY, faceId);
String value = redisTemplate.opsForValue().get(key);
if (value == null) {
log.debug("切片状态缓存不存在,返回默认值COMPLETED: faceId={}", faceId);
return FaceCutStatus.COMPLETED;
}
try {
int code = Integer.parseInt(value);
return FaceCutStatus.fromCodeOrDefault(code, FaceCutStatus.COMPLETED);
} catch (NumberFormatException e) {
log.error("切片状态值解析失败: faceId={}, value={}", faceId, value, e);
return FaceCutStatus.COMPLETED;
}
}
/**
* 删除人脸切片状态缓存
* @param faceId 人脸ID
*/
public void deleteFaceCutStatus(Long faceId) {
if (faceId == null) {
return;
}
String key = String.format(FACE_CUT_STATUS_KEY, faceId);
redisTemplate.delete(key);
log.debug("删除切片状态缓存: faceId={}", faceId);
}
// ==================== 片段更新状态相关方法 ====================
/**
* 标记无新片段(设置Redis键)
* @param faceId 人脸ID
* @param templateId 模板ID(可选,为null时标记全局状态)
*/
public void markNoNewPieces(Long faceId, Long templateId) {
if (faceId == null) {
log.warn("标记无新片段参数为空: faceId={}", faceId);
return;
}
String key;
if (templateId == null) {
// 全局标记:该人脸的所有模板都无新片段
key = String.format(FACE_PIECE_UPDATE_KEY, faceId);
log.debug("标记无新片段(全局): faceId={}", faceId);
} else {
// 模板级标记:该人脸在该模板下无新片段
key = String.format(FACE_TEMPLATE_PIECE_UPDATE_KEY, faceId, templateId);
log.debug("标记无新片段(模板): faceId={}, templateId={}", faceId, templateId);
}
redisTemplate.opsForValue().set(key, "1", DEFAULT_EXPIRE_SECONDS, TimeUnit.SECONDS);
}
/**
* 标记有新片段(删除Redis键)
* @param faceId 人脸ID
* @param templateId 模板ID(可选,为null时标记全局状态)
*/
public void markHasNewPieces(Long faceId, Long templateId) {
if (faceId == null) {
log.warn("标记有新片段参数为空: faceId={}", faceId);
return;
}
String key;
if (templateId == null) {
// 全局标记:该人脸有新片段
key = String.format(FACE_PIECE_UPDATE_KEY, faceId);
log.debug("标记有新片段(全局): faceId={}", faceId);
} else {
// 模板级标记:该人脸在该模板下有新片段
key = String.format(FACE_TEMPLATE_PIECE_UPDATE_KEY, faceId, templateId);
log.debug("标记有新片段(模板): faceId={}, templateId={}", faceId, templateId);
}
redisTemplate.delete(key);
}
/**
* 获取人脸片段更新状态
* @param faceId 人脸ID
* @param templateId 模板ID(可选,为null时查询全局状态)
* @return 片段更新状态,键存在=无新片段,键不存在=有新片段
*/
public FacePieceUpdateStatus getFacePieceUpdateStatus(Long faceId, Long templateId) {
if (faceId == null) {
log.warn("获取片段更新状态参数为空: faceId={}", faceId);
return FacePieceUpdateStatus.HAS_NEW_PIECES;
}
String key;
if (templateId == null) {
// 查询全局状态
key = String.format(FACE_PIECE_UPDATE_KEY, faceId);
} else {
// 查询模板级状态
key = String.format(FACE_TEMPLATE_PIECE_UPDATE_KEY, faceId, templateId);
}
Boolean exists = redisTemplate.hasKey(key);
FacePieceUpdateStatus status = FacePieceUpdateStatus.fromKeyExists(Boolean.TRUE.equals(exists));
if (templateId == null) {
log.debug("获取片段更新状态(全局): faceId={}, status={}", faceId, status.getDescription());
} else {
log.debug("获取片段更新状态(模板): faceId={}, templateId={}, status={}",
faceId, templateId, status.getDescription());
}
return status;
}
/**
* 获取人脸片段更新状态 - 全局版本
* @param faceId 人脸ID
* @return 片段更新状态,键存在=无新片段,键不存在=有新片段
*/
public FacePieceUpdateStatus getFacePieceUpdateStatus(Long faceId) {
return getFacePieceUpdateStatus(faceId, null);
}
/**
* 判断是否有新片段
* @param faceId 人脸ID
* @param templateId 模板ID(可选,为null时查询全局状态)
* @return true=有新片段,false=无新片段;如果templateId为null则默认返回true(有新片段)
*/
public boolean hasNewPieces(Long faceId, Long templateId) {
if (templateId == null) {
// 如果没有指定templateId,默认认为有新片段
log.debug("未指定templateId,默认返回有新片段: faceId={}", faceId);
return true;
}
return getFacePieceUpdateStatus(faceId, templateId).hasNewPieces();
}
/**
* 判断是否有新片段 - 全局版本
* @param faceId 人脸ID
* @return true=有新片段,false=无新片段
*/
public boolean hasNewPieces(Long faceId) {
return getFacePieceUpdateStatus(faceId, null).hasNewPieces();
}
// ==================== 模板渲染状态相关方法 ====================
/**
* 设置人脸模板渲染状态
* @param faceId 人脸ID
* @param templateId 模板ID
* @param status 渲染状态
*/
public void setTemplateRenderStatus(Long faceId, Long templateId, TemplateRenderStatus status) {
if (faceId == null || templateId == null || status == null) {
log.warn("设置模板渲染状态参数为空: faceId={}, templateId={}, status={}", faceId, templateId, status);
return;
}
String key = String.format(FACE_TEMPLATE_RENDER_KEY, faceId, templateId);
// 渲染状态不设置过期时间,永久保存
redisTemplate.opsForValue().set(key, String.valueOf(status.getCode()));
log.debug("设置模板渲染状态: faceId={}, templateId={}, status={}", faceId, templateId, status.getDescription());
}
/**
* 设置人脸模板渲染状态(带过期时间)
* @param faceId 人脸ID
* @param templateId 模板ID
* @param status 渲染状态
* @param expireSeconds 过期时间(秒)
*/
public void setTemplateRenderStatus(Long faceId, Long templateId, TemplateRenderStatus status, long expireSeconds) {
if (faceId == null || templateId == null || status == null) {
log.warn("设置模板渲染状态参数为空: faceId={}, templateId={}, status={}", faceId, templateId, status);
return;
}
String key = String.format(FACE_TEMPLATE_RENDER_KEY, faceId, templateId);
redisTemplate.opsForValue().set(key, String.valueOf(status.getCode()), expireSeconds, TimeUnit.SECONDS);
log.debug("设置模板渲染状态(带过期): faceId={}, templateId={}, status={}, expireSeconds={}",
faceId, templateId, status.getDescription(), expireSeconds);
}
/**
* 获取人脸模板渲染状态
* @param faceId 人脸ID
* @param templateId 模板ID
* @return 渲染状态,缓存不存在时返回 null
*/
public TemplateRenderStatus getTemplateRenderStatus(Long faceId, Long templateId) {
if (faceId == null || templateId == null) {
log.warn("获取模板渲染状态参数为空: faceId={}, templateId={}", faceId, templateId);
return null;
}
String key = String.format(FACE_TEMPLATE_RENDER_KEY, faceId, templateId);
String value = redisTemplate.opsForValue().get(key);
if (value == null) {
log.debug("模板渲染状态缓存不存在: faceId={}, templateId={}", faceId, templateId);
return null;
}
try {
int code = Integer.parseInt(value);
return TemplateRenderStatus.fromCode(code);
} catch (Exception e) {
log.error("模板渲染状态值解析失败: faceId={}, templateId={}, value={}", faceId, templateId, value, e);
return null;
}
}
/**
* 判断模板是否已渲染完成
* @param faceId 人脸ID
* @param templateId 模板ID
* @return true=已渲染,false=未渲染或正在渲染
*/
public boolean isTemplateRendered(Long faceId, Long templateId) {
TemplateRenderStatus status = getTemplateRenderStatus(faceId, templateId);
return status != null && status.isRendered();
}
/**
* 判断模板是否正在渲染
* @param faceId 人脸ID
* @param templateId 模板ID
* @return true=正在渲染,false=未渲染或已完成
*/
public boolean isTemplateRendering(Long faceId, Long templateId) {
TemplateRenderStatus status = getTemplateRenderStatus(faceId, templateId);
return status != null && status.isRendering();
}
/**
* 删除人脸模板渲染状态缓存
* @param faceId 人脸ID
* @param templateId 模板ID
*/
public void deleteTemplateRenderStatus(Long faceId, Long templateId) {
if (faceId == null || templateId == null) {
return;
}
String key = String.format(FACE_TEMPLATE_RENDER_KEY, faceId, templateId);
redisTemplate.delete(key);
log.debug("删除模板渲染状态缓存: faceId={}, templateId={}", faceId, templateId);
}
/**
* 删除人脸的所有模板渲染状态(使用模式匹配)
* 注意:此操作可能影响性能,谨慎使用
* @param faceId 人脸ID
*/
public void deleteAllTemplateRenderStatus(Long faceId) {
if (faceId == null) {
return;
}
String pattern = String.format(FACE_TEMPLATE_RENDER_KEY, faceId, "*");
var keys = redisTemplate.keys(pattern);
if (keys != null && !keys.isEmpty()) {
redisTemplate.delete(keys);
log.debug("批量删除模板渲染状态缓存: faceId={}, count={}", faceId, keys.size());
}
}
}

View File

@@ -1,192 +0,0 @@
package com.ycwl.basic.biz;
import com.ycwl.basic.mapper.FaceMapper;
import com.ycwl.basic.mapper.TaskMapper;
import com.ycwl.basic.mapper.VideoMapper;
import com.ycwl.basic.model.mobile.goods.VideoTaskStatusVO;
import com.ycwl.basic.model.pc.face.entity.FaceEntity;
import com.ycwl.basic.model.pc.face.resp.FaceRespVO;
import com.ycwl.basic.model.pc.task.req.TaskReqQuery;
import com.ycwl.basic.model.pc.task.resp.TaskRespVO;
import com.ycwl.basic.model.pc.template.resp.TemplateRespVO;
import com.ycwl.basic.model.pc.video.entity.VideoEntity;
import com.ycwl.basic.repository.FaceRepository;
import com.ycwl.basic.repository.TemplateRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Component
public class TaskStatusBiz {
public static final String TASK_STATUS_USER_CACHE_KEY = "task:status:user:%s:face:%s";
public static final String TASK_STATUS_FACE_CACHE_KEY = "task:status:face:%s";
public static final String TASK_STATUS_FACE_CACHE_KEY_CUT = "task:status:face:%s:cut";
public static final String TASK_STATUS_FACE_CACHE_KEY_TEMPLATE = "task:status:face:%s:tpl:%s";
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Autowired
private FaceRepository faceRepository;
@Autowired
private TemplateRepository templateRepository;
@Autowired
private FaceMapper faceMapper;
@Autowired
private TaskMapper taskMapper;
@Autowired
private VideoMapper videoMapper;
@Autowired
private TemplateBiz templateBiz;
public boolean getUserHaveFace(Long userId, Long faceId) {
if (userId == null || faceId == null) {
return false;
}
if (redisTemplate.hasKey(String.format(TASK_STATUS_USER_CACHE_KEY, userId, faceId))) {
return true;
}
FaceEntity face = faceRepository.getFace(faceId);
if (face == null) {
return false;
}
if (face.getMemberId().equals(userId)) {
redisTemplate.opsForValue().set(String.format(TASK_STATUS_USER_CACHE_KEY, userId, faceId), "1", 3600, TimeUnit.SECONDS);
return true;
} else {
return false;
}
}
public void setFaceCutStatus(Long faceId, int status) {
redisTemplate.opsForValue().set(String.format(TASK_STATUS_FACE_CACHE_KEY_CUT, faceId), String.valueOf(status), 3600, TimeUnit.SECONDS);
}
public void setFaceTemplateStatus(Long faceId, Long templateId, Long videoId) {
redisTemplate.opsForValue().set(String.format(TASK_STATUS_FACE_CACHE_KEY_TEMPLATE, faceId, templateId), String.valueOf(videoId), 3600, TimeUnit.SECONDS);
}
public VideoTaskStatusVO getScenicUserStatus(Long scenicId, Long userId) {
FaceRespVO lastFace = faceMapper.findLastFaceByScenicAndUserId(scenicId, userId);
VideoTaskStatusVO response = new VideoTaskStatusVO();
if (lastFace == null) {
response.setStatus(-1);
return response;
}
return getFaceStatus(lastFace.getId());
}
public VideoTaskStatusVO getFaceStatus(Long faceId) {
FaceEntity face = faceRepository.getFace(faceId);
VideoTaskStatusVO response = new VideoTaskStatusVO();
if (face == null) {
response.setStatus(-1);
return response;
}
response.setScenicId(face.getScenicId());
response.setFaceId(faceId);
List<TemplateRespVO> templateList = templateRepository.getTemplateListByScenicId(face.getScenicId());
response.setMaxCount(templateList.size());
int alreadyFinished = 0;
for (TemplateRespVO template : templateList) {
response.setTemplateId(template.getId());
long videoId = getFaceTemplateVideoId(faceId, template.getId());
if (videoId <= 0) {
response.setStatus(2);
} else {
response.setVideoId(videoId);
alreadyFinished++;
}
}
response.setCount(alreadyFinished);
if (alreadyFinished == 0) {
response.setStatus(0);
} else {
response.setStatus(1);
}
if (alreadyFinished == 0) {
int faceCutStatus = getFaceCutStatus(faceId);
if (faceCutStatus != 1) {
// 正在切片
if (templateBiz.determineTemplateCanGenerate(templateList.getFirst().getId(), faceId, false)) {
response.setStatus(2);
} else {
response.setStatus(0);
}
}
}
return response;
}
public VideoTaskStatusVO getFaceTemplateStatus(Long faceId, Long templateId) {
FaceEntity face = faceRepository.getFace(faceId);
VideoTaskStatusVO response = new VideoTaskStatusVO();
if (face == null) {
response.setStatus(-1);
return response;
}
response.setScenicId(face.getScenicId());
response.setFaceId(faceId);
response.setTemplateId(templateId);
long videoId = getFaceTemplateVideoId(faceId, templateId);
if (videoId < 0) {
int faceCutStatus = getFaceCutStatus(faceId);
if (faceCutStatus != 1) {
// 正在切片
response.setStatus(2);
return response;
}
} else if (videoId == 0) {
response.setStatus(2);
} else {
response.setVideoId(videoId);
response.setStatus(1);
}
return response;
}
public int getFaceCutStatus(Long faceId) {
if (redisTemplate.hasKey(String.format(TASK_STATUS_FACE_CACHE_KEY_CUT, faceId))) {
String status = redisTemplate.opsForValue().get(String.format(TASK_STATUS_FACE_CACHE_KEY_CUT, faceId));
if (status != null) {
return Integer.parseInt(status);
}
}
return 1;
}
public long getFaceTemplateVideoId(Long faceId, Long templateId) {
if (redisTemplate.hasKey(String.format(TASK_STATUS_FACE_CACHE_KEY_TEMPLATE, faceId, templateId))) {
String status = redisTemplate.opsForValue().get(String.format(TASK_STATUS_FACE_CACHE_KEY_TEMPLATE, faceId, templateId));
if (status != null) {
return Long.parseLong(status);
}
}
TaskReqQuery taskReqQuery = new TaskReqQuery();
taskReqQuery.setFaceId(faceId);
taskReqQuery.setTemplateId(templateId);
List<TaskRespVO> list = taskMapper.list(taskReqQuery);
Optional<TaskRespVO> min = list.stream().min(Comparator.comparing(TaskRespVO::getCreateTime));
if (min.isPresent()) {
TaskRespVO task = min.get();
long taskStatus = 0;
if (task.getStatus() == 1) {
// 已完成
VideoEntity video = videoMapper.findByTaskId(task.getId());
if (video != null) {
taskStatus = video.getId();
}
}
setFaceTemplateStatus(faceId, templateId, taskStatus);
} else {
// 从来没生成过
setFaceTemplateStatus(faceId, templateId, -1L);
return -1;
}
return 0;
}
}