From cdbe247dbf69c7af6b8755a4938af46e97378394 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=BB=84=E8=87=AA=E8=BE=BE?= <980324341@qq.com> Date: Mon, 19 Oct 2026 19:45:05 +0800 Subject: [PATCH] =?UTF-8?q?fix(=E5=93=81=E7=89=8C=E6=A3=80=E6=B5=8B):=20?= =?UTF-8?q?=E6=95=B4=E6=89=B9=E7=A1=AE=E5=AE=9A=E6=80=A7=E6=8B=92=E7=BB=9D?= =?UTF-8?q?=E6=97=B6=E7=9F=AD=E8=B7=AF=E5=90=8C=E6=89=B9=E5=85=B6=E4=BD=99?= =?UTF-8?q?=E5=93=81=E7=89=8C=E7=9A=84=E9=87=8D=E8=AF=95=E9=98=B6=E6=A2=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 2026-10-19 现网取证:品牌库代理套餐过期(供应商回 {"code":-1,"message":"套餐不存在"}) → 16890 代理池恒为 0、一次代理都没挂上 → 全部直连打 WIPO branddb 被整片 Forbidden。 这是每次必然失败的确定性拒绝,而重试阶梯照旧跑满:单品牌 10 轮含最长 10 秒的递增等待 约 45~65 秒,全是白烧;更糟的是它烧的是整批共用的 90 秒预算,于是后面的品牌还没开始 就被掐在 attempt=2/10——日志里成片的「整批耗时预算用尽」与「重试耗尽判定查询失败」 其实是同一件事的两面。 判据保守,三条都硬: - 只有「跑满整条阶梯 + 最后一轮仍是 query_faild_data」才置标志;被预算或短路掐断的 轮次不算证据(ladderCompleted 专门为此而设) - 请求全程抛异常(response==null)不触发:那可能是本品牌特有的超时形态,拿它当 「上游整体在拒绝」会误伤同批真能查回来的品牌 - 首轮始终执行,短路最坏情形的上界就是每品牌一次请求 结论语义不变:短路只省重试,每个品牌仍各自判查询失败、仍交调用方降级。 本类是外观专利 / collect_data / similar-asin 三模块共用的出口,用户口径明确要求 放在共用层(收益最大、影响面也最大),故三处同时生效。 BrandCheckClientTest 10 例(新增 2)+ AppearancePatent*/TaskServiceWiringSlice 全绿。 变异检验:把 upstreamRejecting.set(true) 废掉后新用例确实变红,非装饰性断言。 在独立 worktree(HEAD 干净副本)完成编译与测试——共享工作树此刻有另一路会话的 PublishTaskService.java 半成品(缺 AbstractFileTaskPipeline 的 import,主源码编译不过), 未触碰、未暂存。 --- .../brand/client/BrandCheckClient.java | 31 +++++++++- .../brand/client/BrandCheckClientTest.java | 61 +++++++++++++++++++ 2 files changed, 90 insertions(+), 2 deletions(-) diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/brand/client/BrandCheckClient.java b/backend-java/src/main/java/com/nanri/aiimage/modules/brand/client/BrandCheckClient.java index 5541c9083..d31a9ff20 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/brand/client/BrandCheckClient.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/brand/client/BrandCheckClient.java @@ -24,6 +24,7 @@ import java.util.concurrent.CompletionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicBoolean; @Component @Slf4j @@ -163,9 +164,12 @@ public class BrandCheckClient { // 103.5 秒(taskId 28599),客户端重试预算耗尽后中止了整个采集。预算用尽即停止重试。 Map outcomes = new LinkedHashMap<>(); List> futures = new ArrayList<>(brands.size()); + // 一次批量一份判定:本批里只要有一个品牌跑满阶梯仍被判查询失败,其余品牌就不再 + // 各自烧完整条重试阶梯(见 checkOneBrand 的短路分支)。 + AtomicBoolean upstreamRejecting = new AtomicBoolean(false); for (String brand : brands) { futures.add(CompletableFuture.supplyAsync( - () -> checkOneBrand(brand, strategy, deadlineNanos), checkExecutor)); + () -> checkOneBrand(brand, strategy, deadlineNanos, upstreamRejecting), checkExecutor)); } for (int index = 0; index < brands.size(); index++) { outcomes.put(brands.get(index), awaitOutcome(futures.get(index))); @@ -178,19 +182,35 @@ public class BrandCheckClient { return budgetMillis > 0L ? System.nanoTime() + budgetMillis * 1_000_000L : Long.MAX_VALUE; } - private BrandCheckOutcome checkOneBrand(String brand, String strategy, long deadlineNanos) { + private BrandCheckOutcome checkOneBrand(String brand, String strategy, long deadlineNanos, + AtomicBoolean upstreamRejecting) { int attempts = Math.max(1, properties.getRetryTimes()); BrandCheckResponse response = null; Exception lastFailure = null; + // 只有「把整条重试阶梯走完」才算拿到"上游在确定性拒绝"的证据。 + // 被预算或短路掐断的轮次不是证据,拿它去短路同批其余品牌会把偶发抖动放大成整批放弃。 + boolean ladderCompleted = true; for (int attempt = 1; attempt <= attempts; attempt++) { // 预算用尽就不再重试,按查询失败收尾。只掐「重试」不打断已发出的请求, // 故最坏耗时 ≈ 预算 + 一次请求的读超时;首轮始终执行,避免上游只是慢一点时被误降级。 if (attempt > 1 && System.nanoTime() >= deadlineNanos) { + ladderCompleted = false; log.warn("[brand-check] 整批耗时预算用尽,停止重试 brand={} attempt={}/{} lastErr={}", brand, attempt, attempts, lastFailure == null ? "query_faild_data 持续非空" : lastFailure.getMessage()); break; } + // 同批已有品牌走完整个阶梯、每一轮都被判查询失败 ⇒ 上游在确定性拒绝,本品牌别再烧 + // 等待与整批预算。2026-10-19 现网:品牌库代理套餐过期 → 16890 全部直连 WIPO → + // 整片 Forbidden,单品牌 10 轮含递增等待约 45~65 秒全是白烧,而它烧掉的正是后面 + // 那些品牌的机会(日志里 attempt=2/10「整批耗时预算用尽」就是同一件事的另一面)。 + // 首轮不掐:那一次请求本身就是"本品牌是否真的不可查"的证据,也是短路最坏情形的上界。 + if (attempt > 1 && upstreamRejecting.get()) { + ladderCompleted = false; + log.warn("[brand-check] 同批已确认上游确定性拒绝,本品牌停止重试 brand={} attempt={}/{}", + brand, attempt, attempts); + break; + } try { response = check(brand, strategy); } catch (Exception ex) { @@ -215,6 +235,13 @@ public class BrandCheckClient { sleepBeforeRetry(retryDelayMillis); } } + // 只在"跑满整条阶梯 + 最后一轮仍是查询失败"时短路同批其余品牌。 + // 请求全程抛异常(response==null)不触发:那可能是本品牌特有的超时/网络形态, + // 拿它当"上游整体在拒绝"会误伤同批真正还能查回来的品牌。 + if (ladderCompleted && response != null + && !nullToEmpty(response.getQueryFaildData()).isEmpty()) { + upstreamRejecting.set(true); + } log.warn("[brand-check] 重试耗尽判定查询失败 brand={} attempts={} lastErr={}", brand, attempts, lastFailure == null ? "query_faild_data 持续非空" : lastFailure.getMessage()); diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/brand/client/BrandCheckClientTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/brand/client/BrandCheckClientTest.java index 137dce93d..895edf813 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/brand/client/BrandCheckClientTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/brand/client/BrandCheckClientTest.java @@ -97,6 +97,67 @@ class BrandCheckClientTest { } } + /** + * 整批都被上游确定性拒绝时,后面的品牌不该各自烧完一条重试阶梯。 + * + *

2026-10-19 现网:品牌库代理套餐过期 → 16890 全部直连 WIPO → 整片 Forbidden, + * 每个品牌都要走完 10 轮(含最长 10 秒的递增等待,单品牌约 45~65 秒)才判失败, + * 而它烧掉的正是整批 90 秒预算——日志里成片的 attempt=2/10「整批耗时预算用尽」就是这么来的。 + */ + @Test + void wholeBatchDeterministicRejectionStopsBurningRetryLaddersForLaterBrands() throws Exception { + AtomicInteger requests = new AtomicInteger(); + HttpServer server = startBrandCheckServer(exchange -> { + requests.incrementAndGet(); + respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[\"x\"]}"); + }); + try { + BrandCheckClient client = newClient(server, 3); + List brands = List.of("b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"); + + BrandCheckClient.BrandCheckBatchResult result = client.checkAll(brands, "Terms"); + + assertThat(requests.get()).as("首轮始终执行:短路不许让任何品牌一次都没被查过") + .isGreaterThanOrEqualTo(brands.size()); + assertThat(requests.get()).as("确认上游确定性拒绝后,其余品牌不再各自跑满阶梯") + .isLessThan(brands.size() * 3); + assertThat(result.queryFaildData()).as("短路只省重试,不改结论:8 个品牌仍全部判查询失败") + .hasSize(brands.size()); + } finally { + server.stop(0); + } + } + + /** + * 短路判据必须保守:只有"跑满整条阶梯仍每轮查询失败"才成立。 + * 成功品牌首轮就返回、从不置标志,所以同一批里的个别失败品牌要照旧拿满它的重试机会—— + * 否则一次孤立故障就会把同批别的品牌的恢复机会一起掐掉。 + */ + @Test + void successfulBrandsNeverTripTheShortCircuit() throws Exception { + AtomicInteger badAttempts = new AtomicInteger(); + HttpServer server = startBrandCheckServer(exchange -> { + String body = new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8); + if (body.contains("bad")) { + badAttempts.incrementAndGet(); + respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[\"bad\"]}"); + } else { + respond(exchange, "{\"faild_data\":[],\"query_faild_data\":[]}"); + } + }); + try { + BrandCheckClient client = newClient(server, 3); + + BrandCheckClient.BrandCheckBatchResult result = + client.checkAll(List.of("ok1", "bad", "ok2", "ok3"), "Terms"); + + assertThat(badAttempts.get()).as("同批有成功品牌时,失败品牌仍跑满整条阶梯").isEqualTo(3); + assertThat(result.queryFaildData()).containsExactly("bad"); + } finally { + server.stop(0); + } + } + private BrandCheckClient newClient(HttpServer server, int retryTimes) { BrandCheckProperties props = new BrandCheckProperties(); props.setBaseUrl("http://127.0.0.1:" + server.getAddress().getPort());