From c461210b12a036899000e1d7c0a93501033664a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BB=84=E8=87=AA=E8=BE=BE?= <980324341@qq.com>
Date: Fri, 6 Nov 2026 00:13:35 +0800
Subject: [PATCH] =?UTF-8?q?fix(=E4=BB=BB=E5=8A=A1=E8=BF=9B=E5=BA=A6):=20?=
=?UTF-8?q?=E5=89=94=E9=99=A4=E9=9D=9E=E5=BD=92=E5=B1=9E=E4=BB=BB=E5=8A=A1?=
=?UTF-8?q?=E6=97=B6=E7=82=B9=E5=90=8D=20taskId=E2=80=94=E2=80=94=E9=82=A3?=
=?UTF-8?q?=20512=20=E6=9D=A1=E3=80=8C=E8=AF=B7=E6=B1=82=201=20=E4=B8=AA?=
=?UTF-8?q?=20=E5=91=BD=E4=B8=AD=200=20=E4=B8=AA=E3=80=8D=E4=BB=A5?=
=?UTF-8?q?=E5=89=8D=E8=AF=BB=E4=B8=8D=E5=87=BA=E6=98=AF=E5=93=AA=E4=B8=80?=
=?UTF-8?q?=E5=8D=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
现网形状(2026-11-05 主机A 只读取证,43 分钟日志窗):`userId=1228` 打了 **512 条**
「进度查询剔除非归属任务 … 请求 1 个 命中 0 个」,同一账号每 5 秒轮询一支取不到结果的任务,
界面一直转圈。旧文案只有两个数,于是三种完全不同的事实共用同一行日志:
· 拿别人的 taskId 在轮询(越权探测形状,该报警);
· 网页端换号后仍用旧缓存(该清缓存);
· 单已删而客户端按旧 id 空转(B21「在跑的任务列表没掉」那一族)。
读不出是哪一种,就没人能修——所以本笔只补「点名被剔的 taskId」这一件事,
判据与语义一字未动:剔除仍是安全边界,归属仍只由那一条带 `user_id` 的 SQL 决定。
刻意**不加**第二次归因查询、也**不把**归属条件挪进 Java:
① 挪条件=踩铁律 20「先取页再在 Java 里 filter」那一族(取页与过滤的先后一旦脱钩,
饿死某一分页的缺陷会在这里重生);② 为一条日志在轮询热路径多打一次往返不划算;
③ 本仓 catch 总量棘轮 `CatchSilenceRatchetTest`(STRICT_TOTAL=1069)实测把
「多包一层兜底 try」直接判红——第一版就是因此回炉的。
拿到 id 之后「这单存不存在、现在归谁」是一条主键查询就能定死的事,留给取证侧。
点名有上界(ATTRIBUTION_PREVIEW_LIMIT=12):一次批量轮询不许刷出一行超长日志。
三格新判据:id 必须出现在行里、干净轮询恰好一次查询且零日志、预览被截断在 12 个;
另把 `ProgressQueryOwnershipOutletTest` 的取证口径写回「一次 selectList」并注释清楚
归因只是日志、不是第二道过滤。
---
.../service/TaskProgressOwnershipSupport.java | 31 ++++-
.../ProgressQueryOwnershipOutletTest.java | 2 +
...kProgressOwnershipDropAttributionTest.java | 123 ++++++++++++++++++
3 files changed, 153 insertions(+), 3 deletions(-)
create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipDropAttributionTest.java
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipSupport.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipSupport.java
index adaa2c56b..ea176697a 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipSupport.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipSupport.java
@@ -7,7 +7,9 @@ import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
+import java.util.ArrayList;
import java.util.List;
+import java.util.stream.Collectors;
/**
* 进度查询的归属过滤(2026-09 全维度审查修复)。
@@ -28,6 +30,9 @@ public class TaskProgressOwnershipSupport {
private final FileTaskMapper fileTaskMapper;
+ /** 归因文案里最多点名几个被剔除的 taskId(再多就只报数量,防止一次批量轮询刷出一行长日志)。 */
+ static final int ATTRIBUTION_PREVIEW_LIMIT = 12;
+
/**
* 过滤出属于 userId 的任务 id。
*
@@ -57,10 +62,30 @@ public class TaskProgressOwnershipSupport {
.map(FileTaskEntity::getId)
.toList();
if (owned.size() != normalized.size()) {
- // 非归属任务出现在请求里:可能是越权尝试,也可能是前端历史遗留缓存了别人的 taskId
- log.warn("[progress-ownership] 进度查询剔除非归属任务 userId={} 请求 {} 个 命中 {} 个",
- userId, normalized.size(), owned.size());
+ warnDropped(userId, normalized, owned);
}
return owned;
}
+
+ /**
+ * 剔除必须能被归因(2026-11-05 现网:主机A 43 分钟的日志窗里 {@code userId=1228} 打了 512 条
+ * 「请求 1 个 命中 0 个」,界面一直转圈,而我们连「它要的是哪个 taskId」都读不出来)。
+ *
+ *
三种完全不同的事实此前共用同一行日志:拿别人的 taskId 在轮询(越权探测)、网页端换号后
+ * 仍用旧缓存、单已删而客户端按旧 id 空转(B21「在跑的任务列表没掉」那一族)。读不出是哪一种,
+ * 就没人能修。
+ *
+ * 这里只点名 id:不多打一次归因查询,也不把归属条件从 SQL 挪进 Java——归属必须由那一条
+ * 带 {@code user_id} 的查询说了算(铁律 20「先取页再过滤」之戒同形,且热路径不该为一条日志多一次
+ * 往返)。拿到 id 之后,「这单存不存在、现在归谁」是一条主键查询就能定死的事,留给取证侧。
+ */
+ private void warnDropped(Long userId, List requested, List owned) {
+ List missing = new ArrayList<>(requested);
+ missing.removeAll(owned);
+ String preview = missing.stream().limit(ATTRIBUTION_PREVIEW_LIMIT)
+ .map(String::valueOf)
+ .collect(Collectors.joining(","));
+ log.warn("[progress-ownership] 进度查询剔除非归属任务 userId={} 请求 {} 个 命中 {} 个 剔除 taskId={}",
+ userId, requested.size(), owned.size(), preview);
+ }
}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/common/security/ProgressQueryOwnershipOutletTest.java b/backend-java/src/test/java/com/nanri/aiimage/common/security/ProgressQueryOwnershipOutletTest.java
index 0b7ed188e..f6c113409 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/common/security/ProgressQueryOwnershipOutletTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/common/security/ProgressQueryOwnershipOutletTest.java
@@ -231,6 +231,8 @@ class ProgressQueryOwnershipOutletTest {
// 所以必须把 wrapper 抓出来,钉住 user_id 这一列和会话推出来的那个值。
ArgumentCaptor> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
+ // 剔除路径只多打一行**日志**(把被剔的 taskId 点名,见 TaskProgressOwnershipDropAttributionTest),
+ // 不多打一次查询:归属条件必须一直只由这唯一一支带 user_id 的查询决定。
verify(mapper).selectList(captor.capture());
captor.getValue().getSqlSegment(); // MP 惯例:先求值一次才铺出参数
assertThat(captor.getValue().getSqlSegment()).contains("user_id");
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipDropAttributionTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipDropAttributionTest.java
new file mode 100644
index 000000000..9dcc05367
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskProgressOwnershipDropAttributionTest.java
@@ -0,0 +1,123 @@
+package com.nanri.aiimage.modules.task.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import java.util.List;
+import java.util.stream.LongStream;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 「进度查询剔除非归属任务」必须能被归因(2026-11-05 现网驱动)。
+ *
+ * 现网形状:主机A 一个 25,000 行的日志窗(43 分钟)里 {@code userId=1228} 打了 512 条
+ * 「请求 1 个 命中 0 个」——同一账号每 5 秒轮询一支取不到结果的任务,界面一直转圈。旧文案只有
+ * 两个数,于是三种完全不同的事实共用同一行日志:拿别人的 taskId(越权探测)、网页端换号后仍用
+ * 旧缓存、单已删而客户端按旧 id 空转(B21 那一族)。读不出是哪一种就没人能修,所以本类钉的是
+ * 「读得出来」这件事,而不是任何判定语义。
+ *
+ * 三条判据缺一不可:
+ *
+ * - 剔除语义不变(这是安全边界,不许为了归因放行别人的单);
+ * - 热路径不多一次查询——归属永远只由那一条带 {@code user_id} 的 SQL 决定
+ * (铁律 20「先取页再在 Java 里 filter」之戒同形);
+ * - 点名有上界,一次批量轮询不许刷出一行超长日志。
+ *
+ */
+class TaskProgressOwnershipDropAttributionTest {
+
+ private static final Long SESSION_USER = 1228L;
+
+ private FileTaskMapper fileTaskMapper;
+ private TaskProgressOwnershipSupport support;
+ private ListAppender appender;
+
+ @BeforeAll
+ static void initMybatisPlusTableInfo() {
+ TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
+ FileTaskEntity.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ fileTaskMapper = mock(FileTaskMapper.class);
+ support = new TaskProgressOwnershipSupport(fileTaskMapper);
+ Logger logger = (Logger) LoggerFactory.getLogger(TaskProgressOwnershipSupport.class);
+ appender = new ListAppender<>();
+ appender.start();
+ logger.addAppender(appender);
+ }
+
+ @AfterEach
+ void tearDown() {
+ ((Logger) LoggerFactory.getLogger(TaskProgressOwnershipSupport.class)).detachAppender(appender);
+ }
+
+ private static FileTaskEntity row(long id) {
+ FileTaskEntity entity = new FileTaskEntity();
+ entity.setId(id);
+ entity.setUserId(SESSION_USER);
+ return entity;
+ }
+
+ private String logged() {
+ return appender.list.stream().map(ILoggingEvent::getFormattedMessage)
+ .reduce("", (a, b) -> a + "\n" + b);
+ }
+
+ @Test
+ void droppedTaskIdsAreNamedSoTheShapeIsReadable() {
+ when(fileTaskMapper.selectList(any())).thenReturn(List.of(row(101L)));
+
+ List kept = support.filterOwnedTaskIds(List.of(101L, 202L, 303L), SESSION_USER);
+
+ assertThat(kept).containsExactly(101L); // 剔除本身是安全边界,语义一字不动
+ String line = logged();
+ assertThat(line).contains("userId=" + SESSION_USER)
+ .contains("请求 3 个 命中 1 个")
+ .contains("202").contains("303");
+ }
+
+ @Test
+ void cleanPollLogsNothingAndPaysExactlyOneQuery() {
+ when(fileTaskMapper.selectList(any()))
+ .thenReturn(List.of(row(101L), row(102L)));
+
+ List kept = support.filterOwnedTaskIds(List.of(101L, 102L), SESSION_USER);
+
+ assertThat(kept).containsExactly(101L, 102L);
+ verify(fileTaskMapper, times(1)).selectList(any());
+ assertThat(appender.list).isEmpty();
+ }
+
+ @Test
+ void attributionPreviewIsCapped() {
+ when(fileTaskMapper.selectList(any())).thenReturn(List.of());
+ List requested = LongStream.rangeClosed(1, 40).boxed().toList();
+
+ List kept = support.filterOwnedTaskIds(requested, SESSION_USER);
+
+ assertThat(kept).isEmpty();
+ String line = logged();
+ assertThat(line).contains("1,2,3");
+ assertThat(line).doesNotContain(",40"); // 只点名前 ATTRIBUTION_PREVIEW_LIMIT 个
+ long named = line.substring(line.indexOf("剔除 taskId=")).split(",").length;
+ assertThat(named).isEqualTo(TaskProgressOwnershipSupport.ATTRIBUTION_PREVIEW_LIMIT);
+ }
+}