refactor(phase-3): 3A 接入底座——建单段与一格准入沉下去,回传段其余部分按证据未动

AppearancePatentTaskService 继承 AbstractFileTaskPipeline<AppearancePatentResultRowDto>。
棘轮读数 3458(在册基线)→3381:显式构造器成本 +26,被建单段下沉(-25)与三枚零调用
私有件出仓(-33)对冲掉,本笔自身净减 7 行、较基线净减 77 行。

接得上什么、接不上什么(这次是第四条实测,答案与前三支都不同):
- 接得上底座:newTaskHeader/insertTask/newScopeRow/writeJson/requireUserId/
  requireSubmissionTask/ensureTaskOwnedByCurrentInstance(本支那枚私有同名件签名逐字相同,
  改成 @Override 就接上了)。
- 接不上家族层:本支是 chunk+scope 族(按 submissionId 分片),套 shop-payload 就是把
  「按分片合并」换成「按店铺合并」。装配切片里那条 getSuperclass 断言现在盯住了这一点。
- 接不上缓存钩子:本支的 AppearancePatentTaskCacheService 继承的是同族兄弟
  AbstractPendingRowTaskCacheService,不是 AbstractModuleTaskCacheService ⇒ 底座
  taskCacheService() 钩子对它无类型可套。处置是不覆写那一格(默认 null 已经对),心跳留在
  persistSubmittedChunk 自己那句 touchTaskHeartbeat——不是本支没心跳,是两套抽象接不上。
  底座 javadoc 把 AppearancePatent 列进「4/7 支有模块缓存服务」那格,这条读数不准,
  已在本笔注释里点名更正(蓝图 §5 同步登记)。
- 没动的部分:回传段其余步骤(终态判定用 TaskResultAdmission.rejectNotRunning,比底座
  rejectTerminalSubmission 宽——凡非 RUNNING 皆拒,且 40901 只在真终态那格带)与
  acquireTaskLock 的非阻塞变体(抢不到返回 null 让巡检跳过下一轮,底座只有「抢不到即拒提交」
  两型)。这一段没有 golden,按「先补再动」只做了 prepareSubmittedChunk 那一格
  逐字同形的四行替换,其余一个字节没碰。

捕获账:本支两处序列化 catch(私有 writeJson(Object,String) 与建单那段 try/catch)并进底座
已有的 writeJson ⇒ RETHROW 385→383,按该尺自己写的处置口径逐处记名(出处写在
CatchSilenceRatchetTest 常量上方),用户授权沿用 3B 那一笔的同项拍板。不重抛/只 log/
空体三格未涨,其余判据一格没放宽。

门禁:定向批 452 例/0 红/0 错/5 skipped(五格是 golden 生成器,未设环境变量时如实 skip),
BUILD SUCCESS 取码走无管道写法。八条 golden 逐字节相等——git status -- src/test/resources
一字未动(本支新建单那条 + 前三支那六条都在跑)。装配切片接进第四支:22 枚参数逐枚点名,
含「五枚交 super 之后本支不再持有同名字段」那格 assertSame。
真机启动验收仍没做(要 MySQL+Redis),这条账继续挂在 Phase 8。
This commit is contained in:
2026-10-19 09:36:48 +08:00
parent 7b7d22cbb4
commit f0c672025d
3 changed files with 151 additions and 95 deletions
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.appearancepatent.service;
import cn.hutool.core.util.IdUtil;
import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -8,7 +7,6 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.task.TaskResultAdmission;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentExcelParser;
import com.nanri.aiimage.common.exception.TaskOwnerMismatchException;
import com.nanri.aiimage.common.service.DistributedJobLockService;
@@ -57,7 +55,6 @@ import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.springframework.dao.DuplicateKeyException;
@@ -93,14 +90,14 @@ import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import com.nanri.aiimage.modules.task.model.vo.TaskProgressLightBatchVo;
import com.nanri.aiimage.modules.task.service.TaskProgressLightAssembler;
import com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline;
import com.nanri.aiimage.modules.usersecret.service.UserApiSecretService;
import com.nanri.aiimage.modules.usersecret.support.SecretUsageContext;
import com.nanri.aiimage.modules.usersecret.support.UserSecretModule;
@Service
@RequiredArgsConstructor
@Slf4j
public class AppearancePatentTaskService {
public class AppearancePatentTaskService extends AbstractFileTaskPipeline<AppearancePatentResultRowDto> {
public static final String MODULE_TYPE = "APPEARANCE_PATENT";
@@ -124,34 +121,91 @@ public class AppearancePatentTaskService {
private static final long TASK_LOCK_RETRY_DELAY_MILLIS = 200L;
private final LocalFileStorageService localFileStorageService;
private final OssStorageService ossStorageService;
/** 结果下载直链解析(2026-09 从本类抽到 common,消除 11 处逐字重复) */
private final com.nanri.aiimage.common.service.ResultDownloadResolver resultDownloadResolver;
private final StorageProperties storageProperties;
private final FileTaskMapper fileTaskMapper;
private final FileResultMapper fileResultMapper;
private final TaskScopeStateMapper taskScopeStateMapper;
private final TaskChunkMapper taskChunkMapper;
private final ObjectMapper objectMapper;
private final AppearancePatentLlmClient llmClient;
private final AppearancePatentTaskCacheService taskCacheService;
private final AppearancePatentProperties properties;
private final TaskFileJobService taskFileJobService;
private final TaskProgressSnapshotService taskProgressSnapshotService;
private final TaskHeartbeatPositionService taskHeartbeatPositionService;
private final TransientPayloadStorageService transientPayloadStorageService;
private final PlatformTransactionManager transactionManager;
private final DistributedJobLockService distributedJobLockService;
private final TaskDistributedLockService taskDistributedLockService;
private final InstanceMetadata instanceMetadata;
private final TaskProgressLightAssembler taskProgressLightAssembler;
private final UserApiSecretService userApiSecretService;
/**
* 参数顺序=迁移前 {@code @RequiredArgsConstructor} 的字段声明顺序,一字未动;
* 其中五枚(fileTaskMapper/fileResultMapper/taskDistributedLockService/
* taskFileJobService/ossStorageService)现在交给底座 {@code super(...)} 持有。
* Spring 按类型注入,顺序对装配不构成契约——把它保持原样只为了让测试与调用方
* 不需要重新数一遍(建单段 golden 就是按这个顺序 new 出来的)。
*/
public AppearancePatentTaskService(LocalFileStorageService localFileStorageService,
OssStorageService ossStorageService,
com.nanri.aiimage.common.service.ResultDownloadResolver resultDownloadResolver,
StorageProperties storageProperties,
FileTaskMapper fileTaskMapper,
FileResultMapper fileResultMapper,
TaskScopeStateMapper taskScopeStateMapper,
TaskChunkMapper taskChunkMapper,
ObjectMapper objectMapper,
AppearancePatentLlmClient llmClient,
AppearancePatentTaskCacheService taskCacheService,
AppearancePatentProperties properties,
TaskFileJobService taskFileJobService,
TaskProgressSnapshotService taskProgressSnapshotService,
TaskHeartbeatPositionService taskHeartbeatPositionService,
TransientPayloadStorageService transientPayloadStorageService,
PlatformTransactionManager transactionManager,
DistributedJobLockService distributedJobLockService,
TaskDistributedLockService taskDistributedLockService,
InstanceMetadata instanceMetadata,
TaskProgressLightAssembler taskProgressLightAssembler,
UserApiSecretService userApiSecretService) {
super(fileTaskMapper, fileResultMapper, taskDistributedLockService, taskFileJobService, ossStorageService);
this.localFileStorageService = localFileStorageService;
this.resultDownloadResolver = resultDownloadResolver;
this.storageProperties = storageProperties;
this.taskScopeStateMapper = taskScopeStateMapper;
this.taskChunkMapper = taskChunkMapper;
this.objectMapper = objectMapper;
this.llmClient = llmClient;
this.taskCacheService = taskCacheService;
this.properties = properties;
this.taskProgressSnapshotService = taskProgressSnapshotService;
this.taskHeartbeatPositionService = taskHeartbeatPositionService;
this.transientPayloadStorageService = transientPayloadStorageService;
this.transactionManager = transactionManager;
this.distributedJobLockService = distributedJobLockService;
this.instanceMetadata = instanceMetadata;
this.taskProgressLightAssembler = taskProgressLightAssembler;
this.userApiSecretService = userApiSecretService;
}
@Override
protected String moduleType() {
return MODULE_TYPE;
}
/**
* 本支回传准入走 DB(底座 javadoc 点的「AppearancePatent/Publish/CollectData 一派」)。
* 现由 {@code prepareSubmittedChunk} 经 {@link #requireSubmissionTask} 真实调用——
* 那一格此前是四行内联 {@code selectById + 模块校验 +「任务不存在」},逐字同形。
*/
@Override
protected FileTaskEntity loadTaskForSubmission(Long taskId) {
return fileTaskMapper.selectById(taskId);
}
public AppearancePatentParseVo parseAndCreateTask(AppearancePatentParseRequest request, String deviceId) {
long startedAt = System.nanoTime();
if (request.getUserId() == null || request.getUserId() <= 0) {
throw new BusinessException("user_id 不合法");
}
requireUserId(request.getUserId());
if (request.getFiles() == null || request.getFiles().isEmpty()) {
throw new BusinessException("请先上传 Excel 文件");
}
@@ -192,26 +246,13 @@ public class AppearancePatentTaskService {
int groupCount = countParsedGroups(allRows);
long groupedAt = System.nanoTime();
FileTaskEntity task = new FileTaskEntity();
task.setTaskNo(MODULE_TYPE + "-" + IdUtil.getSnowflakeNextIdStr());
task.setModuleType(MODULE_TYPE);
task.setTaskMode("PYTHON_QUEUE");
task.setStatus(STATUS_PENDING);
task.setSourceFileCount(sourceFiles.size());
FileTaskEntity task = newTaskHeader(STATUS_PENDING, "PYTHON_QUEUE", request.getUserId(), deviceId,
sourceFiles.size());
task.setSuccessFileCount(0);
task.setFailedFileCount(0);
task.setCreatedBy("user:" + request.getUserId());
task.setUserId(request.getUserId());
task.setDeviceId(AdminAuthSupport.normalizeDeviceId(deviceId));
task.setCreatedAt(LocalDateTime.now());
task.setUpdatedAt(LocalDateTime.now());
try {
task.setRequestJson(objectMapper.writeValueAsString(request));
task.setResultJson("{}");
} catch (Exception ex) {
throw new BusinessException("序列化解析结果失败");
}
fileTaskMapper.insert(task);
task.setRequestJson(writeJson(objectMapper, request, "序列化解析结果失败"));
task.setResultJson("{}");
insertTask(task);
long taskInsertedAt = System.nanoTime();
String aggregateScopeKey = buildAggregateScopeKey(sourceFiles);
@@ -225,14 +266,9 @@ public class AppearancePatentTaskService {
fileTaskMapper.updateById(task);
String sourceFilename = buildAggregateSourceFilenameLabel(sourceFiles);
FileResultEntity result = new FileResultEntity();
result.setTaskId(task.getId());
result.setModuleType(MODULE_TYPE);
result.setSourceFilename(sourceFilename);
result.setSourceFileUrl(aggregateScopeKey);
result.setRowCount(allRows.size());
result.setUserId(request.getUserId());
result.setCreatedAt(LocalDateTime.now());
// rowCount 记接受行数、success 留 NULL(本支建单不写占位值),这两列底座刻意不替它定
FileResultEntity result = newScopeRow(task.getId(), request.getUserId(), sourceFilename,
aggregateScopeKey, allRows.size(), null);
fileResultMapper.insert(result);
TaskScopeStateEntity scope = new TaskScopeStateEntity();
@@ -240,7 +276,7 @@ public class AppearancePatentTaskService {
scope.setModuleType(MODULE_TYPE);
scope.setScopeKey(aggregateScopeKey);
scope.setScopeHash(sourceScopeHash);
scope.setParsedPayloadJson(writeJson(parsedPayloadPointer, "保存解析载荷指针失败"));
scope.setParsedPayloadJson(writeJson(objectMapper, parsedPayloadPointer, "保存解析载荷指针失败"));
scope.setStateJson("{\"phase\":\"PARSED\"}");
scope.setChunkTotal(0);
scope.setReceivedChunkCount(0);
@@ -506,7 +542,7 @@ public class AppearancePatentTaskService {
.last("limit 1"));
if (existing == null) {
List<AppearancePatentResultRowDto> rawRows = flattenSubmittedRows(request);
String payloadJson = writeJson(rawRows, "结果序列化失败");
String payloadJson = writeJson(objectMapper, rawRows, "结果序列化失败");
TaskChunkEntity chunk = new TaskChunkEntity();
chunk.setTaskId(taskId);
@@ -833,10 +869,7 @@ public class AppearancePatentTaskService {
* 重复 chunk(查重命中)时不做存储与哈希,落库由 persist 按同一查重短路。
*/
private PreparedSubmittedChunk prepareSubmittedChunk(Long taskId, AppearancePatentSubmitResultRequest request) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType())) {
throw new BusinessException("任务不存在");
}
FileTaskEntity task = requireSubmissionTask(taskId);
ensureTaskOwnedByCurrentInstance(task, "submit result");
int chunkIndex = request.getChunkIndex() == null ? 0 : request.getChunkIndex();
int chunkTotal = request.getChunkTotal() == null ? 1 : request.getChunkTotal();
@@ -855,7 +888,7 @@ public class AppearancePatentTaskService {
request.getError(), null, null, null);
}
List<AppearancePatentResultRowDto> rawRows = flattenSubmittedRows(request);
String payloadJson = writeJson(rawRows, "结果序列化失败");
String payloadJson = writeJson(objectMapper, rawRows, "结果序列化失败");
String storedPayload = storeSharedChunkPayload(taskId, scopeHash, chunkIndex, payloadJson);
return new PreparedSubmittedChunk(task, scopeKey, scopeHash, chunkIndex, chunkTotal, done,
request.getError(), payloadJson, storedPayload, DigestUtil.sha256Hex(payloadJson));
@@ -1503,7 +1536,7 @@ public class AppearancePatentTaskService {
}
persistedRows.put(key, row);
}
String payloadJson = writeJson(new ArrayList<>(persistedRows.values()), "appearance patent chunk payload merge failed");
String payloadJson = writeJson(objectMapper, new ArrayList<>(persistedRows.values()), "appearance patent chunk payload merge failed");
String oldPayload = chunk.getPayloadJson();
String oldPayloadHash = chunk.getPayloadHash();
String newPayloadHash = DigestUtil.sha256Hex(payloadJson);
@@ -2083,7 +2116,8 @@ public class AppearancePatentTaskService {
return job == null || isOwnerCurrent(ownerFromScopeKey(job.getScopeKey()));
}
private void ensureTaskOwnedByCurrentInstance(FileTaskEntity task, String operation) {
@Override
protected void ensureTaskOwnedByCurrentInstance(FileTaskEntity task, String operation) {
String owner = ownerFromTask(task);
if (isOwnerCurrent(owner)) {
return;
@@ -2137,20 +2171,6 @@ public class AppearancePatentTaskService {
return owner.isBlank() ? null : owner;
}
private String abbreviate(String value, int maxLength) {
if (value == null) {
return "";
}
int normalizedMaxLength = Math.max(0, maxLength);
if (value.length() <= normalizedMaxLength) {
return value;
}
if (normalizedMaxLength <= 3) {
return value.substring(0, normalizedMaxLength);
}
return value.substring(0, normalizedMaxLength - 3) + "...";
}
private void saveFileBuildProgress(FileTaskEntity task,
TaskFileJobEntity job,
int total,
@@ -2652,21 +2672,6 @@ public class AppearancePatentTaskService {
return keys;
}
private Set<String> resultLookupKeysForResultRows(List<AppearancePatentResultRowDto> rows) {
Set<String> keys = new LinkedHashSet<>();
for (AppearancePatentResultRowDto row : rows == null ? List.<AppearancePatentResultRowDto>of() : rows) {
String primary = rowKey(row);
if (!primary.isBlank()) {
keys.add(primary);
}
String legacy = legacyRowKey(row);
if (!legacy.isBlank()) {
keys.add(legacy);
}
}
return keys;
}
private void appendRequestedResultRows(Map<String, AppearancePatentResultRowDto> sink,
Iterable<AppearancePatentResultRowDto> rows,
Set<String> requestedKeys) {
@@ -2985,10 +2990,6 @@ public class AppearancePatentTaskService {
return historyAssembler().historyActivityTime(row, task, job);
}
private boolean isHistoryFileBuilding(FileResultEntity row, String taskStatus, TaskFileJobEntity job) {
return historyAssembler().isHistoryFileBuilding(row, taskStatus, job);
}
private String fmt(LocalDateTime t) {
return t == null ? null : t.toString();
}
@@ -3010,7 +3011,7 @@ public class AppearancePatentTaskService {
payload.setItems(List.of());
payload.setGroups(List.of());
payload.setAllItems(allRows == null ? List.of() : allRows);
return writeJson(payload, "保存解析结果失败");
return writeJson(objectMapper, payload, "保存解析结果失败");
}
private String buildTaskResultJson(String aiPrompt, String apiKey, List<AppearancePatentSourceFileDto> sourceFiles, String parsedPayloadPointer) {
@@ -3023,7 +3024,7 @@ public class AppearancePatentTaskService {
.toList());
payload.put("parsedPayloadRef", parsedPayloadPointer);
payload.put("ownerInstanceId", currentInstanceId());
return writeJson(payload, "保存任务结果索引失败");
return writeJson(objectMapper, payload, "保存任务结果索引失败");
}
private String storeParsedPayload(Long taskId, String scopeHash, String parsedPayloadJson) {
@@ -3240,14 +3241,6 @@ public class AppearancePatentTaskService {
return safe.isBlank() ? "appearance-patent" : safe;
}
private String writeJson(Object value, String message) {
try {
return objectMapper.writeValueAsString(value);
} catch (Exception ex) {
throw new BusinessException(message);
}
}
/** 只读收集任务范围/分片载荷指针,供事务提交后做远端删除。 */
private List<String> collectTransientTaskPayloads(Long taskId) {
if (taskId == null || taskId <= 0) {
@@ -94,7 +94,15 @@ class CatchSilenceRatchetTest {
// 四份逐字同名件并成一份 ⇒ 树里少了一处「异常会往外走」的**实例**,不是少了一种会外走的异常;
// 本笔只从树上摘掉这一处 RETHROW 形状的 catch,不重抛侧一个字节没动:同批实测 notRethrow 562、
// logOnly 173、empty 55 三格仍在上限内(未涨)=> 没有任何一处出口被改回吞掉。
static final int RETHROW_FLOOR = 385;
// 10-19 再下调 385 -> 383,出处点名(同一项用户授权「逐处记名调这一格」的第二笔,形状与上一笔逐字相同):
// Phase 3 的 3A 迁移把 AppearancePatentTaskService 的两处同名序列化 catch 并进底座
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,7 个调用点的文案逐字
// 带到调用点);② 建单里那段 `try { setRequestJson(writeValueAsString(request)) … } catch (Exception ex)
// { throw new BusinessException("序列化解析结果失败") }`,失败形状与线协议一字未动。
// 本笔另摘的三枚零调用私有件(abbreviate/resultLookupKeysForResultRows/isHistoryFileBuilding)
// 里没有 catch,所以 RETHROW 只降这两格;不重抛/只 log/空体三格同批复跑未涨(三格判据一条没放宽)。
static final int RETHROW_FLOOR = 383;
/**
* 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉):
* 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为
@@ -224,6 +224,31 @@ class TaskServiceWiringSliceTest {
@Bean InstanceMetadata instanceMetadata() {
return mock(InstanceMetadata.class);
}
// ---- 3A 迁进来的 AppearancePatent 那一支(22 枚依赖;家族里第一个「缓存服务不接底座抽象」的形状)----
@Bean com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient appearancePatentLlmClient() {
return mock(com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient.class);
}
@Bean com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskCacheService appearancePatentTaskCacheService() {
return mock(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskCacheService.class);
}
@Bean com.nanri.aiimage.config.AppearancePatentProperties appearancePatentProperties() {
return mock(com.nanri.aiimage.config.AppearancePatentProperties.class);
}
@Bean com.nanri.aiimage.config.StorageProperties storageProperties() {
return mock(com.nanri.aiimage.config.StorageProperties.class);
}
@Bean com.nanri.aiimage.common.service.DistributedJobLockService distributedJobLockService() {
return mock(com.nanri.aiimage.common.service.DistributedJobLockService.class);
}
@Bean com.nanri.aiimage.modules.usersecret.service.UserApiSecretService userApiSecretService() {
return mock(com.nanri.aiimage.modules.usersecret.service.UserApiSecretService.class);
}
}
private static AnnotationConfigApplicationContext context(Class<?>... services) {
@@ -258,14 +283,18 @@ class TaskServiceWiringSliceTest {
@Test
void migratedServicesInstantiateThroughTheSpringContainer() {
try (AnnotationConfigApplicationContext ctx = context(ShopMatchTaskService.class,
PriceTrackTaskService.class, ShopDataCrawlTaskService.class)) {
PriceTrackTaskService.class, ShopDataCrawlTaskService.class,
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class)) {
ShopMatchTaskService shopMatch = ctx.getBean(ShopMatchTaskService.class);
PriceTrackTaskService priceTrack = ctx.getBean(PriceTrackTaskService.class);
ShopDataCrawlTaskService shopDataCrawl = ctx.getBean(ShopDataCrawlTaskService.class);
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService appearancePatent =
ctx.getBean(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class);
assertNotNull(shopMatch, "Lombok 生成枚换成显式枚之后,Spring 仍要能隐式构造注入");
assertNotNull(priceTrack);
assertNotNull(shopDataCrawl, "3B 那张 23 枚的参数表也得被容器原样解开");
assertNotNull(appearancePatent, "3A 这张 22 枚的参数表同理——它比 3B 少一枚,风险一样");
assertTrue(shopMatch instanceof AbstractShopPayloadTaskPipeline,
"Phase 3 的判据是「真有生产调用方继承底座」,不是只由单测证明契约可用");
assertTrue(priceTrack instanceof AbstractShopPayloadTaskPipeline);
@@ -274,20 +303,27 @@ class TaskServiceWiringSliceTest {
// 收尾闸门)这条断言当场红——注意不能用 !(x instanceof 家族层):静态类型不可能成立时 javac 直接拒。
assertEquals(com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline.class,
shopDataCrawl.getClass().getSuperclass(), "本支的直接父类必须是底座那一层");
// 3A 同一条:外观专利是 chunk+scope 族,与 shop-payload 家族层无关;接错层就会把它的
// 「按 submissionId 分片」当成「按店铺分片」,那是一整段合并语义的替换。
assertEquals(com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline.class,
appearancePatent.getClass().getSuperclass(), "外观专利的直接父类必须是底座那一层");
}
}
@Test
void superCallLandsTheFiveBaseDependenciesInOrder() {
try (AnnotationConfigApplicationContext ctx = context(ShopMatchTaskService.class,
PriceTrackTaskService.class, ShopDataCrawlTaskService.class)) {
PriceTrackTaskService.class, ShopDataCrawlTaskService.class,
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class)) {
ShopMatchTaskService shopMatch = ctx.getBean(ShopMatchTaskService.class);
PriceTrackTaskService priceTrack = ctx.getBean(PriceTrackTaskService.class);
ShopDataCrawlTaskService shopDataCrawl = ctx.getBean(ShopDataCrawlTaskService.class);
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService appearancePatent =
ctx.getBean(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class);
// 这五枚是交给 super(...) 的那五枚。参数表里它们与其余 12/13 枚同类型不重复,
// 换位会在编译期就被挡住——但「少交一枚」「交 null」不会。逐枚 assertSame 才是硬证。
for (Object service : List.of(shopMatch, priceTrack, shopDataCrawl)) {
for (Object service : List.of(shopMatch, priceTrack, shopDataCrawl, appearancePatent)) {
assertSame(ctx.getBean(FileTaskMapper.class), fieldValue(service, "fileTaskMapper"));
assertSame(ctx.getBean(FileResultMapper.class), fieldValue(service, "fileResultMapper"));
assertSame(ctx.getBean(TaskDistributedLockService.class),
@@ -296,6 +332,25 @@ class TaskServiceWiringSliceTest {
assertSame(ctx.getBean(OssStorageService.class), fieldValue(service, "ossStorageService"));
}
// 3A 的私有件:本支把 fileTaskMapper 等五枚交出去后自己不再持有同名字段,
// 所以这里断的是它**自己那 17 枚**里最容易被同族串位的三枚。
assertSame(ctx.getBean(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskCacheService.class),
fieldValue(appearancePatent, "taskCacheService"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient.class),
fieldValue(appearancePatent, "llmClient"));
assertSame(ctx.getBean(com.nanri.aiimage.config.AppearancePatentProperties.class),
fieldValue(appearancePatent, "properties"));
assertSame(ctx.getBean(TaskChunkMapper.class), fieldValue(appearancePatent, "taskChunkMapper"));
assertSame(ctx.getBean(TaskScopeStateMapper.class), fieldValue(appearancePatent, "taskScopeStateMapper"));
assertSame(ctx.getBean(TransientPayloadStorageService.class),
fieldValue(appearancePatent, "transientPayloadStorageService"));
assertSame(ctx.getBean(PlatformTransactionManager.class), fieldValue(appearancePatent, "transactionManager"));
assertSame(ctx.getBean(com.nanri.aiimage.common.service.DistributedJobLockService.class),
fieldValue(appearancePatent, "distributedJobLockService"));
assertSame(ctx.getBean(InstanceMetadata.class), fieldValue(appearancePatent, "instanceMetadata"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.usersecret.service.UserApiSecretService.class),
fieldValue(appearancePatent, "userApiSecretService"));
// 三支各自的私有件:绝不能把 A 支的缓存服务注进 B 支(同族三个 bean,最容易串的就是这儿)
assertSame(ctx.getBean(ShopMatchTaskCacheService.class), fieldValue(shopMatch, "shopMatchTaskCacheService"));
assertSame(ctx.getBean(PriceTrackTaskCacheService.class), fieldValue(priceTrack, "priceTrackTaskCacheService"));