697 lines
24 KiB
Markdown
697 lines
24 KiB
Markdown
# 丹阳公益婚恋服务平台 — 问题修复计划
|
||
|
||
> 基于 2026-09-01 代码审查报告，按优先级排列的修复计划。
|
||
> 每个修复项包含：问题定位、根因分析、修复方案、验证方法。
|
||
|
||
---
|
||
|
||
## P0 — 阻塞上线（4项）
|
||
|
||
### P0-1: 修复 `MessagingService.isBlocked()` — Block不变量失效
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/messaging/service/MessagingService.java`
|
||
**行号**: 313-316
|
||
**违反**: INV-003 (Block优先级最高)
|
||
|
||
**根因**: 方法被标记为 `// TODO: Phase 08` 并返回硬编码 `false`，导致拉黑后仍可发送消息。
|
||
|
||
**修复方案**:
|
||
|
||
```java
|
||
// 当前 (错误):
|
||
private boolean isBlocked(String userId, String targetUserId) {
|
||
// TODO: Phase 08 的 UserRelationMapper 查询
|
||
return false;
|
||
}
|
||
|
||
// 修复后:
|
||
private final UserRelationMapper relationMapper; // 在构造器中注入（已有）
|
||
|
||
private boolean isBlocked(String userId, String targetUserId) {
|
||
return relationMapper.findByRelation(userId, targetUserId, Constants.RELATION_TYPE_BLOCKED).isPresent();
|
||
}
|
||
```
|
||
|
||
**需要同步修复的位置**:
|
||
1. `MessagingService.java:274` — `dto.setCanSend(true);` 改为检查 `!isBlocked()`
|
||
2. `RelationshipService.java` — `isBlocked()` 已正确实现，无需修改
|
||
|
||
**验证**:
|
||
```java
|
||
@Test
|
||
void testBlockStopsChat() {
|
||
// A Block B → A发消息给B → 应抛"对方已将你拉黑"
|
||
relationshipService.block(userA, userB);
|
||
assertThrows(RuntimeException.class,
|
||
() -> messagingService.sendMessage(userA, conversationId, "test", null));
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 30分钟
|
||
|
||
---
|
||
|
||
### P0-2: 修复 `RelationshipStatusService.confirmSuccess()` — 双确认逻辑缺失
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/relationship/service/RelationshipStatusService.java`
|
||
**行号**: 132-174
|
||
**违反**: INV-005 (成功牵手必须双确认) + AGENTS第5条
|
||
|
||
**根因**: 任何一方调用 `confirmSuccess()` 即直接确认成功，没有检查对方是否也确认了。
|
||
|
||
**修复方案**:
|
||
|
||
```java
|
||
@Transactional
|
||
public Map<String, Object> confirmSuccess(String userId, String targetUserId) {
|
||
// 1. 校验有效Match
|
||
Match match = matchMapper.findActiveMatch(userId, targetUserId)
|
||
.orElseThrow(() -> new BusinessException(ApiResponseCode.NOT_FOUND, "匹配关系不存在"));
|
||
|
||
// 2. 查找或创建pending请求（基于matchId防重复）
|
||
RelationshipSuccessRequest request = successRequestMapper.selectOne(
|
||
new LambdaQueryWrapper<RelationshipSuccessRequest>()
|
||
.eq(RelationshipSuccessRequest::getMatchId, match.getId())
|
||
.eq(RelationshipSuccessRequest::getDeletedAt, 0)
|
||
.orderByDesc(RelationshipSuccessRequest::getCreatedAt)
|
||
.last("LIMIT 1"));
|
||
|
||
if (request == null) {
|
||
// 无pending请求，先创建
|
||
request = new RelationshipSuccessRequest();
|
||
request.setMatchId(match.getId());
|
||
request.setInitiatedBy(userId);
|
||
request.setStatus(Constants.SUCCESS_REQUEST_STATUS_PENDING);
|
||
request.setCreatedAt(Instant.now());
|
||
successRequestMapper.insert(request);
|
||
}
|
||
|
||
// 3. 检查是否已被对方拒绝
|
||
if (Constants.SUCCESS_REQUEST_STATUS_DECLINED.equals(request.getStatus())) {
|
||
throw new BusinessException(ApiResponseCode.CONFLICT, "牵手邀请已被拒绝");
|
||
}
|
||
|
||
// 4. 更新请求：记录本次确认人
|
||
request.setConfirmedBy(userId);
|
||
request.setResolvedAt(Instant.now());
|
||
|
||
// 5. 检查双方是否都已确认
|
||
boolean bothConfirmed = userId.equals(request.getInitiatedBy())
|
||
&& userId.equals(request.getConfirmedBy()) // 发起方也确认了
|
||
|| targetUserId.equals(request.getInitiatedBy())
|
||
&& userId.equals(request.getConfirmedBy()); // 对方发起，本方确认
|
||
|
||
// 更准确：查询是否有另一方的确认记录
|
||
RelationshipSuccessRequest otherRequest = successRequestMapper.selectOne(
|
||
new LambdaQueryWrapper<RelationshipSuccessRequest>()
|
||
.eq(RelationshipSuccessRequest::getMatchId, match.getId())
|
||
.eq(RelationshipSuccessRequest::getInitiatedBy, targetUserId)
|
||
.eq(RelationshipSuccessRequest::getStatus, Constants.SUCCESS_REQUEST_STATUS_CONFIRMED)
|
||
.eq(RelationshipSuccessRequest::getDeletedAt, 0));
|
||
|
||
if (otherRequest != null) {
|
||
// 双方都已确认 → 执行成功牵手
|
||
match.setStatus(Constants.MATCH_STATUS_SUCCESSFUL);
|
||
match.setSuccessfulAt(Instant.now());
|
||
matchMapper.updateById(match);
|
||
|
||
updateUserRelationshipStatus(userId, Constants.RELATIONSHIP_STATUS_MATCHED_SUCCESSFULLY);
|
||
updateUserRelationshipStatus(targetUserId, Constants.RELATIONSHIP_STATUS_MATCHED_SUCCESSFULLY);
|
||
stopRecommendations(userId);
|
||
stopRecommendations(targetUserId);
|
||
|
||
// 更新request状态
|
||
request.setStatus(Constants.SUCCESS_REQUEST_STATUS_CONFIRMED);
|
||
successRequestMapper.updateById(request);
|
||
if (otherRequest.getStatus() == null || !Constants.SUCCESS_REQUEST_STATUS_CONFIRMED.equals(otherRequest.getStatus())) {
|
||
otherRequest.setStatus(Constants.SUCCESS_REQUEST_STATUS_CONFIRMED);
|
||
successRequestMapper.updateById(otherRequest);
|
||
}
|
||
|
||
notificationService.sendAsync(userId, Constants.NOTIFICATION_TYPE_MATCH,
|
||
"成功牵手", "恭喜！您和对方已确认成功牵手，平台将暂停双方的婚恋推荐。",
|
||
"success", match.getId().toString());
|
||
notificationService.sendAsync(targetUserId, Constants.NOTIFICATION_TYPE_MATCH,
|
||
"成功牵手", "恭喜！您和对方已确认成功牵手，平台将暂停双方的婚恋推荐。",
|
||
"success", match.getId().toString());
|
||
|
||
saveAuditLog(userId, "SUCCESS_CONFIRM", "match", match.getId(), null, null);
|
||
saveAuditLog(targetUserId, "SUCCESS_CONFIRM", "match", match.getId(), null, null);
|
||
|
||
log.info("成功牵手确认: userId={}, targetUserId={}, matchId={}", userId, targetUserId, match.getId());
|
||
|
||
Map<String, Object> result = new HashMap<>();
|
||
result.put("matchId", match.getId());
|
||
result.put("status", "successful");
|
||
result.put("confirmedBy", userId);
|
||
result.put("confirmedAt", Instant.now());
|
||
return result;
|
||
} else {
|
||
// 只有一方确认，等待对方
|
||
request.setStatus(Constants.SUCCESS_REQUEST_STATUS_CONFIRMED);
|
||
successRequestMapper.updateById(request);
|
||
|
||
// 通知对方
|
||
notificationService.sendAsync(targetUserId, Constants.NOTIFICATION_TYPE_MATCH,
|
||
"成功牵手邀请", "您的匹配对象邀请您确认成功牵手，是否同意？",
|
||
"success_request", request.getId().toString());
|
||
|
||
Map<String, Object> result = new HashMap<>();
|
||
result.put("matchId", match.getId());
|
||
result.put("status", "waiting_for_other");
|
||
result.put("confirmedBy", userId);
|
||
return result;
|
||
}
|
||
}
|
||
```
|
||
|
||
**同时需要完善 `RelationshipStatusService` 中的其他TODO**:
|
||
|
||
```java
|
||
// pauseSearching() — 注入UserMapper并更新
|
||
@Transactional
|
||
public void pauseSearching(String userId) {
|
||
userMapper.update(null, new LambdaUpdateWrapper<User>()
|
||
.eq(User::getId, userId)
|
||
.set(User::getRelationshipStatus, Constants.RELATIONSHIP_STATUS_PAUSED)
|
||
.set(User::getRecommendationEnabled, false));
|
||
// ... 通知和审计
|
||
}
|
||
|
||
// resumeSearching() — 恢复状态
|
||
@Transactional
|
||
public void resumeSearching(String userId) {
|
||
userMapper.update(null, new LambdaUpdateWrapper<User>()
|
||
.eq(User::getId, userId)
|
||
.set(User::getRelationshipStatus, Constants.RELATIONSHIP_STATUS_SEARCHING)
|
||
.set(User::getRecommendationEnabled, true));
|
||
// ... 通知
|
||
}
|
||
|
||
// 注入UserMapper
|
||
private final UserMapper userMapper; // 添加到构造器参数
|
||
|
||
// updateUserRelationshipStatus() — 实现
|
||
private void updateUserRelationshipStatus(String userId, String status) {
|
||
userMapper.update(null, new LambdaUpdateWrapper<User>()
|
||
.eq(User::getId, userId)
|
||
.set(User::getRelationshipStatus, status));
|
||
}
|
||
|
||
// stopRecommendations() — 实现
|
||
private void stopRecommendations(String userId) {
|
||
userMapper.update(null, new LambdaUpdateWrapper<User>()
|
||
.eq(User::getId, userId)
|
||
.set(User::getRecommendationEnabled, false));
|
||
}
|
||
```
|
||
|
||
**验证**:
|
||
```java
|
||
@Test
|
||
void testSuccessRequiresBothConfirm() {
|
||
// A发起成功牵手请求 → 状态应为pending/waiting
|
||
// B确认后 → 状态应变为successful
|
||
// A再确认 → 不变（已经确认过）
|
||
}
|
||
|
||
@Test
|
||
void testSuccessDeclineCancels() {
|
||
// A发起 → B拒绝 → A再尝试确认 → 应返回409冲突
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 2小时
|
||
|
||
---
|
||
|
||
### P0-3: 修复 `AccountLifecycleService.checkCanWithdraw()` — 空查询导致注销失效
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/account/service/AccountLifecycleService.java`
|
||
**行号**: 141-143
|
||
|
||
**根因**: `new LambdaQueryWrapper<>() {}` 是无条件全表查询，`activeRegistrations` 始终很大，阻止所有用户注销。
|
||
|
||
**修复方案**:
|
||
|
||
```java
|
||
// 当前 (错误):
|
||
long activeRegistrations = registrationMapper.selectCount(
|
||
new LambdaQueryWrapper<>() {}).longValue();
|
||
|
||
// 修复后:
|
||
long activeRegistrations = registrationMapper.selectCount(
|
||
new LambdaQueryWrapper<ActivityRegistration>()
|
||
.eq(ActivityRegistration::getUserId, userId)
|
||
.in(ActivityRegistration::getStatus,
|
||
Constants.REGISTRATION_STATUS_PENDING,
|
||
Constants.REGISTRATION_STATUS_APPROVED));
|
||
```
|
||
|
||
**同时需要修复 `sanitizeUserData()` 中身份证脱敏TODO**:
|
||
|
||
```java
|
||
private void sanitizeUserData(String userId) {
|
||
// 脱敏手机号
|
||
User user = userMapper.selectById(userId);
|
||
if (user != null && user.getPhone() != null) {
|
||
String phone = user.getPhone();
|
||
if (phone.length() >= 4) {
|
||
user.setPhone(phone.substring(0, phone.length() - 4) + "****");
|
||
} else {
|
||
user.setPhone("****");
|
||
}
|
||
userMapper.updateById(user);
|
||
}
|
||
// 脱敏身份证（如有）
|
||
// TODO: 查询并脱敏 user_identities.id_number（加密存储的需解密后脱敏再重新加密）
|
||
log.info("敏感数据脱敏: userId={}", userId);
|
||
}
|
||
```
|
||
|
||
**验证**:
|
||
```python
|
||
# Python集成测试中验证
|
||
def test_account_close_allows_when_no_active_services():
|
||
# 创建无进行中的用户 → 应允许注销
|
||
# 创建有pending活动报名的用户 → 应拒绝注销
|
||
```
|
||
|
||
**预计工作量**: 30分钟
|
||
|
||
---
|
||
|
||
### P0-4: 修复 `RelationshipService.createMatch()` — 自动创建Conversation
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/relationship/service/RelationshipService.java`
|
||
**行号**: 204
|
||
|
||
**根因**: Match创建后没有建立Conversation，导致Match成功后用户无法立即开始聊天。
|
||
|
||
**修复方案**:
|
||
|
||
在 `RelationshipService` 中注入 `MessagingService`，然后在 `createMatch()` 中调用：
|
||
|
||
```java
|
||
@RequiredArgsConstructor
|
||
public class RelationshipService {
|
||
// ... 已有注入 ...
|
||
private final MessagingService messagingService; // 新增注入
|
||
}
|
||
|
||
private void createMatch(String userId, String targetUserId, String source) {
|
||
String userA = userId.compareTo(targetUserId) < 0 ? userId : targetUserId;
|
||
String userB = userId.compareTo(targetUserId) < 0 ? targetUserId : userId;
|
||
|
||
Match existing = matchMapper.findActiveMatch(userId, targetUserId).orElse(null);
|
||
if (existing != null) {
|
||
throw new RuntimeException("匹配已存在");
|
||
}
|
||
|
||
Match match = new Match();
|
||
match.setUserAId(userA);
|
||
match.setUserBId(userB);
|
||
match.setStatus(Constants.MATCH_STATUS_ACTIVE);
|
||
match.setSource(source);
|
||
match.setMatchedAt(Instant.now());
|
||
matchMapper.insert(match);
|
||
|
||
// 自动创建Conversation
|
||
try {
|
||
messagingService.createConversation(match.getId(), userId, targetUserId);
|
||
log.info("Match后自动创建会话: matchId={}, users={}", match.getId(), userId + "," + targetUserId);
|
||
} catch (Exception e) {
|
||
log.warn("创建会话失败，Match已创建但聊天不可用: matchId={}, error={}", match.getId(), e.getMessage());
|
||
// Match已写入DB，会话创建失败不影响Match完整性
|
||
}
|
||
}
|
||
```
|
||
|
||
**⚠️ 注意循环依赖风险**: `RelationshipService` 和 `MessagingService` 互相引用。
|
||
- `MessagingService` 已注入 `MatchMapper`（不引用 `RelationshipService`）
|
||
- `RelationshipService` 引用 `MessagingService`
|
||
|
||
这是单向依赖，不是循环依赖，可以正常工作。
|
||
|
||
**验证**:
|
||
```java
|
||
@Test
|
||
void testMatchAutoCreatesConversation() {
|
||
// A Like B → 双向Like → 自动创建Conversation
|
||
Map<String, Object> result = relationshipService.like(userA, userB);
|
||
assertTrue((Boolean) result.get("matchCreated"));
|
||
// 验证Conversation存在
|
||
Conversation conv = conversationMapper.selectOne(
|
||
new LambdaQueryWrapper<Conversation>().eq(Conversation::getMatchId, match.getId()));
|
||
assertNotNull(conv);
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 1小时
|
||
|
||
---
|
||
|
||
## P1 — 上线前建议修复（4项）
|
||
|
||
### P1-1: 补全 RecommendationEngine 双向Required过滤
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/match/service/RecommendationEngineService.java`
|
||
**行号**: 198-215
|
||
|
||
**根因**: 仅检查年龄Required，身高/地区/婚姻状况等全部跳过。
|
||
|
||
**修复方案**:
|
||
|
||
```java
|
||
private boolean checkBidirectionalRequired(UserPreference myPref, UserProfile candidate,
|
||
UserPreference targetPref, UserProfile myProfile) {
|
||
// 1. 年龄Required检查
|
||
if ("required".equals(myPref.getAgePriority())
|
||
&& myPref.getMinAge() != null && myPref.getMaxAge() != null) {
|
||
int candidateAge = calculateAge(candidate.getBirthDate());
|
||
if (candidateAge < myPref.getMinAge() || candidateAge > myPref.getMaxAge()) {
|
||
return false;
|
||
}
|
||
}
|
||
if ("required".equals(targetPref.getAgePriority())
|
||
&& targetPref.getMinAge() != null && targetPref.getMaxAge() != null) {
|
||
int myAge = calculateAge(myProfile.getBirthDate());
|
||
if (myAge < targetPref.getMinAge() || myAge > targetPref.getMaxAge()) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 2. 身高Required检查
|
||
if ("required".equals(myPref.getHeightPriority())
|
||
&& myPref.getMinHeightCm() != null && myPref.getMaxHeightCm() != null) {
|
||
if (candidate.getHeightCm() == null
|
||
|| candidate.getHeightCm() < myPref.getMinHeightCm()
|
||
|| candidate.getHeightCm() > myPref.getMaxHeightCm()) {
|
||
return false;
|
||
}
|
||
}
|
||
if ("required".equals(targetPref.getHeightPriority())
|
||
&& targetPref.getMinHeightCm() != null && targetPref.getMaxHeightCm() != null) {
|
||
if (myProfile.getHeightCm() == null
|
||
|| myProfile.getHeightCm() < targetPref.getMinHeightCm()
|
||
|| myProfile.getHeightCm() > targetPref.getMaxHeightCm()) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 3. 地区Required检查
|
||
if ("required".equals(myPref.getRegionPriority())
|
||
&& myPref.getRegionScope() != null && myPref.getRegionScope().isArray()) {
|
||
boolean inScope = false;
|
||
for (int i = 0; i < myPref.getRegionScope().size(); i++) {
|
||
if (myPref.getRegionScope().get(i).asText().equals(candidate.getRegionCode())) {
|
||
inScope = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!inScope) return false;
|
||
}
|
||
if ("required".equals(targetPref.getRegionPriority())
|
||
&& targetPref.getRegionScope() != null && targetPref.getRegionScope().isArray()) {
|
||
boolean inScope = false;
|
||
for (int i = 0; i < targetPref.getRegionScope().size(); i++) {
|
||
if (targetPref.getRegionScope().get(i).asText().equals(myProfile.getRegionCode())) {
|
||
inScope = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!inScope) return false;
|
||
}
|
||
|
||
// 4. 婚姻状况Required检查
|
||
if ("required".equals(myPref.getMaritalPriority())
|
||
&& myPref.getMaritalStatuses() != null && myPref.getMaritalStatuses().isArray()) {
|
||
boolean accepted = false;
|
||
for (int i = 0; i < myPref.getMaritalStatuses().size(); i++) {
|
||
if (myPref.getMaritalStatuses().get(i).asText().equals(candidate.getMaritalStatus())) {
|
||
accepted = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!accepted) return false;
|
||
}
|
||
if ("required".equals(targetPref.getMaritalPriority())
|
||
&& targetPref.getMaritalStatuses() != null && targetPref.getMaritalStatuses().isArray()) {
|
||
boolean accepted = false;
|
||
for (int i = 0; i < targetPref.getMaritalStatuses().size(); i++) {
|
||
if (targetPref.getMaritalStatuses().get(i).asText().equals(myProfile.getMaritalStatus())) {
|
||
accepted = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!accepted) return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
```
|
||
|
||
**验证**:
|
||
```java
|
||
@Test
|
||
void testHeightRequiredFiltered() {
|
||
// A要求身高≥170cm (required)，B身高165cm
|
||
// B不应出现在A的推荐中
|
||
}
|
||
|
||
@Test
|
||
void testMaritalStatusRequiredFiltered() {
|
||
// A要求离异 (required)，B未婚
|
||
// B不应出现在A的推荐中
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 2小时
|
||
|
||
---
|
||
|
||
### P1-2: Admin Web添加路由级权限守卫
|
||
|
||
**文件**: `admin-web/src/router/index.ts`
|
||
**行号**: 29-35
|
||
|
||
**根因**: 路由守卫只有登录检查，没有权限检查，任何登录用户可访问所有管理页面。
|
||
|
||
**修复方案**:
|
||
|
||
```typescript
|
||
// 路由权限映射
|
||
const ROUTE_PERMISSIONS: Record<string, string[]> = {
|
||
'/users': ['user.view'],
|
||
'/users/detail': ['user.view', 'user.sensitive.view'],
|
||
'/organizations': ['organization.manage'],
|
||
'/operators': ['permission.manage'],
|
||
'/review': ['review.view', 'review.process'],
|
||
'/activities/interests': ['activity.review_registration'],
|
||
'/risk/reports': ['risk.report.view', 'risk.report.process'],
|
||
'/appeals': ['risk.report.process'],
|
||
'/analytics': ['analytics.view'],
|
||
'/audit': ['user.view'],
|
||
}
|
||
|
||
router.beforeEach((to) => {
|
||
const authStore = useAuthStore()
|
||
|
||
// 1. 登录检查
|
||
if (to.path !== '/login' && !authStore.isLoggedIn) {
|
||
return { path: '/login', query: { redirect: to.fullPath } }
|
||
}
|
||
|
||
// 2. 权限检查（仅对需权限的路由）
|
||
const requiredPerms = ROUTE_PERMISSIONS[to.path]
|
||
if (requiredPerms) {
|
||
const userPerms = authStore.permissions
|
||
const hasPermission = requiredPerms.every(perm => userPerms.includes(perm))
|
||
if (!hasPermission) {
|
||
ElMessage.error('您没有访问该页面的权限')
|
||
return { path: '/dashboard' }
|
||
}
|
||
}
|
||
|
||
document.title = to.meta.title ? `${to.meta.title} - 丹阳公益婚恋` : '丹阳公益婚恋'
|
||
})
|
||
```
|
||
|
||
**同时在 `MainLayout.vue` 中根据权限隐藏菜单项**:
|
||
```typescript
|
||
// 菜单权限映射
|
||
const MENU_PERMISSIONS: Record<string, string[]> = {
|
||
'用户管理': ['user.view'],
|
||
'资料审核': ['review.view'],
|
||
'举报中心': ['risk.report.view'],
|
||
// ...
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 1.5小时
|
||
|
||
---
|
||
|
||
### P1-3: 实现消息速率限制
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/messaging/safety/MessageRiskService.java`
|
||
**行号**: 83-87
|
||
|
||
**根因**: 消息发送无速率限制，恶意用户可以无限发送骚扰消息。
|
||
|
||
**修复方案**:
|
||
|
||
```java
|
||
@Value("${rate-limit.max-requests-per-window:100}")
|
||
private int maxRequestsPerWindow;
|
||
|
||
@Value("${rate-limit.window-seconds:60}")
|
||
private int windowSeconds;
|
||
|
||
@Autowired
|
||
private StringRedisTemplate redisTemplate;
|
||
|
||
public boolean isRateLimited(String userId) {
|
||
String key = "rate_limit:msg:" + userId;
|
||
Long count = redisTemplate.opsForValue().increment(key);
|
||
if (count != null && count == 1) {
|
||
redisTemplate.expire(key, windowSeconds, TimeUnit.SECONDS);
|
||
}
|
||
return count != null && count > maxRequestsPerWindow;
|
||
}
|
||
```
|
||
|
||
**在 `application.yml` 中添加配置**:
|
||
```yaml
|
||
rate-limit:
|
||
max-requests-per-window: 20 # 每人每分钟20条消息
|
||
window-seconds: 60
|
||
```
|
||
|
||
**预计工作量**: 30分钟
|
||
|
||
---
|
||
|
||
### P1-4: HealthController接入实际依赖检查
|
||
|
||
**文件**: `backend/src/main/java/com/danyang/match/platform/shared/controller/HealthController.java`
|
||
|
||
**修复方案**:
|
||
```java
|
||
@GetMapping("/health")
|
||
public ApiResponse<Map<String, Object>> health() {
|
||
Map<String, Object> details = new HashMap<>();
|
||
|
||
// 数据库检查
|
||
try {
|
||
healthIndicator.check(); // Spring Boot Actuator的DataSourceHealthIndicator
|
||
details.put("database", Map.of("status", "up"));
|
||
} catch (Exception e) {
|
||
details.put("database", Map.of("status", "down", "error", e.getMessage()));
|
||
}
|
||
|
||
// Redis检查
|
||
try {
|
||
redisTemplate.opsForValue().set("_health_check_", "ok", 1, TimeUnit.SECONDS);
|
||
String val = redisTemplate.opsForValue().get("_health_check_");
|
||
details.put("redis", Map.of("status", "up".equals(val) ? "up" : "down"));
|
||
} catch (Exception e) {
|
||
details.put("redis", Map.of("status", "down", "error", e.getMessage()));
|
||
}
|
||
|
||
boolean allUp = !details.values().stream()
|
||
.filter(m -> m instanceof Map)
|
||
.map(m -> ((Map<?,?>)m).get("status"))
|
||
.anyMatch("down"::equals);
|
||
|
||
return ApiResponse.ok(Map.of(
|
||
"status", allUp ? "UP" : "DEGRADED",
|
||
"details", details
|
||
));
|
||
}
|
||
```
|
||
|
||
**预计工作量**: 30分钟
|
||
|
||
---
|
||
|
||
## P2 — 后续迭代（5项）
|
||
|
||
### P2-1: 修复 `RecommendationService` 字段声明顺序
|
||
**文件**: `RecommendationService.java:102,114`
|
||
**操作**: 将 `private final UserProfileService userProfileService;` 移到类顶部与其他 `@Autowired` 字段一起
|
||
|
||
### P2-2: 删除未使用的中文命名方法
|
||
**文件**: `RelationshipService.java:331`
|
||
**操作**: 删除 `private void 解除Match()` 方法（已被 `unmatch()` 替代且未被调用）
|
||
|
||
### P2-3: 完善 AuditLog reason JSON序列化
|
||
**文件**: `AccountLifecycleService.java:196`
|
||
**操作**: 使用 `ObjectMapper.writeValueAsString(Map.of("reason", reason))` 替代字符串拼接
|
||
|
||
### P2-4: 实现图片上传Signed URL
|
||
**文件**: `ChatController.java:66-77, PhotoService.java:51`
|
||
**操作**: 接入MinIO Presigned URL生成
|
||
|
||
### P2-5: 小程序TypeScript迁移
|
||
**操作**: 将45个`.js`页面迁移到`.ts`，添加类型定义
|
||
|
||
---
|
||
|
||
## 验证计划
|
||
|
||
### 单元测试补充
|
||
| 测试文件 | 新增测试用例 | 覆盖不变量 |
|
||
|----------|-------------|-----------|
|
||
| `RelationshipServiceTest.java` | block后不可聊天、双确认成功牵手、并发Like单Match | INV-003, INV-004, INV-005 |
|
||
| `MessagingServiceTest.java` | isBlocked验证、无Match不可发消息 | INV-002, INV-003 |
|
||
| `RecommendationEngineServiceTest.java` | 身高Required过滤、地区Required过滤 | INV-001 |
|
||
| `AccountLifecycleServiceTest.java` | 无进行中服务可注销、有pending活动不可注销 | INV-008 |
|
||
|
||
### 集成测试补充（Python）
|
||
```python
|
||
# tests/invariant_integration_test.py 新增:
|
||
def test_inv003_block_stops_chat(token, user_a, user_b, conn):
|
||
"""Block后A不可向B发消息"""
|
||
|
||
def test_inv005_success_requires_double_confirm(token, user_a, user_b, conn):
|
||
"""成功牵手需双方确认"""
|
||
|
||
def test_inv001_height_required_filtered(token, user_a, user_b, conn):
|
||
"""身高Required过滤验证"""
|
||
```
|
||
|
||
### 冒烟测试清单（API）
|
||
```bash
|
||
# 核心流程冒烟测试
|
||
curl -X POST /api/v1/auth/wechat/login -d '{"code":"xxx"}' # 登录
|
||
curl -H "Authorization: Bearer $TOKEN" /api/v1/recommendations # 推荐
|
||
curl -X POST /api/v1/relations/UserB/like # Like
|
||
curl -X POST /api/v1/relations/UserB/block # Block
|
||
curl -X POST /api/v1/messages/conversations/{id}/send -d '{}' # 发消息(需先Match)
|
||
curl -X POST /api/v1/relationship/success/request # 发起成功牵手
|
||
curl -X POST /api/v1/relationship/success/confirm # 确认成功牵手
|
||
curl -X PUT /api/v1/relationship/pause # 暂停寻找
|
||
curl -X PUT /api/v1/account/withdraw # 注销账号
|
||
```
|
||
|
||
---
|
||
|
||
## 修复优先级总结
|
||
|
||
| 优先级 | 数量 | 预计总工时 | 阻塞项 |
|
||
|--------|------|-----------|--------|
|
||
| P0 | 4项 | ~4小时 | 全部 |
|
||
| P1 | 4项 | ~4小时 | 无 |
|
||
| P2 | 5项 | ~8小时 | 无 |
|
||
| **合计** | **13项** | **~16小时** | **4项P0阻塞** |
|
||
|
||
**建议执行顺序**:
|
||
1. 先修复全部P0（可并行）
|
||
2. P0验证通过后，修复P1
|
||
3. P1验证通过后，进入UAT阶段
|
||
4. P2可纳入V1.1迭代
|
||
|
||
---
|
||
*最后更新: 2026-09-01 | 基于 CODE_REVIEW_REPORT.md*
|