From 005cda9379dae72c9f095bfd445825a8f8904014 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BB=84=E8=87=AA=E8=BE=BE?= <980324341@qq.com>
Date: Sat, 3 Oct 2026 00:22:07 +0800
Subject: [PATCH] =?UTF-8?q?feat(=E9=87=87=E9=9B=86=E6=95=B0=E6=8D=AE):=20?=
=?UTF-8?q?=E5=93=81=E7=89=8C=E6=A3=80=E6=B5=8B=E5=A4=B1=E8=B4=A5=E8=87=AA?=
=?UTF-8?q?=E5=8A=A8=E8=A1=A5=E6=B5=8B=E9=98=9F=E5=88=97=EF=BC=8C=E9=99=90?=
=?UTF-8?q?=E6=B5=81=E7=AA=97=E5=8F=A3=E5=90=8E=E8=87=AA=E5=8A=A8=E9=87=8D?=
=?UTF-8?q?=E6=9F=A5=E5=B9=B6=E8=A1=A5=E7=BB=93=E6=9E=9C=EF=BC=88V140?=
=?UTF-8?q?=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
WIPO 限流窗口内 queryFailed 的品牌按任务排队(biz_collectdata_brand_recheck,同任务同品牌幂等),Scheduler 按指数退避自动补测:补出无侵权→行补进结果文件,判出侵权→落无效品牌表,连续耗尽→EXHAUSTED 并通知。只存品牌不存行,注入按 payload_hash 幂等。
---
backend-java/docs/migration-inventory.md | 10 +-
.../CollectDataBrandRecheckProperties.java | 50 ++++
.../aiimage/config/PropertiesConfig.java | 2 +-
.../mapper/CollectDataBrandRecheckMapper.java | 9 +
.../entity/CollectDataBrandRecheckEntity.java | 37 +++
.../CollectDataBrandRecheckInjector.java | 215 ++++++++++++++
.../CollectDataBrandRecheckScheduler.java | 267 ++++++++++++++++++
.../CollectDataBrandRecheckService.java | 203 +++++++++++++
.../service/CollectDataService.java | 9 +-
.../util/CollectDataBrandBatchFilter.java | 3 +-
.../service/NotificationDispatchService.java | 41 +++
.../db/V140__collectdata_brand_recheck.sql | 39 +++
.../service/CollectDataActivateGuardTest.java | 3 +-
.../CollectDataBrandRecheckInjectorTest.java | 209 ++++++++++++++
.../CollectDataBrandRecheckSchedulerTest.java | 251 ++++++++++++++++
.../CollectDataBrandRecheckServiceTest.java | 215 ++++++++++++++
.../CollectDataDeleteConsistencyTest.java | 3 +-
.../CollectDataServiceTxBoundaryTest.java | 1 +
.../CollectDataStorageCallCountTest.java | 3 +-
...otificationDispatchServiceRecheckTest.java | 82 ++++++
.../DuplicateSubmissionContractTest.java | 1 +
21 files changed, 1642 insertions(+), 11 deletions(-)
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/config/CollectDataBrandRecheckProperties.java
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/mapper/CollectDataBrandRecheckMapper.java
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/model/entity/CollectDataBrandRecheckEntity.java
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckInjector.java
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckScheduler.java
create mode 100644 backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckService.java
create mode 100644 backend-java/src/main/resources/db/V140__collectdata_brand_recheck.sql
create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckInjectorTest.java
create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckSchedulerTest.java
create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckServiceTest.java
create mode 100644 backend-java/src/test/java/com/nanri/aiimage/modules/notification/service/NotificationDispatchServiceRecheckTest.java
diff --git a/backend-java/docs/migration-inventory.md b/backend-java/docs/migration-inventory.md
index 8890b64ff..8cab5331e 100644
--- a/backend-java/docs/migration-inventory.md
+++ b/backend-java/docs/migration-inventory.md
@@ -5,10 +5,10 @@
## 概览
-- 版本化迁移文件数:**138**(`src/main/resources/db/V*.sql`,其中整数版本 137 个 + 小版本 V25_1)
-- 整数版本范围:**V1..V139**,其中 V132/V133 为已退役空号(见下),其余连续
+- 版本化迁移文件数:**139**(`src/main/resources/db/V*.sql`,其中整数版本 138 个 + 小版本 V25_1)
+- 整数版本范围:**V1..V140**,其中 V132/V133 为已退役空号(见下),其余连续
- 历史遗留小版本:**V25_1__shop_manage_group_bind_user.sql**(Flyway 语义 25.1,紧跟在 V25 之后、V26 之前执行,属历史命名,保留)
-- 最新版本:**V139__asin_result_cache.sql**
+- 最新版本:**V140__collectdata_brand_recheck.sql**
- 重复版本:无
- 迁移命名:全部符合 `V<整数>(_<子版本>)?__<描述>.sql`,无空格
@@ -20,9 +20,9 @@
本地曾存在 `V132__web_config_add_is_latest.sql`、`V133__hide_redundant_indexes_invisible.sql`,与另一分支已在生产落库的 V134/V135 冲突。因 Flyway 未开启 `out-of-order`,把任何迁移编到 132/133 会在启动期报 "resolved migration not applied";因此这两条改为 **V136/V137**,132/133 永久退役,不可回填。
-后续新增迁移从 **V140** 起取号(只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红)。
+后续新增迁移从 **V141** 起取号(只认"当前最大值 + 1",不要为还没写出来的迁移预留号段——预留会在 1..max 里留洞,`integerVersionsSequentialFromOne` 会红)。
-原先挂在待办里的"V137 冗余索引 DROP"迁移计划取 V139,该号已被 `V139__asin_result_cache.sql` 占用,顺延到 V140。
+原先挂在待办里的"V137 冗余索引 DROP"迁移计划取 V139,该号已被 `V139__asin_result_cache.sql` 占用,顺延到 V140;V140 已被品牌补测队列表 `V140__collectdata_brand_recheck.sql` 落用。
## 约束
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/CollectDataBrandRecheckProperties.java b/backend-java/src/main/java/com/nanri/aiimage/config/CollectDataBrandRecheckProperties.java
new file mode 100644
index 000000000..b0e485ad7
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/CollectDataBrandRecheckProperties.java
@@ -0,0 +1,50 @@
+package com.nanri.aiimage.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * 采集数据品牌检测失败补测(requeue)配置:
+ * 上游 WIPO 限流窗口过去后,把任务里品牌检测「查询失败」的品牌自动重查并补进结果。
+ *
+ *
节奏设计对标 2026-10-02 的真实限流事件(持续 11 小时):首轮延后 {@link #firstDelayMinutes}
+ * 分钟避开任务收尾,失败后按 {@link #intervalBaseMinutes} 起指数退避(30m→1h→2h→4h→8h→16h→32h
+ * 封顶),共 {@link #maxAttempts} 轮实测,合计覆盖约 31 小时的上游抖动窗口。
+ */
+@Data
+@ConfigurationProperties(prefix = "aiimage.collect-data.brand-recheck")
+public class CollectDataBrandRecheckProperties {
+
+ /** 补测总开关:关闭后不再入队、调度器跳过所有轮次(应急降噪)。 */
+ private boolean enabled = true;
+
+ /** 调度轮询间隔(毫秒),默认 5 分钟;与通知扫描同节拍,双实例由分布式锁互斥。 */
+ private long scanIntervalMs = 5 * 60 * 1000L;
+
+ /** 调度首次执行延迟(毫秒),默认 2 分钟,避开启动阶段。 */
+ private long scanInitialDelayMs = 2 * 60 * 1000L;
+
+ /** 入队后到首次补测的延后分钟数:避开任务收尾与短时限流窗口(客户端同步重试已覆盖)。 */
+ private int firstDelayMinutes = 30;
+
+ /** 退避基准分钟数:第 n 次失败后等待 intervalBaseMinutes × 2^(n-1),封顶 16 小时。 */
+ private int intervalBaseMinutes = 30;
+
+ /**
+ * 单个品牌最大实测轮次(含首次)。默认 7:失败后等待 30m/1h/2h/4h/8h/16h,
+ * 首测 + 6 次重测合计覆盖约 31 小时;用尽后条目 EXHAUSTED,不再自动重试。
+ */
+ private int maxAttempts = 7;
+
+ /** 单轮最多取出的到期条目数(跨任务合计),防止限流恢复瞬间的补流洪峰。 */
+ private int roundBatchSize = 200;
+
+ /**
+ * 轮内熔断阈值:本轮已实测品牌中「仍查询失败」占比超过该值(且实测数 ≥
+ * {@link #failRateMinProbe})时,中止本轮剩余条目——上游仍在限流时不必逐批捶它。
+ */
+ private double failRateThreshold = 0.5;
+
+ /** 熔断判定的最小实测品牌数:样本太小不判熔断,避免单品牌偶发失败触发整轮中止。 */
+ private int failRateMinProbe = 3;
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/PropertiesConfig.java b/backend-java/src/main/java/com/nanri/aiimage/config/PropertiesConfig.java
index c4eb42352..d76db05bf 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/config/PropertiesConfig.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/config/PropertiesConfig.java
@@ -4,6 +4,6 @@ import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Configuration;
@Configuration
-@EnableConfigurationProperties({OssProperties.class, TransientStorageProperties.class, StorageProperties.class, BrandProgressProperties.class, DeleteBrandProgressProperties.class, BrandCheckProperties.class, ZiniaoProperties.class, ModuleCleanupProperties.class, TaskPressureProperties.class, TaskImageCacheCleanupProperties.class, AppearancePatentProperties.class, SimilarAsinProperties.class, ImageVideoProperties.class, InstanceRoutingProperties.class, CapacityPlanProperties.class, UserSecretProperties.class, NotificationProperties.class, DeviceLogOssProperties.class})
+@EnableConfigurationProperties({OssProperties.class, TransientStorageProperties.class, StorageProperties.class, BrandProgressProperties.class, DeleteBrandProgressProperties.class, BrandCheckProperties.class, ZiniaoProperties.class, ModuleCleanupProperties.class, TaskPressureProperties.class, TaskImageCacheCleanupProperties.class, AppearancePatentProperties.class, SimilarAsinProperties.class, ImageVideoProperties.class, InstanceRoutingProperties.class, CapacityPlanProperties.class, UserSecretProperties.class, NotificationProperties.class, DeviceLogOssProperties.class, CollectDataBrandRecheckProperties.class})
public class PropertiesConfig {
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/mapper/CollectDataBrandRecheckMapper.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/mapper/CollectDataBrandRecheckMapper.java
new file mode 100644
index 000000000..bbc7c3a8c
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/mapper/CollectDataBrandRecheckMapper.java
@@ -0,0 +1,9 @@
+package com.nanri.aiimage.modules.collectdata.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.nanri.aiimage.modules.collectdata.model.entity.CollectDataBrandRecheckEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface CollectDataBrandRecheckMapper extends BaseMapper {
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/model/entity/CollectDataBrandRecheckEntity.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/model/entity/CollectDataBrandRecheckEntity.java
new file mode 100644
index 000000000..4793aeb8a
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/model/entity/CollectDataBrandRecheckEntity.java
@@ -0,0 +1,37 @@
+package com.nanri.aiimage.modules.collectdata.model.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 品牌检测失败补测队列表(V140):分片回传时把「查询失败」的品牌按任务入队,
+ * 调度器在上游限流窗口过去后重查,出结论的行补进结果文件 / 无效品牌表。
+ * 只存品牌不存行——行数据留在 chunk 全量 payload(RustFS),注入时按品牌回读。
+ */
+@Data
+@TableName("biz_collectdata_brand_recheck")
+public class CollectDataBrandRecheckEntity {
+
+ public static final String STATUS_PENDING = "PENDING";
+ public static final String STATUS_INJECTED = "INJECTED";
+ public static final String STATUS_REJECTED = "REJECTED";
+ public static final String STATUS_EXHAUSTED = "EXHAUSTED";
+
+ @TableId(type = IdType.AUTO)
+ private Long id;
+ private Long taskId;
+ private String taskNo;
+ private Long userId;
+ /** 归一化小写品牌,与 CollectDataBrandBatchFilter.normalizeBrand 同口径。 */
+ private String brand;
+ private String status;
+ private Integer attemptCount;
+ private String lastError;
+ private LocalDateTime nextAttemptAt;
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckInjector.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckInjector.java
new file mode 100644
index 000000000..ec1a4179b
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckInjector.java
@@ -0,0 +1,215 @@
+package com.nanri.aiimage.modules.collectdata.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.nanri.aiimage.modules.asincache.service.AsinResultCacheService;
+import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataBatchQuery;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataInvalidAsinBatchWriter;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailCodec;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataResultItemBatchWriter;
+import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
+import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
+import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 补测结论注入器:把一轮补测里出结论的品牌落回该任务的数据链。
+ *
+ * 行为与实时分片回传(CollectDataService.submitResult)同语义,只是发生在任务收尾之后:
+ *
+ * - CLEAN(无侵权命中)→ 行按 chunk 回读,先过 dedupe/无效品牌复查
+ * (补测窗口内该 ASIN 可能已被其他任务采走,first-writer-wins),
+ * 再写 chunk 级明细对象(key 带 recheck- 前缀,不覆盖原 chunk 明细)并
+ * {@code upsertAccepted} 进结果——重复注入靠 payload_hash 跳过语义幂等;
+ * - REJECTED(判出侵权命中)→ 行落无效品牌表(与实时 rejected 路径一致),不进结果;
+ * - 注入的行同步写 ASIN 跨任务缓存(resolveCacheCountry 同口径:只收单国家任务)。
+ *
+ *
+ * 结果文件不在这里重建:注入完成后由调度器 {@code enqueueAssembleResult} 走既有
+ * 异步装配任务(worker 会按 biz_task_result_item 重算并持久化 finalRowCount)。
+ * 单 chunk 明细对象写失败即整组抛出:已落库的行靠下轮重放的幂等性收敛,不丢不重。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class CollectDataBrandRecheckInjector {
+
+ public static final String MODULE_TYPE = "COLLECT_DATA";
+
+ /** 补测结论:无侵权命中(行进结果) / 侵权命中(行落无效品牌表)。 */
+ public enum RecheckVerdict { CLEAN, REJECTED }
+
+ /** 一轮注入的落地结果:resultId 供调度器触发结果文件重建;两计数为 0 表示无实际写入。 */
+ public record GroupOutcome(Long resultId, int acceptedRows, int rejectedRows) {
+
+ public static final GroupOutcome EMPTY = new GroupOutcome(null, 0, 0);
+ }
+
+ private final TaskChunkMapper taskChunkMapper;
+ private final FileResultMapper fileResultMapper;
+ private final CollectDataBatchQuery collectDataBatchQuery;
+ private final CollectDataResultDetailCodec resultDetailCodec;
+ private final CollectDataResultItemBatchWriter resultItemBatchWriter;
+ private final CollectDataInvalidAsinBatchWriter invalidAsinBatchWriter;
+ private final TransientPayloadStorageService transientPayloadStorageService;
+ private final AsinResultCacheService asinResultCacheService;
+ private final ObjectMapper objectMapper;
+ /** 只为复用 resolveCacheCountry 的单国家判定口径(缓存键缺国家会把 DE 价当 US 结论)。 */
+ private final CollectDataService collectDataService;
+
+ /**
+ * 把补测结论落回任务:按品牌回读 chunk 全量 payload,分流 CLEAN/REJECTED。
+ * 结论映射键必须与队列表 brand 同口径({@link CollectDataBrandBatchFilter#normalizeBrand})。
+ */
+ public GroupOutcome apply(FileTaskEntity task, Map verdicts) {
+ if (task == null || task.getId() == null || verdicts == null || verdicts.isEmpty()) {
+ return GroupOutcome.EMPTY;
+ }
+ Set cleanBrands = brandsWith(verdicts, RecheckVerdict.CLEAN);
+ Set rejectedBrands = brandsWith(verdicts, RecheckVerdict.REJECTED);
+ if (cleanBrands.isEmpty() && rejectedBrands.isEmpty()) {
+ return GroupOutcome.EMPTY;
+ }
+ FileResultEntity result = fileResultMapper.selectOne(new LambdaQueryWrapper()
+ .eq(FileResultEntity::getTaskId, task.getId())
+ .eq(FileResultEntity::getModuleType, MODULE_TYPE)
+ .orderByDesc(FileResultEntity::getId)
+ .last("limit 1"));
+ if (result == null) {
+ log.warn("[brand-recheck] 任务无结果记录,跳过注入 taskId={}", task.getId());
+ return GroupOutcome.EMPTY;
+ }
+ List chunks = taskChunkMapper.selectList(new LambdaQueryWrapper()
+ .eq(TaskChunkEntity::getTaskId, task.getId())
+ .eq(TaskChunkEntity::getModuleType, MODULE_TYPE)
+ .orderByAsc(TaskChunkEntity::getChunkIndex)
+ .orderByAsc(TaskChunkEntity::getId));
+
+ int acceptedRows = 0;
+ int rejectedRows = 0;
+ List acceptedKept = new ArrayList<>();
+ for (TaskChunkEntity chunk : chunks) {
+ List rows = readChunkRows(chunk);
+ if (rows.isEmpty()) {
+ continue;
+ }
+ if (!rejectedBrands.isEmpty()) {
+ List chunkRejected = rowsOfBrands(rows, rejectedBrands);
+ if (!chunkRejected.isEmpty()) {
+ // INSERT IGNORE 幂等:重复补测同品牌不会在无效品牌表翻倍
+ rejectedRows += invalidAsinBatchWriter.writeBatch(chunkRejected);
+ }
+ }
+ if (cleanBrands.isEmpty()) {
+ continue;
+ }
+ List chunkClean = rowsOfBrands(rows, cleanBrands);
+ if (chunkClean.isEmpty()) {
+ continue;
+ }
+ // 复查去重/无效品牌:补测窗口内该 ASIN 可能已被其他任务采走(first-writer-wins)
+ CollectDataBatchQuery.FilterResult filtered = collectDataBatchQuery.filter(chunkClean);
+ if (filtered.kept().isEmpty()) {
+ log.info("[brand-recheck] 补测行全部被去重/无效过滤,不注入 taskId={} rows={}",
+ task.getId(), chunkClean.size());
+ continue;
+ }
+ String detailJson = resultDetailCodec.encodeChunk(filtered.kept());
+ // key 带 recheck- 前缀:不覆盖原 chunk 的明细对象;同 chunk 重复注入覆盖同一对象(幂等)
+ String storedDetail = transientPayloadStorageService.storeResultPayload(
+ MODULE_TYPE, task.getId(), chunk.getScopeHash(),
+ "recheck-chunk-" + chunk.getChunkIndex(), detailJson);
+ CollectDataResultItemBatchWriter.UpsertCounts counts = resultItemBatchWriter.upsertAccepted(
+ task.getId(), result.getId(), chunk.getScopeKey(), chunk.getChunkIndex(),
+ filtered.kept(), storedDetail);
+ acceptedRows += counts.newlyInserted();
+ acceptedKept.addAll(filtered.kept());
+ }
+ if (!acceptedKept.isEmpty()) {
+ writeAsinCache(task, acceptedKept);
+ }
+ if (acceptedRows > 0 || rejectedRows > 0) {
+ log.info("[brand-recheck] 补测结论注入完成 taskId={} 新增结果行={} 判定无效行={} 品牌(净/败)={}/{}",
+ task.getId(), acceptedRows, rejectedRows, cleanBrands.size(), rejectedBrands.size());
+ }
+ return new GroupOutcome(result.getId(), acceptedRows, rejectedRows);
+ }
+
+ private Set brandsWith(Map verdicts, RecheckVerdict verdict) {
+ Set out = new HashSet<>();
+ for (Map.Entry entry : verdicts.entrySet()) {
+ if (entry.getValue() == verdict && entry.getKey() != null && !entry.getKey().isBlank()) {
+ out.add(entry.getKey());
+ }
+ }
+ return out;
+ }
+
+ private List rowsOfBrands(List rows, Set brands) {
+ List out = new ArrayList<>();
+ for (CollectDataResultRowVo row : rows) {
+ if (row == null) {
+ continue;
+ }
+ String brand = CollectDataBrandBatchFilter.normalizeBrand(row.getBrand());
+ if (!brand.isBlank() && brands.contains(brand)) {
+ out.add(row);
+ }
+ }
+ return out;
+ }
+
+ /** 单 chunk 全量行回读(与 CollectDataService.streamRawRows 的 chunk 内逻辑一致)。 */
+ private List readChunkRows(TaskChunkEntity chunk) {
+ try {
+ String payloadJson = transientPayloadStorageService.resolvePayload(
+ chunk.getPayloadJson(), "read collect data raw chunk failed");
+ if (payloadJson == null || payloadJson.isBlank()) {
+ return List.of();
+ }
+ List values = objectMapper.readValue(payloadJson,
+ new TypeReference>() {
+ });
+ if (values == null) {
+ return List.of();
+ }
+ List out = new ArrayList<>(values.size());
+ for (CollectDataResultRowVo value : values) {
+ if (value != null) {
+ out.add(value);
+ }
+ }
+ return out;
+ } catch (Exception ex) {
+ // 单 chunk 丢失只跳不炸:其余 chunk 的行照常注入,该 chunk 的行留待人工
+ log.warn("[brand-recheck] chunk 全量行回读失败,跳过该 chunk taskId={} chunkIndex={} err={}",
+ chunk.getTaskId(), chunk.getChunkIndex(), ex.getMessage());
+ return List.of();
+ }
+ }
+
+ /** 补测出的行同样"顺带贡献结论"进 ASIN 缓存;写失败不影响注入结果。 */
+ private void writeAsinCache(FileTaskEntity task, List rows) {
+ try {
+ asinResultCacheService.writeCollectDataRows(
+ collectDataService.resolveCacheCountry(task), String.valueOf(task.getId()), rows);
+ } catch (RuntimeException ex) {
+ log.warn("[brand-recheck] ASIN 缓存写入失败,不影响注入 taskId={} err={}",
+ task.getId(), ex.getMessage());
+ }
+ }
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckScheduler.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckScheduler.java
new file mode 100644
index 000000000..e84bc6c31
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataBrandRecheckScheduler.java
@@ -0,0 +1,267 @@
+package com.nanri.aiimage.modules.collectdata.service;
+
+import com.nanri.aiimage.common.service.DistributedJobLockService;
+import com.nanri.aiimage.config.CollectDataBrandRecheckProperties;
+import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
+import com.nanri.aiimage.modules.collectdata.model.entity.CollectDataBrandRecheckEntity;
+import com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckInjector.RecheckVerdict;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter;
+import com.nanri.aiimage.modules.notification.service.NotificationDispatchService;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
+import com.nanri.aiimage.modules.task.service.TaskFileJobService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 品牌检测失败补测调度器:把补测队列(biz_collectdata_brand_recheck)里到期的
+ * PENDING 条目按任务聚组,批量重查品牌检测,出结论的行交给
+ * {@link CollectDataBrandRecheckInjector} 落回结果文件 / 无效品牌表。
+ *
+ * 轮内熔断:本轮实测品牌中「仍查询失败」占比超阈值(样本 ≥ failRateMinProbe)时
+ * 中止本轮剩余条目并顺延(不计尝试次数)——上游仍在限流时不必逐批捶它,
+ * 2026-10-02 WIPO 连续 11 小时 Forbidden 的形状下,逐批重试只会白白消耗预算。
+ *
+ *
双实例经 Redis 分布式锁互斥;任务级写并发经任务分布式锁互斥(补测发生在
+ * 任务终态之后,锁主要挡结果文件装配与注入的竞态)。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class CollectDataBrandRecheckScheduler {
+
+ private static final String LOCK_NAME = "collectdata-brand-recheck";
+ private static final String MODULE_TYPE = CollectDataBrandRecheckInjector.MODULE_TYPE;
+ private static final String STATUS_SUCCESS = "SUCCESS";
+ private static final String STATUS_FAILED = "FAILED";
+ private static final long TASK_LOCK_WAIT_MILLIS = 2000L;
+
+ private final CollectDataBrandRecheckService recheckService;
+ private final CollectDataBrandRecheckProperties properties;
+ private final FileTaskMapper fileTaskMapper;
+ private final BrandCheckClient brandCheckClient;
+ private final CollectDataBrandRecheckInjector injector;
+ private final NotificationDispatchService notificationDispatchService;
+ private final TaskDistributedLockService taskDistributedLockService;
+ private final TaskFileJobService taskFileJobService;
+ private final DistributedJobLockService distributedJobLockService;
+
+ @Scheduled(fixedDelayString = "${aiimage.collect-data.brand-recheck.scan-interval-ms:300000}",
+ initialDelayString = "${aiimage.collect-data.brand-recheck.scan-initial-delay-ms:120000}")
+ public void scan() {
+ if (!properties.isEnabled()) {
+ log.info("[brand-recheck] 补测已关闭(brand-recheck.enabled=false),跳过本轮");
+ return;
+ }
+ var lock = distributedJobLockService.tryLock(LOCK_NAME, Duration.ofMinutes(5));
+ if (lock == null) {
+ log.info("[brand-recheck] 另一实例持有补测锁,跳过本轮");
+ return;
+ }
+ try (lock) {
+ runRound();
+ } catch (Exception ex) {
+ log.warn("[brand-recheck] 补测轮异常终止 err={}", ex.getMessage(), ex);
+ }
+ }
+
+ /** 一轮补测:取出到期条目、按任务聚组逐组处理;熔断触发后剩余组整组顺延。 */
+ void runRound() {
+ List due = recheckService.listDue(
+ LocalDateTime.now(), properties.getRoundBatchSize());
+ if (due.isEmpty()) {
+ log.info("[brand-recheck] 无到期的补测条目");
+ return;
+ }
+ Map> groups = new LinkedHashMap<>();
+ for (CollectDataBrandRecheckEntity entry : due) {
+ groups.computeIfAbsent(entry.getTaskId(), key -> new ArrayList<>()).add(entry);
+ }
+ log.info("[brand-recheck] 本轮开始 条目={} 任务组={}", due.size(), groups.size());
+
+ int probedBrands = 0;
+ int stillFailedBrands = 0;
+ boolean tripped = false;
+ for (Map.Entry> group : groups.entrySet()) {
+ if (tripped) {
+ recheckService.postponeWithoutAttempt(group.getValue(),
+ properties.getIntervalBaseMinutes());
+ continue;
+ }
+ GroupRound round = processTaskGroup(group.getKey(), group.getValue());
+ probedBrands += round.probed();
+ stillFailedBrands += round.stillFailed();
+ if (probedBrands >= Math.max(1, properties.getFailRateMinProbe())
+ && stillFailedBrands >= probedBrands * properties.getFailRateThreshold()) {
+ tripped = true;
+ log.warn("[brand-recheck] 轮内熔断:实测 {} 个品牌仍失败 {},上游疑仍在限流,剩余条目顺延",
+ probedBrands, stillFailedBrands);
+ }
+ }
+ log.info("[brand-recheck] 本轮结束 实测品牌={} 仍失败={} 熔断={}", probedBrands, stillFailedBrands, tripped);
+ }
+
+ /** 处理单个任务组;返回轮计数(实测品牌数 / 仍失败品牌数),异常按全失败计。 */
+ private GroupRound processTaskGroup(Long taskId, List entries) {
+ FileTaskEntity task = fileTaskMapper.selectById(taskId);
+ if (task == null) {
+ // 任务已删除(清理 SPI 回收):条目无主,直接收口避免永久占坑
+ for (CollectDataBrandRecheckEntity entry : entries) {
+ recheckService.markExhausted(entry, "任务不存在(可能已被清理)");
+ }
+ return new GroupRound(0, 0);
+ }
+ if (!STATUS_SUCCESS.equals(task.getStatus()) && !STATUS_FAILED.equals(task.getStatus())) {
+ // 任务仍在跑:补测只做终态之后的兜底,顺延不计数(避免与分片重提竞态)
+ recheckService.postponeWithoutAttempt(entries, properties.getFirstDelayMinutes());
+ return new GroupRound(0, 0);
+ }
+ TaskDistributedLockService.LockHandle taskLock =
+ taskDistributedLockService.acquire(MODULE_TYPE, taskId, TASK_LOCK_WAIT_MILLIS);
+ if (taskLock == null) {
+ log.info("[brand-recheck] 任务锁竞争,本轮顺延(不计数) taskId={}", taskId);
+ recheckService.postponeWithoutAttempt(entries, properties.getFirstDelayMinutes());
+ return new GroupRound(0, 0);
+ }
+ try (taskLock) {
+ return checkAndApply(task, entries);
+ }
+ }
+
+ private GroupRound checkAndApply(FileTaskEntity task, List entries) {
+ List brands = distinctBrands(entries);
+ BrandCheckClient.BrandCheckBatchResult check;
+ try {
+ check = brandCheckClient.checkAll(brands, "Terms");
+ } catch (RuntimeException ex) {
+ // 整批检查异常(网络/服务级故障):按实测失败计次退避,下轮重试
+ log.warn("[brand-recheck] 批量品牌检测异常,按失败计次 taskId={} brands={} err={}",
+ task.getId(), brands.size(), ex.getMessage());
+ for (CollectDataBrandRecheckEntity entry : entries) {
+ recheckService.markAttempted(entry, ex.getMessage());
+ }
+ return new GroupRound(brands.size(), brands.size());
+ }
+
+ Set faildBrands = normalizeVerdicts(check == null ? null : check.faildData());
+ Set queryFailedBrands = normalizeVerdicts(check == null ? null : check.queryFaildData());
+ Map verdicts = new LinkedHashMap<>();
+ List cleanEntries = new ArrayList<>();
+ List rejectedEntries = new ArrayList<>();
+ List stillFailedEntries = new ArrayList<>();
+ for (CollectDataBrandRecheckEntity entry : entries) {
+ String brand = CollectDataBrandBatchFilter.normalizeBrand(entry.getBrand());
+ if (faildBrands.contains(brand)) {
+ verdicts.put(brand, RecheckVerdict.REJECTED);
+ rejectedEntries.add(entry);
+ } else if (queryFailedBrands.contains(brand)) {
+ stillFailedEntries.add(entry);
+ } else {
+ verdicts.put(brand, RecheckVerdict.CLEAN);
+ cleanEntries.add(entry);
+ }
+ }
+
+ CollectDataBrandRecheckInjector.GroupOutcome outcome = CollectDataBrandRecheckInjector.GroupOutcome.EMPTY;
+ boolean applyFailed = false;
+ if (!verdicts.isEmpty()) {
+ try {
+ outcome = injector.apply(task, verdicts);
+ } catch (RuntimeException ex) {
+ // 注入失败(如结果明细写批次失败):出结论的品牌留队重放(注入幂等),按实测失败计次
+ applyFailed = true;
+ log.warn("[brand-recheck] 补测结论注入失败,整组留队重放 taskId={} err={}",
+ task.getId(), ex.getMessage());
+ }
+ }
+ if (applyFailed) {
+ for (CollectDataBrandRecheckEntity entry : entries) {
+ recheckService.markAttempted(entry, "补测结论注入失败,留队重放");
+ }
+ return new GroupRound(brands.size(), brands.size());
+ }
+
+ int exhaustedThisRound = 0;
+ for (CollectDataBrandRecheckEntity entry : cleanEntries) {
+ recheckService.markInjected(entry);
+ }
+ for (CollectDataBrandRecheckEntity entry : rejectedEntries) {
+ recheckService.markRejected(entry);
+ }
+ for (CollectDataBrandRecheckEntity entry : stillFailedEntries) {
+ if (recheckService.markAttempted(entry, "query_faild_data 持续非空")) {
+ // updateQuietly 失败时下轮按 PENDING 重放,不算收口
+ if (CollectDataBrandRecheckEntity.STATUS_EXHAUSTED.equals(entry.getStatus())) {
+ exhaustedThisRound++;
+ }
+ }
+ }
+
+ if (outcome.acceptedRows() > 0) {
+ // 结果行有新增 → 复用既有异步装配重建结果文件(worker 重算并持久化 finalRowCount)
+ taskFileJobService.enqueueAssembleResult(task.getId(), MODULE_TYPE, outcome.resultId(),
+ "task:" + task.getId());
+ }
+ notificationDispatchService.pushRecheckOutcome(task.getUserId(), task.getId(), MODULE_TYPE,
+ task.getTaskNo(), outcome.acceptedRows(), outcome.rejectedRows(),
+ stillFailedEntries.size(), exhaustedThisRound);
+ log.info("[brand-recheck] 任务组完成 taskId={} 品牌={} 净={} 败={} 仍失败={} 收口={} 新增结果行={} 判定无效行={}",
+ task.getId(), brands.size(), cleanEntries.size(), rejectedEntries.size(),
+ stillFailedEntries.size(), exhaustedThisRound, outcome.acceptedRows(), outcome.rejectedRows());
+ return new GroupRound(brands.size(), stillFailedEntries.size());
+ }
+
+ private List distinctBrands(List entries) {
+ Set brands = new LinkedHashSet<>();
+ for (CollectDataBrandRecheckEntity entry : entries) {
+ String brand = CollectDataBrandBatchFilter.normalizeBrand(entry.getBrand());
+ if (!brand.isBlank()) {
+ brands.add(brand);
+ }
+ }
+ return new ArrayList<>(brands);
+ }
+
+ /** 服务端返回的结论对象(字符串或 {brand,...} 映射)→ 归一化品牌集合,与过滤器同口径。 */
+ private Set normalizeVerdicts(List