fix(tasks): 批量入库与 folder 去重逐条容错,发布文案不说谎

B49/B50 收尾三处当时被标"非 ★"跳过的同类缺陷。判据同一条:一颗坏项不许让
其余项一起不干活,也不许把"根本没拿到数据"说成"数据正常"。

1) shopkey/service/QueryAsinService.java(B49 #6,flushInsert:843-844)
   复验为真:整张表共用一条读行循环,某一批 insertBatch 抛出即冒到
   runImportTask 的 catch,后面的批次一个都跑不到、内存里的余行一起丢。
   审计里"报数虚高"那条已被复验否掉(原状下坏批计数确实不外发),本笔不按
   那个理由改;但逐批容错之后坏批计数会随后续进度外发,所以必须按"没落库"
   回退:insertedCount 扣回、skippedCount 记上、坏批点名进日志与 errorMessage。
   收尾新增 failIfBatchesLost():有坏批就让导入落"失败"态并报出缺口行数——
   admin 侧只在 failed 分支显示 errorMessage(QueryAsinPage.vue:260-271),
   留在 success 上等于把没入库的行说成导入完成。重传整表是安全的:已入库行
   会被 rowSignature 认成重复跳过。
   processImportFile 由 private 收到包级作测试接缝(形状同 tryAcquireFileSlot)。
   该 importer 此前零夹具,新建 3 例(真 xlsx + 真 ExcelStreamReader)。

2) dedupe/service/DedupeRunService.java(B49 #4 的 folder 分支)
   只在 folder 模式成立:逐文件清洗结果只落本地临时目录,唯一交付物是那个
   ZIP。两颗坏项会带走整批——① 收尾的 aborted 判定排在打包之前,一个 worker
   线程级异常就让打包整步跳过;② 打包循环里一个条目读不到/条目名相撞就整包
   作废。现改为 folder 分支先打包再判 aborted,打包逐条目容错并点名跳过;
   一个都没写进去时拒绝交空包(那才是"根本没拿到数据")。aborted 仍照旧把
   终态落 FAILED,不拿部分交付冒充全量成功;缺口写在交付条目与日志上,
   不写 file_task.error_message。非 folder 分支一个字节没动。
   DedupeArchiveEntry 与打包方法收到包级作测试接缝。新建 3 例,含一支用
   同线程执行器让第 2 个 worker 当场线程级异常的真链路用例。

3) publish/service/PublishTaskService.java(B49 #7/B50 #4,607-609)
   按上一轮复验结论只改文案,不动状态语义:逐文件 status/VO 本来就交付了。
   会说谎的地方是 publishResultFile(..., preserveFailure=false) 把结果行
   error_message 洗成 null,"N 个文件没进这张表"在文案层等于全部成功。
   缺口写在 biz_file_result.error_message(本仓既有"部分交付"载体:
   ShopMatch:825/PriceTrack:905/ProductRisk:827 都按它判 partialFailure;
   publish 侧只有 toResultVo:1216 读它,纯展示,fileReady 由 success+url 推导
   不受影响)。SUCCESS 的 file_task.error_message 继续留空并就地写明理由:
   TaskRetryEligibility.forceMajeureCategory 与 SimilarAsinStaleReopenSupport
   .isStaleFailure 都按那段文字做字面量分类,写进去会喂错 stale/重开/续跑判据。
   文案两个方向都不说谎:说清"只含成功处理的 X 个、另有 N 个未纳入(点名)",
   并明写"不是表格格式问题、可只重新提交这些文件",不把可恢复失败推给表格。
   新建 2 例(含反向钉:全成功时不得凭空造缺口文案)。

实测:mvn -o test-compile rc=0;新增 8 例改前 6 红(QueryAsin 2 红=原始
RuntimeException 直接冒出、批次被提前收走;Dedupe 3 红="Wanted but not
invoked: fileResultMapper.insert"+整包作废;Publish 1 红=errorMessage 恒
null),改后 8/8 绿;相邻既有 9 支类 97 例全绿(PublishTaskServiceTest 33、
DedupeRunProgressResumeTest 14、PublishFileLevelStatusTest 8、
PublishResultFileJobHandlerTest 8、DedupeRunServiceCleanRulesTest 9、
DedupeRunServiceFileSlotTest 2、QueryAsinResolveServiceTest 13 等)。

CatchSilenceRatchetTest 按预期判红(本笔新增 2 处 catch,均在被禁改的共享台账
里,合并时由主线程统一重钉):实测 total=1028(基线 1026)、
notRethrow(incl logOnly)=579(基线 577)、logOnly=181(不变)、
rethrow=393(不变)、empty=56(不变)。
This commit is contained in:
2026-10-27 16:02:11 +08:00
parent e08b5369d7
commit 88d737a7f0
6 changed files with 811 additions and 16 deletions
@@ -367,16 +367,21 @@ public class DedupeRunService {
}
try {
if (aborted) {
// 有文件没能正常处理完就序列化/标成功,会出现「任务成功但结果缺文件」
throw new IllegalStateException("部分文件处理线程异常结束,结果不完整");
}
// folder 模式:先打包,再判 aborted。逐文件清洗结果只落在本地临时目录,唯一交付物就是这个
// ZIP——原先一个 worker 线程级异常就让整步打包跳过,已清洗完的 N-1 个文件一起不交付
// (B49 #4 的 folder 分支)。打包本身逐条目容错,见
// {@link #packageFolderDedupeResultsAsZip(String, List)};aborted 仍照旧把终态落到
// FAILED,绝不拿"部分交付"冒充全量成功。非 folder 模式一个字节不变。
if (folderMode && !archiveEntries.isEmpty()) {
DedupeResultItemVo zipItem = buildFolderZipResult(request, archiveEntries, task);
synchronized (progress) {
outcomeItems.add(0, zipItem);
}
}
if (aborted) {
// 有文件没能正常处理完就序列化/标成功,会出现「任务成功但结果缺文件」
throw new IllegalStateException("部分文件处理线程异常结束,结果不完整");
}
DedupeRunVo result = buildRunVo(request, outcomeItems, progress);
finishTaskSuccess(task, result);
synchronized (progress) {
@@ -620,7 +625,9 @@ public class DedupeRunService {
private DedupeResultItemVo buildFolderZipResult(DedupeRunRequest request,
Map<String, DedupeArchiveEntry> archiveEntries,
FileTaskEntity task) {
File zipFile = packageFolderDedupeResultsAsZip(request.getArchiveName(), new ArrayList<>(archiveEntries.values()));
FolderPackage packaged = packageFolderDedupeResultsAsZip(
request.getArchiveName(), new ArrayList<>(archiveEntries.values()));
File zipFile = packaged.file();
OssStorageService.UploadedResult uploadedResult = ossStorageService.uploadResultFileWithFreshDownloadUrl(zipFile, "DEDUPE");
DedupeResultItemVo item = new DedupeResultItemVo();
item.setSourceFilename(request.getArchiveName());
@@ -628,6 +635,15 @@ public class DedupeRunService {
item.setSuccess(true);
item.setDownloadUrl(uploadedResult.downloadUrl());
item.setResultFileSize(zipFile.length());
if (!packaged.skippedEntries().isEmpty()) {
// 缺口只写在这一条交付项上(VO + task.result_json),不写 file_task.error_message:
// 那段文字会被按字面量分类的判据读取(TaskRetryEligibility/
// SimilarAsinStaleReopenSupport),SUCCESS 行留空才是安全口径。
item.setError("压缩包已交付 " + packaged.packedCount() + " 个文件,另有 "
+ packaged.skippedEntries().size() + " 个文件的结果没能写进压缩包("
+ String.join("、", packaged.skippedEntries())
+ ");这些文件本次确实没交付,是临时结果文件/写入的问题,不是表格内容问题,可只重新提交这几个文件");
}
FileResultEntity resultEntity = new FileResultEntity();
resultEntity.setTaskId(task.getId());
@@ -995,20 +1011,57 @@ public class DedupeRunService {
return value == null ? "" : value;
}
private File packageFolderDedupeResultsAsZip(String archiveName, List<DedupeArchiveEntry> archiveEntries) {
/** 打包结果:交付的压缩包,以及逐条目容错后没能写进去的那些文件名。 */
record FolderPackage(File file, int packedCount, List<String> skippedEntries) {
}
/**
* 文件夹模式逐条目容错打包(B49 #4 的 folder 分支)。
*
* <p>原形状:一个条目读不到(结果临时文件被清掉/磁盘错)或条目名相撞,就在 {@code ZipOutputStream}
* 里抛出并整包作废——同一批里<b>已清洗完的其余文件一起不交付</b>,用户只能整批重跑。
* 现在坏条目自己认赔、点名跳过,其余照常入包;只有<b>一个都没写进去</b>时才整批判失败
* (那才是"根本没拿到数据",不许交一个空包冒充成功)。压缩包本体建不起来
* (目录/磁盘级错误)同样是整批级别,照旧抛出。
*
* <p>本方法不私有:它是 folder 打包唯一的可测接缝(形状同 {@link #tryAcquireFileSlot()})。
*/
FolderPackage packageFolderDedupeResultsAsZip(String archiveName, List<DedupeArchiveEntry> archiveEntries) {
File outputDir = FileUtil.mkdir(FileUtil.file(storageProperties.getLocalTempDir(), "dedupe-result"));
File zipFile = buildNamedOutputFile(outputDir, archiveName + ".zip");
int packedCount = 0;
List<String> skippedEntries = new ArrayList<>();
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) {
for (DedupeArchiveEntry entry : archiveEntries) {
String zipEntryName = buildFolderZipEntry(entry.relativePath(), entry.inputName(), entry.inputName(), false);
zos.putNextEntry(new ZipEntry(zipEntryName));
Files.copy(entry.outputFile().toPath(), zos);
zos.closeEntry();
String entryName = entry.inputName();
File source = entry.outputFile();
// 先验可读再开条目:文件缺失/不可读与条目名相撞都发生在写入之前,
// 这类坏项不会在包里留下半截文件(写到一半才抛的极端 IO 错仍可能留短条目)
if (source == null || !source.exists() || !source.canRead()) {
skippedEntries.add(entryName);
log.error("[dedupe] 结果临时文件不可读,跳过该条目并继续其余文件 archiveName={} entry={} path={}",
archiveName, entryName, source == null ? "null" : source.getPath());
continue;
}
try {
zos.putNextEntry(new ZipEntry(buildFolderZipEntry(entry.relativePath(), entryName, entryName, false)));
Files.copy(source.toPath(), zos);
zos.closeEntry();
packedCount++;
} catch (Exception ex) {
skippedEntries.add(entryName);
log.error("[dedupe] 单个结果文件写入压缩包失败,跳过该条目并继续其余文件 archiveName={} entry={} error",
archiveName, entryName, ex);
}
}
} catch (Exception ex) {
throw new BusinessException(UserMessages.with("去重结果打包失败", ex));
}
return zipFile;
if (packedCount == 0) {
throw new BusinessException("去重结果打包失败:待打包的 " + archiveEntries.size()
+ " 个结果文件没有一个写进压缩包(临时结果文件缺失或写入异常,不是表格内容问题),本次没有交付文件夹结果");
}
return new FolderPackage(zipFile, packedCount, skippedEntries);
}
private String buildFolderZipEntry(String relativePath, String inputName, String outputFilename, boolean includeSourceStemFolder) {
@@ -1240,7 +1293,8 @@ public class DedupeRunService {
return nanos / 1_000_000L;
}
private record DedupeArchiveEntry(String relativePath, String inputName, File outputFile) {
/** 不私有:folder 打包接缝 {@link #packageFolderDedupeResultsAsZip(String, List)} 的入参类型。 */
record DedupeArchiveEntry(String relativePath, String inputName, File outputFile) {
}
private static final class DedupeReadResult {
@@ -96,6 +96,8 @@ public class PublishTaskService extends AbstractFileTaskPipeline<PublishRowDto>
private static final String STATUS_RUNNING = "RUNNING";
private static final String STATUS_SUCCESS = "SUCCESS";
private static final String STATUS_FAILED = "FAILED";
/** 「部分交付」文案里最多点名几个文件,余下的用总数兜住。 */
private static final int PARTIAL_NOTE_NAME_LIMIT = 3;
/**
* 保留期清理允许删除的终态集合(与 ModuleHistoryCleanupService 的 TERMINAL_STATUSES 一致)。
* PENDING/RUNNING 绝不在此列;PUBLISH 实际只会写 SUCCESS/FAILED,取消态是无害的超集。
@@ -603,9 +605,24 @@ public class PublishTaskService extends AbstractFileTaskPipeline<PublishRowDto>
publishResultFile(result, packaged.file(), packaged.filename(), packaged.contentType(), rowCount, false);
int failedCount = (int) files.stream().filter(file -> STATUS_FAILED.equals(file.getStatus())).count();
int unpackedCount = files.size() - successfulFiles.size();
if (unpackedCount > 0) {
// 只补文案、不动状态语义:文件确实交付了,success=1 与下载直链都不能改(改了就把
// 能用的结果也扣掉)。缺口写在这一行 result 的 error_message 上——本仓把它当
// 「部分交付」载体用(ShopMatch:825/PriceTrack:905/ProductRisk:827 都按它判
// partialFailure),而 publish 侧只有 toResultVo 读它(纯展示),不喂任何分类判据。
result.setErrorMessage(partialDeliveryNote(files, successfulFiles.size(), unpackedCount, failedCount));
fileResultMapper.updateById(result);
log.warn("[publish] 任务标成功但有文件未纳入结果 taskId={} files={} delivered={} unpacked={} failed={}",
task.getId(), files.size(), successfulFiles.size(), unpackedCount, failedCount);
}
task.setStatus(STATUS_SUCCESS);
task.setSuccessFileCount(successfulFiles.size());
task.setFailedFileCount(failedCount);
// SUCCESS 的 file_task 行必须留空 error_message:TaskRetryEligibility.forceMajeureCategory
// 与 SimilarAsinStaleReopenSupport.isStaleFailure 都拿这段文字做字面量分类(stale/重开/
// 克隆重跑),写进去会把"其实已跑完一半"的单子喂给错误的分类。所以缺口只落在上面
// 结果行的文案与日志里,这里继续清空的语义是有意为之,不是漏判。
task.setErrorMessage(null);
task.setUpdatedAt(LocalDateTime.now());
task.setFinishedAt(LocalDateTime.now());
@@ -624,6 +641,33 @@ public class PublishTaskService extends AbstractFileTaskPipeline<PublishRowDto>
}
}
/**
* 「部分交付」提示语(B49/B50 口径):不许把「N 个文件没处理」说成整单成功,
* 也不许反过来把可恢复的处理失败推给表格——文件级的真因本来就落在
* {@code publish_file.error_message}({@code toFileVo} 已逐文件回传)。
* 名单只取前几项,余下的用总数兜住,免得文案无限长。
*/
private String partialDeliveryNote(List<PublishFileEntity> files, int deliveredCount,
int unpackedCount, int failedCount) {
List<String> names = new ArrayList<>();
for (PublishFileEntity file : files) {
if (STATUS_SUCCESS.equals(file.getStatus())) {
continue;
}
names.add(firstNonBlank(file.getSourceFilename(), "未命名文件"));
if (names.size() >= PARTIAL_NOTE_NAME_LIMIT) {
break;
}
}
String nameList = String.join("、", names)
+ (unpackedCount > names.size() ? " 等 " + unpackedCount + " 个文件" : "");
String gap = failedCount == unpackedCount
? "另有 " + unpackedCount + " 个文件处理失败,未纳入结果(" + nameList + ")"
: "另有 " + unpackedCount + " 个文件未纳入结果(其中 " + failedCount + " 个处理失败:" + nameList + ")";
return "结果已生成,但只含成功处理的 " + deliveredCount + " 个文件;" + gap
+ "。这些文件本轮确实没有结果,不是表格格式问题——各自的原因见文件列表,可只重新提交这些文件,不必重跑整单";
}
/**
* 删除任务。
*
@@ -451,8 +451,16 @@ public class QueryAsinService {
}
}
private void processImportFile(File tempFile, String filename, Long fallbackGroupId, Long operatorId,
boolean superAdmin, boolean deleteMode, QueryAsinImportProgressVo progress) throws Exception {
/**
* 逐行读表并分批入库。本方法<b>不</b>是私有的:它是导入链唯一的可测接缝
* (形状同 {@code DedupeRunService.tryAcquireFileSlot},本仓既有约定)。
*
* <p>收尾必须做一次「有没有坏批」的交代:{@link ImportContext} 现在按批容错,
* 一颗坏批只丢它自己那几行、其余批照常入库,所以异常不会自然冒到这里。
* 全部批次都坏=一行没落库,此时必须如实失败,不许报「导入完成」。
*/
void processImportFile(File tempFile, String filename, Long fallbackGroupId, Long operatorId,
boolean superAdmin, boolean deleteMode, QueryAsinImportProgressVo progress) throws Exception {
validateExcelFilename(filename);
ImportContext context = new ImportContext(fallbackGroupId, operatorId, superAdmin, deleteMode, progress);
ExcelStreamReader.readFirstSheet(tempFile, new ExcelStreamReader.SheetRowHandler() {
@@ -471,6 +479,7 @@ public class QueryAsinService {
if (!context.hasHeader()) {
throw new BusinessException("Excel 表头为空");
}
context.failIfBatchesLost();
}
private File saveMultipartToTempFile(MultipartFile file, String prefix) throws Exception {
@@ -702,6 +711,16 @@ public class QueryAsinService {
private int insertedCount;
private int deletedCount;
private int skippedCount;
/**
* 没能入库的批次,逐批点名(B49 #6)。原形状:一整张表共用一条读行循环,
* 某一批 {@code insertBatch} 抛出就直接冒到 {@code runImportTask} 的 catch,
* 于是<b>后面的批次一个都跑不到</b>、已在内存里的余行也一起丢。
* 现在按批容错:坏批自己认赔并记在这里,其余批照常入库;最后一并交代(见
* {@link #failIfBatchesLost()}),既不带走整表,也不把没落库的行说成导入完成。
*/
private final List<String> lostBatchNotes = new ArrayList<>();
private int lostBatchRowCount;
private int lostBatchCellCount;
private ImportContext(Long fallbackGroupId, Long operatorId, boolean superAdmin,
boolean deleteMode, QueryAsinImportProgressVo progress) {
@@ -814,6 +833,7 @@ public class QueryAsinService {
}
}
List<QueryAsinEntity> insertRows = new ArrayList<>();
int insertRowCells = 0;
for (QueryAsinEntity target : targets) {
int cellCount = countCountryCells(target);
String signature = rowSignature(target);
@@ -836,13 +856,55 @@ public class QueryAsinService {
}
insertRows.add(target);
insertedCount += cellCount;
insertRowCells += cellCount;
existingSignatures.add(signature);
existingByKey.computeIfAbsent(importKey(target.getGroupId(), target.getShopName()),
ignored -> new ArrayList<>()).add(target);
}
if (!insertRows.isEmpty()) {
queryAsinMapper.insertBatch(insertRows);
if (insertRows.isEmpty()) {
return;
}
try {
queryAsinMapper.insertBatch(insertRows);
} catch (Exception ex) {
// 逐批容错(B49 #6):坏批只认赔自己那几行,其余批继续由后续 flush 入库,
// 不再让一批的数据库异常中断整张表。计数按"没落库"回退,坏批点名留痕。
insertedCount -= insertRowCells;
skippedCount += insertRowCells;
lostBatchRowCount += insertRows.size();
lostBatchCellCount += insertRowCells;
lostBatchNotes.add("坏批 " + (lostBatchNotes.size() + 1) + "(" + insertRows.size() + " 行,"
+ describeBatchForNote(insertRows) + ")入库失败:"
+ UserMessages.orFallback(ex.getMessage(), "数据库写入异常"));
log.error("[query-asin-import] 批量入库失败,跳过该批并继续其余批次 batchSize={} cells={} groups={} shops={}",
insertRows.size(), insertRowCells, groupIds, shopNames, ex);
}
}
/** 坏批点名:取批内前几行的「分组/店铺」,让运维能在不查库的情况下定位是哪一段没进去。 */
private String describeBatchForNote(List<QueryAsinEntity> rows) {
List<String> names = new ArrayList<>();
for (QueryAsinEntity row : rows) {
names.add(row.getGroupId() + "/" + row.getShopName());
if (names.size() >= 3) {
break;
}
}
return String.join("、", names) + (rows.size() > names.size() ? " 等" + rows.size() + " 行" : "");
}
/**
* 有批次没入库就必须让导入落「失败」态:逐批容错换来了「其余批照常入库」,
* 代价是异常不再自然冒出去、{@code runImportTask} 会把它报成 success——那等于
* 把没落库的行说成导入完成。这里补一次交代,并且只在真有缺口时才改口。
*/
private void failIfBatchesLost() {
if (lostBatchNotes.isEmpty()) {
return;
}
throw new BusinessException("整表已跑完,但有 " + lostBatchRowCount + " 行(" + lostBatchCellCount
+ " 个 ASIN)未入库,已入库的行不受影响;重新导入整表即可补写(已入库行会按重复跳过),"
+ "未入库的都是数据库写入失败、不是表格内容问题:" + String.join(";", lostBatchNotes));
}
private QueryAsinEntity findCompatibleInsertCandidate(QueryAsinEntity target, List<QueryAsinEntity> candidates) {