refactor(phase-3): 3C 第六支接入底座——八件十一点,接不上的七格逐格立账

CollectDataService extends AbstractFileTaskPipeline<CollectDataResultRowVo>:
@RequiredArgsConstructor 换成显式 29 枚构造子(参数表逐枚沿用原字段声明序,
两处 29 枚实参的测试调用点一个字未改),五枚底座依赖交 super;钩子两枚
moduleType()/loadTaskForSubmission()(DB 直读派)。

接上的公共件(八件十一点):newTaskHeader/insertTask/newScopeRow×2(建单结果行
+ ensureTaskResult 补建行)/requireSubmissionTask×2(锁外预检+锁内复核,全族
第一次同一格被一支用两次)/rejectTerminalSubmission(IDEMPOTENT)×2/
enqueueResultAssembly。锁外那格的 warn 留在调用点(底座件刻意不打日志)。

接不上、逐格留本地写法并写明理由:admitSubmission 整段(本支两段准入、那一格一次
走完);requireUserId(现网把 request 空判与 userId 非法合并成同一格判据);
requireTaskId(本支没有那一格,golden 已证);acquireSubmissionLockOrThrow(文案
差一个字、warn 还带 waitMillis);listScopeRows(本支要 limit 1 首行);
publishResultFile(底座把上传捆在写列内,本支现网先上传→persistStats→再写列,
那条时序是注释里立着的自愈前提);writeJson 两处未并(要 RETHROW_FLOOR 383→381
的逐处记名授权,本笔未动门禁)。

行数账:显式构造子+钩子 ≈+65、②抵掉 22 ⇒ 本支棘轮 2080→2123(+43),对在册
基线 2209 仍净减 86;基线一格未改、--write 未跑。额度来源是上一笔 A 聚类抽件的
−129,抵平因此跨了两笔,这一点如实登记。

装配面:TaskServiceWiringSliceTest 补第六支——真容器起六支、本支 24 枚私有件逐枚
assertSame、并断言本支不再留 taskFileJobService 同名字段;moduleType() 第五个读数
assemble("COLLECT_DATA")。

门禁:定向 341 例/0 红/2 skipped;wiring 5 例/0 红;后端全量 4528 例/0 红/
14 skipped/BUILD SUCCESS(真实 rc=0,用例数与上一读数相同——本笔只加断言不加
方法);两套 golden 非写模式逐字节复现;ops ruff All checks passed、readability
棘轮 9 passed;格式步未纳管 ⇒ 如实跳过。真机启动验收本格仍欠。
This commit is contained in:
2026-10-19 15:33:50 +08:00
parent 0168a30ae4
commit e6853a0e4f
2 changed files with 243 additions and 58 deletions
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.collectdata.service;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.crypto.digest.DigestUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -10,7 +9,6 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessCodes;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.util.ExcelStreamReader;
import com.nanri.aiimage.modules.asincache.service.AsinResultCacheService;
import com.nanri.aiimage.modules.collectdata.mapper.CollectDataCountryPrefMapper;
@@ -65,7 +63,6 @@ import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import lombok.RequiredArgsConstructor;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
@@ -98,11 +95,11 @@ import java.util.regex.Pattern;
import com.nanri.aiimage.modules.task.model.vo.TaskProgressLightBatchVo;
import com.nanri.aiimage.modules.task.service.TaskProgressLightAssembler;
import com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy;
import com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline;
@Service
@RequiredArgsConstructor
@Slf4j
public class CollectDataService {
public class CollectDataService extends AbstractFileTaskPipeline<CollectDataResultRowVo> {
public static final String MODULE_TYPE = "COLLECT_DATA";
@@ -147,20 +144,15 @@ public class CollectDataService {
private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
private final LocalFileStorageService localFileStorageService;
private final FileTaskMapper fileTaskMapper;
private final FileResultMapper fileResultMapper;
private final CollectDataItemMapper collectDataItemMapper;
private final CollectDataCountryPrefMapper collectDataCountryPrefMapper;
private final InvalidAsinDataMapper invalidAsinDataMapper;
private final TaskChunkMapper taskChunkMapper;
private final TaskScopeStateMapper taskScopeStateMapper;
private final TaskResultItemMapper taskResultItemMapper;
private final TaskDistributedLockService taskDistributedLockService;
private final TaskFileJobService taskFileJobService;
private final TaskHeartbeatPositionService taskHeartbeatPositionService;
private final TransientPayloadStorageService transientPayloadStorageService;
private final CollectDataExcelAssemblyService excelAssemblyService;
private final OssStorageService ossStorageService;
private final ObjectMapper objectMapper;
private final TransactionTemplate transactionTemplate;
private final DistributedJobLockService distributedJobLockService;
@@ -198,6 +190,86 @@ public class CollectDataService {
*/
private final StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy;
/**
* 显式构造子取代 {@code @RequiredArgsConstructor}:参数表<b>逐枚沿用原字段声明序</b>,
* 只是把交给底座的五枚(两支 Mapper+锁+Job+对象存储)转给 {@code super}——
* 这样 {@code CollectDataSnapshotTest}/{@code CollectDataSubmitResultSnapshotTest} 那两处
* 29 枚实参的调用点一个字都不用改(改顺序等于让 golden 的夹具与被测件重排,白增风险)。
* 逐枚接线由 {@code TaskServiceWiringSliceTest} 钉。
*/
public CollectDataService(LocalFileStorageService localFileStorageService,
FileTaskMapper fileTaskMapper,
FileResultMapper fileResultMapper,
CollectDataItemMapper collectDataItemMapper,
CollectDataCountryPrefMapper collectDataCountryPrefMapper,
InvalidAsinDataMapper invalidAsinDataMapper,
TaskChunkMapper taskChunkMapper,
TaskScopeStateMapper taskScopeStateMapper,
TaskResultItemMapper taskResultItemMapper,
TaskDistributedLockService taskDistributedLockService,
TaskFileJobService taskFileJobService,
TaskHeartbeatPositionService taskHeartbeatPositionService,
TransientPayloadStorageService transientPayloadStorageService,
CollectDataExcelAssemblyService excelAssemblyService,
OssStorageService ossStorageService,
ObjectMapper objectMapper,
TransactionTemplate transactionTemplate,
DistributedJobLockService distributedJobLockService,
CollectDataBatchQuery collectDataBatchQuery,
CollectDataBrandBatchFilter brandBatchFilter,
CollectDataInvalidAsinBatchWriter invalidAsinBatchWriter,
CollectDataResultDetailCodec resultDetailCodec,
CollectDataResultItemBatchWriter resultItemBatchWriter,
CollectDataResultDetailReader resultDetailReader,
TaskProgressLightAssembler taskProgressLightAssembler,
NotificationDispatchService notificationDispatchService,
AsinResultCacheService asinResultCacheService,
CollectDataBrandRecheckService collectDataBrandRecheckService,
StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy) {
super(fileTaskMapper, fileResultMapper, taskDistributedLockService, taskFileJobService, ossStorageService);
this.localFileStorageService = localFileStorageService;
this.collectDataItemMapper = collectDataItemMapper;
this.collectDataCountryPrefMapper = collectDataCountryPrefMapper;
this.invalidAsinDataMapper = invalidAsinDataMapper;
this.taskChunkMapper = taskChunkMapper;
this.taskScopeStateMapper = taskScopeStateMapper;
this.taskResultItemMapper = taskResultItemMapper;
this.taskHeartbeatPositionService = taskHeartbeatPositionService;
this.transientPayloadStorageService = transientPayloadStorageService;
this.excelAssemblyService = excelAssemblyService;
this.objectMapper = objectMapper;
this.transactionTemplate = transactionTemplate;
this.distributedJobLockService = distributedJobLockService;
this.collectDataBatchQuery = collectDataBatchQuery;
this.brandBatchFilter = brandBatchFilter;
this.invalidAsinBatchWriter = invalidAsinBatchWriter;
this.resultDetailCodec = resultDetailCodec;
this.resultItemBatchWriter = resultItemBatchWriter;
this.resultDetailReader = resultDetailReader;
this.taskProgressLightAssembler = taskProgressLightAssembler;
this.notificationDispatchService = notificationDispatchService;
this.asinResultCacheService = asinResultCacheService;
this.collectDataBrandRecheckService = collectDataBrandRecheckService;
this.staleTaskHeartbeatPolicy = staleTaskHeartbeatPolicy;
}
@Override
protected String moduleType() {
return MODULE_TYPE;
}
/**
* 加载派别=DB 直读(与 AppearancePatent/Publish 同派,见底座 {@code loadTaskForSubmission} 注释)。
* 整段 {@code admitSubmission} 套不上:本支是七支里唯一<b>准入两次</b>的(锁外预检+锁内复核),
* 而那一格一次走完;锁外那次还要在抛之前 warn 一句现网文案,底座件刻意不打日志。
* 泛型 {@code T} 取回传行类型 {@link CollectDataResultRowVo}(本支没有模块缓存服务,
* {@code taskCacheService()} 用底座默认的 null,心跳那一格没有承接件)。
*/
@Override
protected FileTaskEntity loadTaskForSubmission(Long taskId) {
return fileTaskMapper.selectById(taskId);
}
@Value("${aiimage.collect-data.stale-timeout-minutes:30}")
private long staleTimeoutMinutes;
@@ -323,19 +395,10 @@ public class CollectDataService {
List<ParsedRow> parsedRows,
String aggregateFilename,
String deviceId) {
FileTaskEntity task = new FileTaskEntity();
task.setTaskNo(MODULE_TYPE + "-" + IdUtil.getSnowflakeNextIdStr());
task.setModuleType(MODULE_TYPE);
task.setTaskMode("PYTHON_QUEUE");
task.setStatus(STATUS_PENDING);
task.setSourceFileCount(sources.size());
FileTaskEntity task = newTaskHeader(STATUS_PENDING, "PYTHON_QUEUE", request.getUserId(), deviceId,
sources.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 {
Map<String, Object> requestPayload = new LinkedHashMap<>();
requestPayload.put("userId", request.getUserId());
@@ -358,7 +421,7 @@ public class CollectDataService {
} catch (Exception ex) {
throw new BusinessException("序列化任务信息失败");
}
fileTaskMapper.insert(task);
insertTask(task);
int rowIndex = 0;
LocalDateTime itemCreatedAt = LocalDateTime.now();
@@ -390,14 +453,8 @@ public class CollectDataService {
collectDataItemMapper.insertBatch(itemBatch);
}
FileResultEntity result = new FileResultEntity();
result.setTaskId(task.getId());
result.setModuleType(MODULE_TYPE);
result.setSourceFilename(aggregateFilename);
result.setSourceFileUrl(buildAggregateSourceFileUrl(sources));
result.setRowCount(parsedRows.size());
result.setUserId(request.getUserId());
result.setCreatedAt(LocalDateTime.now());
FileResultEntity result = newScopeRow(task.getId(), request.getUserId(), aggregateFilename,
buildAggregateSourceFileUrl(sources), parsedRows.size(), null);
fileResultMapper.insert(result);
return new PersistedParse(task, result);
@@ -745,14 +802,11 @@ public class CollectDataService {
// 锁外预检:任务不存在/已结束时立即失败,不为终态任务白跑去重查询与品牌检测。
// 只做快速失败,并发正确性仍由锁内的重读复核保证。
FileTaskEntity probe = fileTaskMapper.selectById(taskId);
if (probe == null || !MODULE_TYPE.equals(probe.getModuleType())) {
throw new BusinessException("任务不存在");
}
FileTaskEntity probe = requireSubmissionTask(taskId);
if (STATUS_SUCCESS.equals(probe.getStatus()) || STATUS_FAILED.equals(probe.getStatus())) {
log.warn("[collect-data] 任务已结束,拒绝重复提交 taskId={} status={}", taskId, probe.getStatus());
throw new BusinessException(40901, "任务已结束,拒绝重复提交");
}
rejectTerminalSubmission(probe.getStatus(), TerminalRejection.IDEMPOTENT);
// 归一化 / 去重过滤 / 品牌检测放在锁外:品牌检测是同步远程调用,上游 16890 抖动时
// 单品牌 10 次重试合计上百秒(taskId 28599 实测:chunk 回传在锁内等品牌检测 103.5 秒,
@@ -786,13 +840,8 @@ public class CollectDataService {
collectDataBrandRecheckService.enqueue(probe, brandOutcome.queryFailed());
try (TaskDistributedLockService.LockHandle ignored = acquireTaskLockOrThrow(taskId)) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType())) {
throw new BusinessException("任务不存在");
}
if (STATUS_SUCCESS.equals(task.getStatus()) || STATUS_FAILED.equals(task.getStatus())) {
throw new BusinessException(40901, "任务已结束,拒绝重复提交");
}
FileTaskEntity task = requireSubmissionTask(taskId);
rejectTerminalSubmission(task.getStatus(), TerminalRejection.IDEMPOTENT);
if (!STATUS_RUNNING.equals(task.getStatus())) {
task.setStatus(STATUS_RUNNING);
task.setUpdatedAt(LocalDateTime.now());
@@ -904,13 +953,7 @@ public class CollectDataService {
if (result != null) {
return result;
}
result = new FileResultEntity();
result.setTaskId(task.getId());
result.setModuleType(MODULE_TYPE);
result.setSourceFilename("");
result.setRowCount(0);
result.setUserId(task.getUserId());
result.setCreatedAt(LocalDateTime.now());
result = newScopeRow(task.getId(), task.getUserId(), "", null, 0, null);
fileResultMapper.insert(result);
return result;
}
@@ -1009,7 +1052,7 @@ public class CollectDataService {
fileResultMapper.updateById(result);
task.setUpdatedAt(LocalDateTime.now());
fileTaskMapper.updateById(task);
taskFileJobService.enqueueAssembleResult(task.getId(), MODULE_TYPE, result.getId(), "task:" + task.getId());
enqueueResultAssembly(task.getId(), result.getId(), "task:" + task.getId());
}
private void markTaskFailed(FileTaskEntity task, FileResultEntity result, String error, CollectDataStats stats) {
@@ -67,13 +67,16 @@ import static org.mockito.Mockito.verifyNoInteractions;
* Phase 3 动了 {@code @Service} 的**构造器形状**(Lombok {@code @RequiredArgsConstructor} 生成枚
* → 手写的显式枚,还要把 5 枚交给 {@code super})——这正是「装配相邻」的改动,光靠单测说不过去。
* 本切片不连数据库,但走的是**真的 Spring 构造器解析**:隐式单构造器注入是否成立、
* 底座那 5 枚是否真从 {@code super(...)} 落进来、五支是否各自拿到自己的缓存服务与装配服务。
* 底座那 5 枚是否真从 {@code super(...)} 落进来、六支是否各自拿到自己的缓存服务与装配服务。
* 3B 把第三支({@code ShopDataCrawlTaskService},23 枚依赖)也接进来时,本切片顺带钉住
* 「它继承的是底座、不是 shop-payload 家族层」这条按证据得出的结论——家族层模板会改掉它的准入步序
* 与收尾闸门,误套上去这里当场红。3A/3E 又各加了第四、第五支,同一格判据沿用;
* 与收尾闸门,误套上去这里当场红。3A/3E/3C 又各加了第四、第五、第六支,同一格判据沿用;
* 其中两支({@code AppearancePatentTaskCacheService}/{@code DeleteBrandTaskCacheService})的缓存服务
* <b>不</b>继承 {@code AbstractModuleTaskCacheService},所以 {@code taskCacheService()} 那枚钩子
* 在它们身上必须是缺件(底座 javadoc 已按实测更正过),别指望这里出现「心跳接上」的断言。
* 3C 的 {@code CollectDataService} 是第三种形状:本支<b>没有</b>模块缓存服务(它有的是
* {@code AsinResultCacheService},那是跨任务 ASIN 结论缓存、不是任务缓存),
* {@code taskCacheService()} 用底座默认的 {@code null} ⇒ 回传段一次心跳都不打,与现网一致。
*
* <p><b>为什么不只断言「refresh() 没抛异常」。</b>那是一句会说谎的判据:Spring 6 在没有
* {@code @Autowired} 而存在多枚 public 构造器时,会**静默挑无参那一枚**,容器照样起得来、
@@ -265,6 +268,72 @@ class TaskServiceWiringSliceTest {
@Bean com.nanri.aiimage.config.DeleteBrandProgressProperties deleteBrandProgressProperties() {
return mock(com.nanri.aiimage.config.DeleteBrandProgressProperties.class);
}
// ---- 3C 迁进来的 CollectData 那一支(24 枚私有依赖=全族最长的一张参数表)----
@Bean com.nanri.aiimage.modules.collectdata.mapper.CollectDataItemMapper collectDataItemMapper() {
return mock(com.nanri.aiimage.modules.collectdata.mapper.CollectDataItemMapper.class);
}
@Bean com.nanri.aiimage.modules.collectdata.mapper.CollectDataCountryPrefMapper collectDataCountryPrefMapper() {
return mock(com.nanri.aiimage.modules.collectdata.mapper.CollectDataCountryPrefMapper.class);
}
@Bean com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper invalidAsinDataMapper() {
return mock(com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper.class);
}
@Bean com.nanri.aiimage.modules.task.mapper.TaskResultItemMapper taskResultItemMapper() {
return mock(com.nanri.aiimage.modules.task.mapper.TaskResultItemMapper.class);
}
@Bean com.nanri.aiimage.modules.collectdata.service.CollectDataExcelAssemblyService collectDataExcelAssemblyService() {
return mock(com.nanri.aiimage.modules.collectdata.service.CollectDataExcelAssemblyService.class);
}
@Bean com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckService collectDataBrandRecheckService() {
return mock(com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckService.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataBatchQuery collectDataBatchQuery() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataBatchQuery.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter collectDataBrandBatchFilter() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataInvalidAsinBatchWriter collectDataInvalidAsinBatchWriter() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataInvalidAsinBatchWriter.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailCodec collectDataResultDetailCodec() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailCodec.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataResultItemBatchWriter collectDataResultItemBatchWriter() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataResultItemBatchWriter.class);
}
@Bean com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailReader collectDataResultDetailReader() {
return mock(com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailReader.class);
}
@Bean com.nanri.aiimage.modules.notification.service.NotificationDispatchService notificationDispatchService() {
return mock(com.nanri.aiimage.modules.notification.service.NotificationDispatchService.class);
}
@Bean com.nanri.aiimage.modules.asincache.service.AsinResultCacheService asinResultCacheService() {
return mock(com.nanri.aiimage.modules.asincache.service.AsinResultCacheService.class);
}
@Bean com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy staleTaskHeartbeatPolicy() {
return mock(com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy.class);
}
/** 本支建单走 {@code TransactionTemplate}(与 AP/DeleteBrand 的裸事务管理器不同派)。 */
@Bean org.springframework.transaction.support.TransactionTemplate transactionTemplate() {
return mock(org.springframework.transaction.support.TransactionTemplate.class);
}
}
private static AnnotationConfigApplicationContext context(Class<?>... services) {
@@ -293,7 +362,7 @@ class TaskServiceWiringSliceTest {
}
// ------------------------------------------------------------------
// 正判:真实容器把五支建起来,且每一枚依赖都落在它该落的位置
// 正判:真实容器把六支建起来,且每一枚依赖都落在它该落的位置
// ------------------------------------------------------------------
@Test
@@ -301,7 +370,8 @@ class TaskServiceWiringSliceTest {
try (AnnotationConfigApplicationContext ctx = context(ShopMatchTaskService.class,
PriceTrackTaskService.class, ShopDataCrawlTaskService.class,
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class,
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class)) {
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class,
com.nanri.aiimage.modules.collectdata.service.CollectDataService.class)) {
ShopMatchTaskService shopMatch = ctx.getBean(ShopMatchTaskService.class);
PriceTrackTaskService priceTrack = ctx.getBean(PriceTrackTaskService.class);
ShopDataCrawlTaskService shopDataCrawl = ctx.getBean(ShopDataCrawlTaskService.class);
@@ -309,12 +379,15 @@ class TaskServiceWiringSliceTest {
ctx.getBean(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class);
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService deleteBrand =
ctx.getBean(com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class);
com.nanri.aiimage.modules.collectdata.service.CollectDataService collectData =
ctx.getBean(com.nanri.aiimage.modules.collectdata.service.CollectDataService.class);
assertNotNull(shopMatch, "Lombok 生成枚换成显式枚之后,Spring 仍要能隐式构造注入");
assertNotNull(priceTrack);
assertNotNull(shopDataCrawl, "3B 那张 23 枚的参数表也得被容器原样解开");
assertNotNull(appearancePatent, "3A 这张 22 枚的参数表同理——它比 3B 少一枚,风险一样");
assertNotNull(deleteBrand, "3E 这张 14 枚:本支是全族唯一 taskMode=IMMEDIATE 的一支");
assertNotNull(collectData, "3C 这张 29 枚(含交出去的 5 枚)=全族最长,换位与漏交的风险也最大");
assertTrue(shopMatch instanceof AbstractShopPayloadTaskPipeline,
"Phase 3 的判据是「真有生产调用方继承底座」,不是只由单测证明契约可用");
assertTrue(priceTrack instanceof AbstractShopPayloadTaskPipeline);
@@ -331,6 +404,10 @@ class TaskServiceWiringSliceTest {
// 按 fileIdentity 分scope),既不是 shop-payload 也不是 AP 那族;接错层的代价同上。
assertEquals(com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline.class,
deleteBrand.getClass().getSuperclass(), "删除品牌的直接父类必须是底座那一层");
// 3C:采集与 AP 同属 chunk+scope 族、接底座;接上家族层会把它的
// 「按 submissionId 分片」当成「按店铺分片」,那是一整段合并语义的替换。
assertEquals(com.nanri.aiimage.modules.task.service.pipeline.AbstractFileTaskPipeline.class,
collectData.getClass().getSuperclass(), "采集数据的直接父类必须是底座那一层");
}
}
@@ -339,7 +416,8 @@ class TaskServiceWiringSliceTest {
try (AnnotationConfigApplicationContext ctx = context(ShopMatchTaskService.class,
PriceTrackTaskService.class, ShopDataCrawlTaskService.class,
com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class,
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class)) {
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class,
com.nanri.aiimage.modules.collectdata.service.CollectDataService.class)) {
ShopMatchTaskService shopMatch = ctx.getBean(ShopMatchTaskService.class);
PriceTrackTaskService priceTrack = ctx.getBean(PriceTrackTaskService.class);
ShopDataCrawlTaskService shopDataCrawl = ctx.getBean(ShopDataCrawlTaskService.class);
@@ -347,10 +425,13 @@ class TaskServiceWiringSliceTest {
ctx.getBean(com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskService.class);
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService deleteBrand =
ctx.getBean(com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class);
com.nanri.aiimage.modules.collectdata.service.CollectDataService collectData =
ctx.getBean(com.nanri.aiimage.modules.collectdata.service.CollectDataService.class);
// 这五枚是交给 super(...) 的那五枚。参数表里它们与其余 12/13 枚同类型不重复,
// 换位会在编译期就被挡住——但「少交一枚」「交 null」不会。逐枚 assertSame 才是硬证。
for (Object service : List.of(shopMatch, priceTrack, shopDataCrawl, appearancePatent, deleteBrand)) {
for (Object service : List.of(shopMatch, priceTrack, shopDataCrawl, appearancePatent, deleteBrand,
collectData)) {
assertSame(ctx.getBean(FileTaskMapper.class), fieldValue(service, "fileTaskMapper"));
assertSame(ctx.getBean(FileResultMapper.class), fieldValue(service, "fileResultMapper"));
assertSame(ctx.getBean(TaskDistributedLockService.class),
@@ -400,6 +481,60 @@ class TaskServiceWiringSliceTest {
.getDeclaredField("fileTaskMapper"),
"底座那五枚只能有一份,本支不该再声明 fileTaskMapper");
// 3C 的 24 枚私有件逐枚点名(本支参数表最长,手写构造子里「这一行赋值指错人」是唯一的真风险)。
// 风险最高的三组:① 五枚 Mapper 都是 MyBatis-Plus 接口,串了不报错、只会把行写到别人的表里;
// ② 三支各自的 ExcelAssemblyService/两支的 LocalFileStorageService 属跨支同族;
// ③ 本支拿的是 TransactionTemplate,别支拿的是 PlatformTransactionManager——同名不同物。
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.mapper.CollectDataItemMapper.class),
fieldValue(collectData, "collectDataItemMapper"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.mapper.CollectDataCountryPrefMapper.class),
fieldValue(collectData, "collectDataCountryPrefMapper"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper.class),
fieldValue(collectData, "invalidAsinDataMapper"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.task.mapper.TaskResultItemMapper.class),
fieldValue(collectData, "taskResultItemMapper"));
assertSame(ctx.getBean(TaskChunkMapper.class), fieldValue(collectData, "taskChunkMapper"));
assertSame(ctx.getBean(TaskScopeStateMapper.class), fieldValue(collectData, "taskScopeStateMapper"));
assertSame(ctx.getBean(LocalFileStorageService.class), fieldValue(collectData, "localFileStorageService"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.service.CollectDataExcelAssemblyService.class),
fieldValue(collectData, "excelAssemblyService"), "别把别支的装配服务注进采集");
assertSame(ctx.getBean(TransientPayloadStorageService.class),
fieldValue(collectData, "transientPayloadStorageService"));
assertSame(ctx.getBean(TaskHeartbeatPositionService.class),
fieldValue(collectData, "taskHeartbeatPositionService"));
assertSame(ctx.getBean(org.springframework.transaction.support.TransactionTemplate.class),
fieldValue(collectData, "transactionTemplate"), "本支用模板,别支用裸事务管理器");
assertSame(ctx.getBean(com.nanri.aiimage.common.service.DistributedJobLockService.class),
fieldValue(collectData, "distributedJobLockService"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.task.service.StaleTaskHeartbeatPolicy.class),
fieldValue(collectData, "staleTaskHeartbeatPolicy"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataBatchQuery.class),
fieldValue(collectData, "collectDataBatchQuery"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter.class),
fieldValue(collectData, "brandBatchFilter"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataInvalidAsinBatchWriter.class),
fieldValue(collectData, "invalidAsinBatchWriter"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailCodec.class),
fieldValue(collectData, "resultDetailCodec"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataResultItemBatchWriter.class),
fieldValue(collectData, "resultItemBatchWriter"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.util.CollectDataResultDetailReader.class),
fieldValue(collectData, "resultDetailReader"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.notification.service.NotificationDispatchService.class),
fieldValue(collectData, "notificationDispatchService"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.asincache.service.AsinResultCacheService.class),
fieldValue(collectData, "asinResultCacheService"));
assertSame(ctx.getBean(com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckService.class),
fieldValue(collectData, "collectDataBrandRecheckService"));
assertSame(ctx.getBean(TaskProgressLightAssembler.class),
fieldValue(collectData, "taskProgressLightAssembler"));
assertSame(ctx.getBean(ObjectMapper.class), fieldValue(collectData, "objectMapper"));
// 交出去的那五枚同样不许在本支留同名私有字段
assertThrows(NoSuchFieldException.class,
() -> com.nanri.aiimage.modules.collectdata.service.CollectDataService.class
.getDeclaredField("taskFileJobService"),
"3C 把 taskFileJobService 交给 super 之后,本支不该再留一份(留了就读到 null)");
// 三支各自的私有件:绝不能把 A 支的缓存服务注进 B 支(同族三个 bean,最容易串的就是这儿)
assertSame(ctx.getBean(ShopMatchTaskCacheService.class), fieldValue(shopMatch, "shopMatchTaskCacheService"));
assertSame(ctx.getBean(PriceTrackTaskCacheService.class), fieldValue(priceTrack, "priceTrackTaskCacheService"));
@@ -438,28 +573,35 @@ class TaskServiceWiringSliceTest {
void injectedCollaboratorsAreActuallyUsedAndEachBranchReportsItsOwnModuleType() {
try (AnnotationConfigApplicationContext ctx = context(ShopMatchTaskService.class,
PriceTrackTaskService.class, ShopDataCrawlTaskService.class,
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class)) {
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class,
com.nanri.aiimage.modules.collectdata.service.CollectDataService.class)) {
TaskProgressLightAssembler assembler = ctx.getBean(TaskProgressLightAssembler.class);
ShopMatchTaskService shopMatch = ctx.getBean(ShopMatchTaskService.class);
PriceTrackTaskService priceTrack = ctx.getBean(PriceTrackTaskService.class);
ShopDataCrawlTaskService shopDataCrawl = ctx.getBean(ShopDataCrawlTaskService.class);
com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService deleteBrand =
ctx.getBean(com.nanri.aiimage.modules.deletebrand.service.DeleteBrandRunService.class);
com.nanri.aiimage.modules.collectdata.service.CollectDataService collectData =
ctx.getBean(com.nanri.aiimage.modules.collectdata.service.CollectDataService.class);
List<Long> taskIds = List.of(1L);
shopMatch.progressLight(taskIds, 7L);
priceTrack.progressLight(taskIds, 7L);
shopDataCrawl.progressLight(taskIds, 7L);
deleteBrand.progressLight(taskIds, 7L);
collectData.progressLight(taskIds, 7L);
// moduleType() 是迁移新加的钩子:回错一支,心跳、结果行与组装 Job 全挂到别人模块上,
// 而建单照样成功——那种错只有在这里才看得见。四支四个字符串,串一支就少一对。
// 而建单照样成功——那种错只有在这里才看得见。五支五个字符串,串一支就少一对。
verify(assembler, times(1)).assemble(eq("SHOP_MATCH"), eq(7L), eq(taskIds));
verify(assembler, times(1)).assemble(eq("PRICE_TRACK"), eq(7L), eq(taskIds));
verify(assembler, times(1)).assemble(eq("SHOP_DATA_CRAWL"), eq(7L), eq(taskIds));
// 3E:这一对同时是「底座钩子真在被迁支用到」的生产侧证据——moduleType() 由本支交出,
// 而 progressLight 走的是自家 assembler,不是底座件,所以它证明的是钩子本身接对了。
verify(assembler, times(1)).assemble(eq("DELETE_BRAND"), eq(7L), eq(taskIds));
// 3C:同一格判据的第五个读数。本支的 moduleType() 还被 listScopeRows/
// enqueueResultAssembly/requireSubmissionTask 三件共用,回错一支那三件一起挂到别人身上。
verify(assembler, times(1)).assemble(eq("COLLECT_DATA"), eq(7L), eq(taskIds));
}
}