From 68b19f22b33c6914a1eb93a191d72a727acb0aac 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, 2 Oct 2026 23:41:28 +0800 Subject: [PATCH] =?UTF-8?q?perf(=E8=B4=A7=E6=BA=90):=20=E5=88=86=E7=B1=BB?= =?UTF-8?q?=E5=8C=B9=E9=85=8D=E6=89=B9=E9=87=8F=E5=88=86=E5=9D=97=EF=BC=8C?= =?UTF-8?q?=E7=B1=BB=E7=9B=AE=E6=A0=91=E6=96=87=E6=9C=AC=E6=95=B4=E6=89=B9?= =?UTF-8?q?=E5=8F=AA=E9=9A=8F=E4=B8=80=E6=AC=A1=E8=AF=B7=E6=B1=82=E5=8F=91?= =?UTF-8?q?=E9=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 分类判定按 llmCategoryBatchSize(默认10)分块、每块一次 LLM 调用:formatTwoLevels 的两层类目树此前随每行请求重复发送,是分类链路最大的 token 开销(10 行/块省约九成)。块内缺编号/坏编号的行、整块调用失败的行回退逐行单调用,行级失败语义不变。env: AIIMAGE_SIMILAR_ASIN_LLM_CATEGORY_BATCH_SIZE,设 0/1 回退旧行为。 --- .../aiimage/config/SimilarAsinProperties.java | 8 + .../service/SimilarAsinLlmService.java | 189 +++++++++++++++++- .../src/main/resources/application.yml | 1 + .../service/SimilarAsinLlmServiceTest.java | 151 +++++++++++++- 4 files changed, 344 insertions(+), 5 deletions(-) diff --git a/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java b/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java index 3adc6d18c..a4c944804 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java +++ b/backend-java/src/main/java/com/nanri/aiimage/config/SimilarAsinProperties.java @@ -170,6 +170,14 @@ public class SimilarAsinProperties { private int llmMaxTokens = 64000; private int llmConnectTimeoutMillis = 10000; private int llmReadTimeoutMillis = 600000; + /** + * 批量分类的行数(2026-10-02):>1 且批内多行时,分类判定按该行数分块、每块一次 + * LLM 调用 —— 类目树文本(formatTwoLevels,数千字符量级)整块只随请求发送一次, + * 不再随每行重复发送(这是分类链路最大的 token 开销,10 行/块可省约九成)。 + * 缺编号/解析失败的行、整块调用失败的行回退逐行单调用,行级失败语义不变。 + * 设 0/1 回退逐行旧行为。 + */ + private int llmCategoryBatchSize = 10; /** * 首次尝试读超时(毫秒):上游偶发单请求不应答,首查用更短预算快速失败后重试。 * 与外观专利同口径:那边一批 5 张图后单次耗时按倍数涨,60s 会误杀正常慢响应, diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java index c5099a96e..fb68698b9 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmService.java @@ -28,6 +28,7 @@ import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; @@ -158,6 +159,19 @@ public class SimilarAsinLlmService { + "}"; private static final String USER_TEXT_CATEGORY = "产品标题:%s\n产品属性:%s\n类目:%s"; + + /** + * 批量分类的输出契约追加段(2026-10-02):一次请求判定整块行,类目树文本 + * (formatTwoLevels,数千字符量级)只随请求发送一次 —— 逐行请求把同一棵树 + * 重复发送 N 遍,是分类链路里最大的 token 开销。判定语义与单件模式完全一致。 + */ + private static final String CATEGORY_BATCH_ENVELOPE = + "\n\n# 批量模式(本次输入包含多件待分类商品)\n" + + "输入按编号 [1]、[2]… 列出多件商品,备选类目列表对全部商品共用。" + + "对每件商品**分别**按上述规则判定一级与二级类目,禁止遗漏编号、禁止把多件商品合并成一条。\n" + + "只输出一个 JSON 对象:{\"items\":[{\"i\":1,\"first\":\"一级名称\",\"second\":\"二级名称或无\"}]}\n" + + "* i=商品编号;first/second=按上述规则对该件商品的判定,回退机制与单件模式一致(某层匹配不到填\"无\")。\n" + + "* 严禁伪造类目名称,first/second 必须逐字来自候选列表。输出必须严格遵循 JSON 语法。"; private static final String USER_TEXT_CONFORM = "标题:%s\nSKU:%s\n违规类目产品:一级类目:%s ,二级类目:%s,三级类目:%s"; private static final String USER_TEXT_COMPARE = "ASIN:%s\n所属类目:%s\n产品信息:%s"; @@ -199,15 +213,20 @@ public class SimilarAsinLlmService { ExecutorService executor = rowExecutor(); // 类目树整批加载一次供本批所有行复用:逐行现拼两层要 27 次 SQL/行,比省下的那次 LLM 调用更贵。 CategoryTree categoryTree = categorySwitch ? CategoryTree.load(productCategoryService.list()) : null; + // 批量分类预计算:树文本整批只随一次请求发送(llmCategoryBatchSize>1 且多行时启用), + // 关闭或单行时为 null,走逐行调用旧路径。见 matchCategoryPathsBatched。 + CategoryPrepass prepass = categorySwitch ? matchCategoryPathsBatched(rows, categoryTree, apiKey) : null; // 行级处理跑在 worker 线程:把「当前任务归属用户」快照带过去,供 LLM 请求计次 SecretUsageContext.Context usageContext = SecretUsageContext.snapshot(); List> futures = new ArrayList<>(rows.size()); - for (SimilarAsinResultRowDto row : rows) { + for (int i = 0; i < rows.size(); i++) { + SimilarAsinResultRowDto row = rows.get(i); + int rowIndex = i; futures.add(CompletableFuture.supplyAsync(SecretUsageContext.wrap(() -> { try { concurrency.acquire(); try { - return inspectRow(row, prompt, apiKey, imgSwitch, categorySwitch, categoryTree); + return inspectRow(row, rowIndex, prepass, prompt, apiKey, imgSwitch, categorySwitch, categoryTree); } finally { concurrency.release(); } @@ -231,6 +250,8 @@ public class SimilarAsinLlmService { } private SimilarAsinResultRowDto inspectRow(SimilarAsinResultRowDto source, + int rowIndex, + CategoryPrepass prepass, String prompt, String apiKey, boolean imgSwitch, @@ -238,7 +259,7 @@ public class SimilarAsinLlmService { CategoryTree categoryTree) { SimilarAsinResultRowDto row = copyRow(source); try { - inspectRowInternal(row, prompt, apiKey, imgSwitch, categorySwitch, categoryTree); + inspectRowInternal(row, rowIndex, prepass, prompt, apiKey, imgSwitch, categorySwitch, categoryTree); return row; } catch (Exception ex) { log.warn("[similar-asin][llm] row failed asin={} title={} err={}", @@ -248,6 +269,8 @@ public class SimilarAsinLlmService { } private void inspectRowInternal(SimilarAsinResultRowDto row, + int rowIndex, + CategoryPrepass prepass, String prompt, String apiKey, boolean imgSwitch, @@ -265,7 +288,8 @@ public class SimilarAsinLlmService { } // --- 2. 类目匹配:一次调用出一级+二级,三级候选走内存树(141783/1548215/1288150)--- - CategoryPath path = matchCategoryPath(row, categoryTree, apiKey); + // 批量启用时直接用预计算结果(树文本已随批量请求发送);未启用走逐行单调用。 + CategoryPath path = categoryPathForRow(rowIndex, prepass, row, categoryTree, apiKey); CategoryLevel first = path.first(); CategoryLevel second = path.second(); List thirdCandidates = isNoMatch(second) @@ -368,6 +392,163 @@ public class SimilarAsinLlmService { return new CategoryPath(first, second == null ? CategoryLevel.none() : second); } + // --- 批量分类(2026-10-02):类目树文本随每行请求重复发送是分类链路最大的 token 开销 --- + + /** 批量分类预计算的产物:paths 覆盖整批行(含降级为"无"的判定),errors 记录回退调用也失败的行。 */ + private record CategoryPrepass(Map paths, Map errors) { + } + + /** + * 批内分类预计算:按 {@code llmCategoryBatchSize} 分块,每块一次 LLM 调用, + * 类目树文本整块只随请求发送一次。块内缺编号/坏编号的行、以及整块调用失败的行, + * 回退到逐行单调用(对齐旧语义:分类抛异常 = 行失败,而不是静默降级成"无")。 + * 返回 null 表示批量未启用(阈值 ≤1 或行数 <2),调用方走逐行旧路径。 + */ + private CategoryPrepass matchCategoryPathsBatched(List rows, + CategoryTree categoryTree, String apiKey) { + int batchSize = Math.max(1, properties.getLlmCategoryBatchSize()); + if (batchSize <= 1 || rows.size() < 2) { + return null; + } + Semaphore concurrency = new Semaphore(Math.max(1, properties.getLlmRowConcurrency())); + ExecutorService executor = rowExecutor(); + SecretUsageContext.Context usageContext = SecretUsageContext.snapshot(); + Map paths = new ConcurrentHashMap<>(); + Map errors = new ConcurrentHashMap<>(); + List> futures = new ArrayList<>(); + for (int from = 0; from < rows.size(); from += batchSize) { + List chunk = new ArrayList<>(Math.min(batchSize, rows.size() - from)); + for (int i = from; i < Math.min(from + batchSize, rows.size()); i++) { + chunk.add(i); + } + futures.add(CompletableFuture.supplyAsync(SecretUsageContext.wrap(() -> { + try { + concurrency.acquire(); + try { + matchCategoryChunk(rows, chunk, categoryTree, apiKey, paths, errors); + } finally { + concurrency.release(); + } + } catch (InterruptedException interruptedException) { + Thread.currentThread().interrupt(); + throw new IllegalStateException("LLM category batch interrupted", interruptedException); + } + return null; + }, usageContext), executor)); + } + for (CompletableFuture future : futures) { + future.join(); // matchCategoryChunk 内部自捕获,join 只会因中断失败 + } + return new CategoryPrepass(paths, errors); + } + + private void matchCategoryChunk(List rows, List chunk, + CategoryTree tree, String apiKey, + Map paths, Map errors) { + try { + String content = llmClient.invokeChat(properties.getLlmCategoryModel(), + SYSTEM_CATEGORY + CATEGORY_BATCH_ENVELOPE, + buildCategoryBatchUserText(rows, chunk, tree), apiKey); + JsonNode root = llmClient.parseJsonContent(content); + resolveCategoryBatchItems(rows, chunk, root, tree, apiKey, paths, errors); + } catch (Exception ex) { + log.warn("[similar-asin][llm] category batch failed rows={} firstAsin={} err={} → 整块回退单行", + chunk.size(), abbreviate(rows.get(chunk.get(0)).getAsin(), 40), failureMessage(ex)); + fallbackCategorySingleRows(rows, chunk, tree, apiKey, paths, errors); + } + } + + /** + * 批量结果逐项回查类目树:判定语义与单行 {@link #matchCategoryPath} 完全一致 + * (一级失配=整行"无"、二级失配=保留一级);缺失/坏编号的行回退单行调用补齐。 + */ + private void resolveCategoryBatchItems(List rows, List chunk, + JsonNode root, CategoryTree tree, String apiKey, + Map paths, Map errors) { + Map parsed = new HashMap<>(); + JsonNode items = root.path("items"); + if (items.isArray()) { + for (JsonNode item : items) { + int i = item.path("i").asInt(-1); + if (i < 1 || i > chunk.size()) { + continue; // 坏编号:交给缺失回退 + } + int rowIndex = chunk.get(i - 1); + if (parsed.containsKey(rowIndex)) { + continue; // 重复编号取首个 + } + parsed.put(rowIndex, categoryPathFromNames(tree, + textOrEmpty(item, "first"), textOrEmpty(item, "second"))); + } + } + for (Integer rowIndex : chunk) { + CategoryPath path = parsed.get(rowIndex); + if (path != null) { + paths.put(rowIndex, path); + } else { + fallbackCategorySingleRows(rows, List.of(rowIndex), tree, apiKey, paths, errors); + } + } + } + + private CategoryPath categoryPathFromNames(CategoryTree tree, String firstName, String secondName) { + CategoryLevel first = resolveLevel(tree.roots(), firstName, "一级"); + if (first == null) { + return CategoryPath.none(); + } + CategoryLevel second = resolveLevel(tree.childrenOf(first.id()), secondName, "二级"); + return new CategoryPath(first, second == null ? CategoryLevel.none() : second); + } + + /** 批量失败的行回退逐行单调用;分类调用本身抛异常时记入 errors(行级失败语义不变)。 */ + private void fallbackCategorySingleRows(List rows, List chunk, + CategoryTree tree, String apiKey, + Map paths, Map errors) { + for (Integer rowIndex : chunk) { + if (paths.containsKey(rowIndex) || errors.containsKey(rowIndex)) { + continue; + } + try { + paths.put(rowIndex, matchCategoryPath(rows.get(rowIndex), tree, apiKey)); + } catch (Exception ex) { + errors.put(rowIndex, ex); + } + } + } + + /** 每行分类结果取用:优先预计算;回退也失败的行按单行语义抛出 → 行失败。 */ + private CategoryPath categoryPathForRow(int rowIndex, CategoryPrepass prepass, + SimilarAsinResultRowDto row, CategoryTree tree, + String apiKey) throws Exception { + if (prepass == null) { + return matchCategoryPath(row, tree, apiKey); + } + Exception error = prepass.errors().get(rowIndex); + if (error != null) { + throw error instanceof RuntimeException runtimeException ? runtimeException + : new IllegalStateException(error.getMessage(), error); + } + CategoryPath path = prepass.paths().get(rowIndex); + if (path == null) { + throw new IllegalStateException("批量分类结果缺失 rowIndex=" + rowIndex); + } + return path; + } + + private String buildCategoryBatchUserText(List rows, List chunk, + CategoryTree tree) { + StringBuilder sb = new StringBuilder(); + sb.append("备选类目列表:\n").append(tree.formatTwoLevels()).append("\n\n"); + sb.append("待分类商品(共 ").append(chunk.size()).append(" 件,按编号 [i] 逐件判定):\n"); + for (int position = 0; position < chunk.size(); position++) { + SimilarAsinResultRowDto row = rows.get(chunk.get(position)); + sb.append('[').append(position + 1).append("] 产品标题:") + .append(firstNonBlank(row.getTitle(), row.getAsin())).append('\n'); + sb.append(" 产品属性:").append(normalize(row.getSku())).append('\n'); + } + return sb.toString(); + } + /** 按名称在给定候选内回查层级;"无"/空/编造名称一律返回 null,交由上层降级。 */ private CategoryLevel resolveLevel(List candidates, String name, String levelLabel) { String normalized = normalize(name); diff --git a/backend-java/src/main/resources/application.yml b/backend-java/src/main/resources/application.yml index 70f524db8..1795c3fe6 100644 --- a/backend-java/src/main/resources/application.yml +++ b/backend-java/src/main/resources/application.yml @@ -381,6 +381,7 @@ aiimage: llm-first-attempt-read-timeout-millis: ${AIIMAGE_SIMILAR_ASIN_LLM_FIRST_ATTEMPT_READ_TIMEOUT_MILLIS:300000} llm-retry-times: ${AIIMAGE_SIMILAR_ASIN_LLM_RETRY_TIMES:3} llm-row-concurrency: ${AIIMAGE_SIMILAR_ASIN_LLM_ROW_CONCURRENCY:5} + llm-category-batch-size: ${AIIMAGE_SIMILAR_ASIN_LLM_CATEGORY_BATCH_SIZE:10} llm-image-download-timeout-seconds: ${AIIMAGE_SIMILAR_ASIN_LLM_IMAGE_DOWNLOAD_TIMEOUT_SECONDS:10} llm-image-download-retry-times: ${AIIMAGE_SIMILAR_ASIN_LLM_IMAGE_DOWNLOAD_RETRY_TIMES:2} llm-image-host-alias-map: ${AIIMAGE_SIMILAR_ASIN_LLM_IMAGE_HOST_ALIAS_MAP:m.media-amazon.com=images-na.ssl-images-amazon.com} diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java index a62ac8dd6..87aa0ed58 100644 --- a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java +++ b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinLlmServiceTest.java @@ -346,6 +346,12 @@ class SimilarAsinLlmServiceTest { /** 按 userText 前缀区分类目调用与合规调用,并记录全部 chat 调用供断言。 */ private SimilarAsinLlmClient recordingClient(List chatUserTexts, String categoryJson, String conformJson) { + return recordingClient(chatUserTexts, null, categoryJson, conformJson); + } + + /** 同上,另支持批量分类文本(含"待分类商品"标记)——batchCategoryJson 为 null 时批量调用视为意外。 */ + private SimilarAsinLlmClient recordingClient(List chatUserTexts, String batchCategoryJson, + String categoryJson, String conformJson) { SimilarAsinLlmClient client = mock(SimilarAsinLlmClient.class); when(client.resolveApiKey(anyString())).thenReturn("k"); when(client.hasApiKey(anyString())).thenReturn(true); @@ -353,6 +359,12 @@ class SimilarAsinLlmServiceTest { .thenAnswer(invocation -> { String userText = invocation.getArgument(2); chatUserTexts.add(userText); + if (userText.contains("待分类商品")) { + if (batchCategoryJson == null) { + throw new IllegalStateException("unexpected category batch call: " + userText); + } + return batchCategoryJson; + } return userText.startsWith("产品标题:") ? categoryJson : conformJson; }); when(client.invokeChatWithImages(anyString(), anyString(), anyString(), any(), anyString())) @@ -447,7 +459,11 @@ class SimilarAsinLlmServiceTest { List chats = new CopyOnWriteArrayList<>(); ProductCategoryService categoryService = duplicateTreeCategoryService(); SimilarAsinLlmService service = service( - recordingClient(chats, "{\"first\":\"家具\",\"second\":\"配件\"}", + recordingClient(chats, + "{\"items\":[{\"i\":1,\"first\":\"家具\",\"second\":\"配件\"}," + + "{\"i\":2,\"first\":\"数码\",\"second\":\"配件\"}," + + "{\"i\":3,\"first\":\"数码\",\"second\":\"无\"}]}", + "{\"first\":\"家具\",\"second\":\"配件\"}", "{\"asin\":\"B01\",\"is_conform\":\"不符合\",\"reason\":\"无\",\"category\":\"家具->配件->沙发套\"}"), categoryService); @@ -456,4 +472,137 @@ class SimilarAsinLlmServiceTest { verify(categoryService, times(1)).list(); verify(categoryService, never()).children(any(), anyLong(), anyLong()); } + + // --- 批量分类(2026-10-02):类目树文本整批只随一次请求发送 --- + + private SimilarAsinLlmService service(SimilarAsinLlmClient llmClient, ProductCategoryService categoryService, + SimilarAsinProperties properties) { + OssStorageService ossStorage = mock(OssStorageService.class); + when(ossStorage.getPublicUrl(anyString())).thenAnswer(invocation -> "https://oss.aishufu.top/nanri-ai-images/" + invocation.getArgument(0)); + PuzzleImageMerger merger = mock(PuzzleImageMerger.class); + when(merger.merge(anyList(), Mockito.any())).thenReturn(jpegBytes()); + SimilarAsinLlmService svc = new SimilarAsinLlmService( + llmClient, + properties, + mock(OssProperties.class), + categoryService, + merger, + ossStorage, + mock(SimilarAsinImageEmbedder.class)); + svc.setDownloadHttpClientForTest(mockHttpClient()); + return svc; + } + + private static long countTreeTexts(List chats) { + return chats.stream().filter(text -> text.contains("备选类目列表")).count(); + } + + private static final String CONFORM_JSON = + "{\"asin\":\"B01\",\"is_conform\":\"不符合\",\"reason\":\"无\",\"category\":\"家具->配件->沙发套\"}"; + + @Test + void categoryBatchAmortizesTreeTextAcrossRows() { + List chats = new CopyOnWriteArrayList<>(); + SimilarAsinLlmService service = service( + recordingClient(chats, + "{\"items\":[{\"i\":1,\"first\":\"家具\",\"second\":\"配件\"}," + + "{\"i\":2,\"first\":\"家具\",\"second\":\"无\"}," + + "{\"i\":3,\"first\":\"数码\",\"second\":\"配件\"}]}", + "{\"first\":\"家具\",\"second\":\"配件\"}", + CONFORM_JSON), + duplicateTreeCategoryService()); + + List result = service.inspectRows( + List.of(rowOf("B01", "布质防滑罩"), rowOf("B02", "亚麻沙发套"), rowOf("B03", "手机支架")), + "", "k", false, true); + + // 1 次批量分类 + 3 次合规;树文本只在批量请求里出现一次(逐行模式会出现 3 次) + assertEquals(4, chats.size(), "实际调用:" + chats); + assertEquals(1, countTreeTexts(chats)); + String batchText = chats.get(0); + assertTrue(batchText.contains("布质防滑罩") && batchText.contains("亚麻沙发套") && batchText.contains("手机支架"), + "批量请求应包含整块全部行:" + batchText); + // 批量判定的行级语义与单行一致:i=2 second=无 → 合规入参二级为"无"且无三级候选 + assertTrue(result.get(1).getIsConform() != null, "每行都要完成合规判定"); + String conformTexts = chats.stream().filter(text -> text.contains("三级类目:")) + .filter(text -> text.contains("一级类目:家具") && text.contains("二级类目:无")) + .findFirst().orElse(""); + assertTrue(!conformTexts.isEmpty(), "i=2 的判定应保留一级、二级为无:" + chats); + assertFalse(conformTexts.contains("手机壳"), "二级为无时不应给出三级候选"); + } + + @Test + void categoryBatchMissingItemFallsBackToSingleRowCall() { + List chats = new CopyOnWriteArrayList<>(); + // 批量结果只回了 i=1、i=3,i=2 缺失 → 该行回退逐行单调用补齐 + SimilarAsinLlmService service = service( + recordingClient(chats, + "{\"items\":[{\"i\":1,\"first\":\"家具\",\"second\":\"配件\"}," + + "{\"i\":3,\"first\":\"数码\",\"second\":\"配件\"}]}", + "{\"first\":\"家具\",\"second\":\"配件\"}", + CONFORM_JSON), + duplicateTreeCategoryService()); + + service.inspectRows( + List.of(rowOf("B01", "布质防滑罩"), rowOf("B02", "亚麻沙发套"), rowOf("B03", "手机支架")), + "", "k", false, true); + + long batchCalls = chats.stream().filter(text -> text.contains("待分类商品")).count(); + long singleCategoryCalls = chats.stream().filter(text -> text.startsWith("产品标题:")).count(); + assertEquals(1, batchCalls); + assertEquals(1, singleCategoryCalls, "缺失行要回退单行分类调用:" + chats); + assertEquals(3, chats.size() - batchCalls - singleCategoryCalls, "3 行都要有合规调用:" + chats); + } + + @Test + void categoryBatchTransportErrorFallsBackForWholeChunk() { + List chats = new CopyOnWriteArrayList<>(); + SimilarAsinLlmClient client = mock(SimilarAsinLlmClient.class); + when(client.resolveApiKey(anyString())).thenReturn("k"); + when(client.hasApiKey(anyString())).thenReturn(true); + when(client.invokeChat(anyString(), anyString(), anyString(), anyString())) + .thenAnswer(invocation -> { + String userText = invocation.getArgument(2); + chats.add(userText); + if (userText.contains("待分类商品")) { + throw new IllegalStateException("LLM gateway 502"); + } + return userText.startsWith("产品标题:") ? "{\"first\":\"家具\",\"second\":\"配件\"}" : CONFORM_JSON; + }); + when(client.invokeChatWithImages(anyString(), anyString(), anyString(), any(), anyString())) + .thenReturn("{\"asin\":\"B01\",\"is_stock\":\"没有货\",\"similarity\":\"10%\",\"status\":\"成功\"}"); + when(client.parseJsonContent(anyString())) + .thenAnswer(invocation -> parseJson(invocation.getArgument(0))); + SimilarAsinLlmService service = service(client, duplicateTreeCategoryService()); + + List result = service.inspectRows( + List.of(rowOf("B01", "A"), rowOf("B02", "B"), rowOf("B03", "C")), "", "k", false, true); + + long batchCalls = chats.stream().filter(text -> text.contains("待分类商品")).count(); + assertEquals(1, batchCalls, "批量调用发生一次"); + assertEquals(3, chats.stream().filter(text -> text.startsWith("产品标题:")).count(), + "整块失败后 3 行都回退单行分类调用:" + chats); + for (SimilarAsinResultRowDto row : result) { + assertEquals("不符合", row.getIsConform(), "回退后行级结果照常产出"); + } + } + + @Test + void categoryBatchDisabledWhenBatchSizeOne() { + List chats = new CopyOnWriteArrayList<>(); + SimilarAsinProperties properties = properties(); + properties.setLlmCategoryBatchSize(1); + SimilarAsinLlmService service = service( + recordingClient(chats, "{\"first\":\"家具\",\"second\":\"配件\"}", CONFORM_JSON), + duplicateTreeCategoryService(), + properties); + + service.inspectRows(List.of(rowOf("B01", "A"), rowOf("B02", "B"), rowOf("B03", "C")), "", "k", false, true); + + assertEquals(0, chats.stream().filter(text -> text.contains("待分类商品")).count(), + "批量关闭时不得发起批量调用"); + // 单行模式:每行的分类请求各带一次树文本(树内容以一级类目的 ID 标注为标记) + assertEquals(3, chats.stream().filter(text -> text.contains("ID:100")).count(), "3 次分类各带一棵树"); + assertEquals(6, chats.size(), "3 次分类 + 3 次合规"); + } }