feat(phase-5): B60 console 分页与矩阵预聚合+P1-B5/6/7/8 性能热点收口

接管另一路会话的 Phase 5 在飞件收口(5A/5C 主体由那一路落码,本笔补齐 P1-B7 与两处台账并整量验证)。

- 5A/B60:撞款 console 的行窗口在服务端真分页(响应 dup 行数 ≤ pageSize,total_dup 仍是未分页
  总数)、dupGroup 判据收归服务端单一出处(前端 dupWithinGroup 删掉,两套同名规则不再分叉)、
  排序先于切窗;后管矩阵改预聚合+列窗 40。读数(200 列 × 50 行):每行 3 店 8.4 → 5.3 → 0.7ms
  (12.4×),每行 40 店 83.7 → 18.4 → 1.8ms(45.3×)。服务端不设列窗是判断不是漏做:shops 每行
  只有 5 个标量,而矩阵的列来自已分页的行——给 shops 再加分页会把"全局指标读全集"和"列窗读本页"
  两套语义搅在一起。浏览器首屏/交互耗时本机拿不到,登记为 Phase 6 现网复量。
- P1-B6:claim 循环的父任务终态判定折成一次批量 IN(TaskFileJobBatchQueries+Mapper XML,
  铁律 1 收口在 Mapper),逐行 CAS 认领一字不动。
- P1-B5:V187 只建 idx_biz_file_task_resume_of;审计给的候选集索引**有意不建**(V184 前缀已覆盖,
  OR/IS-NULL 与 COALESCE 不可索引),判据把这条负判定钉住。真库 EXPLAIN 本机无 MySQL,顺延现网。
- P1-B8:结果载荷的对象存储删除移到 afterCommit,事务里不再做 120s 超时的网络调用。
- P1-B7:结果集读取按窗提交+收割(窗口=线程池队列容量的一半)。审计把它记成"无 limit",但截断
  是正确性错误不是性能取舍,真能收的是"整份结果集被读两遍"——一次性提交时每支 Future 把解好的
  载荷扣在自己身上直到全部收割完,峰值=结果集+另一份整副本;分窗后副本只驻留一窗。流式组装
  契约要改 4 个模块的调用方,本 Phase 未做,别读成 P1-B7 已闭环。
- SourceScanTest 台账随之登记:裸名 25 → 26、调用方 18 → 19(P1-B7 的窗口判据只能打在源码上——
  线程池只有 8 个线程,"同时开始读几行"改前改后读数相同,差异只体现在堆上,mock 数不出来)。
This commit is contained in:
2026-11-03 23:00:44 +08:00
parent fee4df5bf6
commit c8cd75cf6c
29 changed files with 1735 additions and 206 deletions
@@ -52,15 +52,46 @@ test('align_dup_console_pagination_all_lists', () => {
// 且分布/矩阵/详情常显(不足一页也显示分页器,反馈:数据少时看不到分页)。
const page = readSource('src/pages/tasks/DuplicateCheckPage.vue')
assert.match(page, /:total="distCount"/, '店铺上架分布有分页器(常显)')
assert.match(page, /:total="dupRows\.length"/, '撞款覆盖矩阵有分页器(常显)')
assert.match(page, /v-for="item in dupCardRows"/, '撞款详情卡片绑定分页切片')
assert.match(page, /:total="dupRows\.length"[\s\S]*dupCardPageSize/, '撞款详情卡片有分页器(常显)')
// B60:撞款行改由服务端切窗口,矩阵与详情卡片读同一窗 ⇒ 两个分页器必须共用同一个游标
// (各自独立翻页在"一窗"的形状下已经不可表示,留着就是界面说一套、请求发另一套)。
assert.match(page, /:total="totalDupCount"[\s\S]*:page="matrixPage"/, '撞款覆盖矩阵分页器绑服务端总数与行窗口游标')
assert.match(page, /v-for="item in dupItems"/, '撞款详情卡片绑这一窗行集')
assert.match(page, /:total="totalDupCount"[\s\S]*:page-size="matrixPageSize"/, '撞款详情卡片分页器与矩阵同游标')
assert.doesNotMatch(page, /dupCardPage/, '卡片不再自持一个分页游标(同窗就是同游标)')
assert.doesNotMatch(page, /matrixRows/, '矩阵不再客户端切片(行窗口是服务端切的)')
assert.match(page, /<OldPagination[^>]*:total="distCount"/, '分布分页器无 v-if 条件')
assert.match(page, /<OldPagination[^>]*:total="dupRows\.length"/, '矩阵/详情分页器无 v-if 条件')
assert.match(page, /<OldPagination[^>]*:total="totalDupCount"/, '矩阵/详情分页器无 v-if 条件')
assert.match(page, /v-for="group in pagedGroupStats"/, '分组说明抽屉表绑定分页切片')
assert.match(page, /:total="groupStats\.length"/, '分组说明抽屉表有分页器')
})
/**
* B60 的前后两处出口:行窗口三键要真发出去,矩阵格子要一次算完。
* 反向自证:把 api 改回不带 page/page_size、或把模板改回逐格 filter,即红。
*/
test('align_dup_console_b60_row_window_and_precomputed_cells', () => {
const api = readSource('src/pages/tasks/duplicate-console-api.ts')
assert.match(api, /page, page_size: pageSize/, 'console 请求带行窗口参数')
assert.match(api, /query\.dup_group = group/, 'console 请求带分组裁行参数')
assert.doesNotMatch(api, /多余分页参数后端忽略/, '旧注释说分页参数被后端忽略,现在后端认了')
const page = readSource('src/pages/tasks/DuplicateCheckPage.vue')
// 矩阵窗口那一层已从页面拆进 `duplicate-matrix-window.ts`(B60 之后本页顶在可读性基线的
// 超长文件名单上,只许减)。绊线跟着搬,判据一字不松:改回逐格 filter 照样红。
const matrix = readSource('src/pages/tasks/duplicate-matrix-window.ts')
assert.match(page, /useDuplicateMatrix\(/, '页面接的是矩阵窗口组合式')
assert.match(matrix, /buildMatrixCells\(/, '矩阵格子一次预聚合')
assert.match(matrix, /MATRIX_COLUMN_WINDOW = 40/, '列数有窗口上限(按列切窗)')
assert.match(page, /v-for="\(cell, index\) in row\.cells"/, '模板只读预聚合好的格子')
assert.doesNotMatch(page, /function cellCount\(/, '逐格 filter 那套函数已收掉')
assert.doesNotMatch(matrix, /function cellCount\(/, '窗口组合式里也不许再长出逐格 filter')
const service = readSource('../backend-java/src/main/java/com/nanri/aiimage/modules/shopduplicatecheck/service/ShopDataDuplicateCheckQueryService.java')
assert.match(service, /consoleData\(DuplicateScanView view, Set<String> visibleKeys, Filters filters,\s*\n?\s*int page, int pageSize, String dupGroup\)/,
'服务端 console 收行窗口与分组参数')
assert.match(service, /"total_dup", total,/, 'total_dup 是未分页总数,不是本页行数')
})
test('align_dup_console_ledger_total_preload', () => {
const page = readSource('src/pages/tasks/DuplicateCheckPage.vue')
assert.match(page, /onMounted\(\(\) => \{\s*loadConsole\(\).*loadLedger\(1\)/s, '挂载即预取台账计数')
@@ -1,10 +1,10 @@
{
"note": "readSource 钉子逐文件基线。两把尺子:pins=落在用例体内的读盘,reads=全文读点总数(含模块级夹具与 helper)。都只许减;pins 下降而 reads 没同步下降=把读盘挪出体内,不算改进。由 tests/source-pin-ratchet.test.ts 生成。",
"totals": {
"files": 253,
"cases": 1772,
"pins": 457,
"reads": 652
"files": 254,
"cases": 1778,
"pins": 458,
"reads": 656
},
"files": {
"admin-scaffold.test.ts": {
@@ -48,9 +48,9 @@
"reads": 3
},
"align-dup-console.test.ts": {
"cases": 10,
"pins": 9,
"reads": 12
"cases": 11,
"pins": 10,
"reads": 16
},
"align-edit-user-auth-guard.test.ts": {
"cases": 1,
@@ -272,8 +272,13 @@
"pins": 5,
"reads": 6
},
"dup-matrix-window.test.ts": {
"cases": 4,
"pins": 0,
"reads": 0
},
"duplicate-console.test.ts": {
"cases": 5,
"cases": 6,
"pins": 0,
"reads": 0
},
@@ -0,0 +1,183 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { buildMatrixCells, matrixCellOf, storeColumnsOf } from '../src/pages/tasks/duplicate-console-logic.ts'
import type { DuplicateItem, DuplicateOccurrence } from '../src/pages/tasks/duplicate-model.ts'
/**
* B60 撞款矩阵:预聚合的等价性与前后读数。
*
* 审计指的那件事是「每格多次全量 filter」——模板一格要付 cellCount ×2 + cellTitle(内部再
* cellCount + cellCountryDots + 每站点一次 cellCountryCount),每次都是把该行 occurrences 整份
* filter 一遍,而且**每格都新建一条文案字符串**。下面 `legacyCell` 就是页面原来那几行函数的
* 原样搬运,当"前";与新一次算完的 `buildMatrixCells`(空格按列共用一份视图)对撞:
* 先证明结果逐字相同(预聚合不是靠少算蒙过去的),再同尺量时间。
*/
function occ(asin: string, shopName: string, country: string): DuplicateOccurrence {
return {
asin,
date: '2026-09-01',
price: '',
brand: 'B',
shopName,
groupName: '',
countryCodes: [country],
country,
}
}
const shopKey = (name: string): string => (name || '').trim().toLowerCase()
interface CellView {
count: number
dots: string[]
title: string
}
/** 原页面的逐格算法(一格扫整行 occurrences 若干次,并且每格造一条文案)。 */
function legacyCellOccurrences(item: DuplicateItem, shop: string): DuplicateOccurrence[] {
const key = shopKey(shop)
return (item.occurrences || []).filter((entry) => shopKey(entry.shopName) === key)
}
function legacyCell(item: DuplicateItem, shop: string): CellView {
const count = legacyCellOccurrences(item, shop).length
const codes = new Set<string>()
for (const entry of legacyCellOccurrences(item, shop)) if (entry.country) codes.add(entry.country.toUpperCase())
const dots = [...codes]
const sites = dots.map((code) => `${code} ${legacyCellOccurrences(item, shop).filter((entry) => (entry.country || '').toUpperCase() === code).length}条`)
return {
count,
dots,
title: count ? `${shop} 在售 ${count} 条 · ${sites.join('、')}` : `${shop} 无此 ASIN`,
}
}
/** 页面现在的读法:一次取值;空格取该列那一份共用视图(不再造文案)。 */
function fastCell(cells: ReturnType<typeof buildMatrixCells>, item: DuplicateItem, shop: string, blank: CellView): CellView {
const cell = matrixCellOf(cells, item.asin, shop)
if (!cell.count) return blank
const sites = cell.sites.map((site) => `${site.code} ${site.count}条`)
return {
count: cell.count,
dots: cell.sites.map((site) => site.code),
title: sites.length ? `${shop} 在售 ${cell.count} 条 · ${sites.join('、')}` : `${shop} 在售 ${cell.count} 条`,
}
}
function fixtureItem(asin: string, shops: [string, string][]): DuplicateItem {
const occurrences = shops.map(([shop, country]) => occ(asin, shop, country))
return {
asin,
shopCount: new Set(occurrences.map((entry) => shopKey(entry.shopName))).size,
recordCount: occurrences.length,
occurrences,
}
}
function blankViews(columns: string[]): CellView[] {
return columns.map((shop) => ({ count: 0, dots: [] as string[], title: `${shop} 无此 ASIN` }))
}
/**
* 200 列 × 50 行的矩阵夹具。`shopsPerRow` 决定密度:现实中一个撞款 ASIN 落在几家到几十家店,
* 而逐格 filter 的代价正是按「行内 occurrences × 列数」乘出来的——密度越高旧算法越吃亏,
* 所以两种密度都取读数,不挑对自己有利的那一档。
*/
function matrixFixture(columns: string[], shopsPerRow: number): DuplicateItem[] {
return Array.from({ length: 50 }, (_, index) => {
const pairs: [string, string][] = []
for (let offset = 0; offset < shopsPerRow; offset++) {
const shop = columns[(index * 7 + offset * 61) % columns.length]
pairs.push([shop, 'UK'], [shop, 'DE'])
}
return fixtureItem(`B${String(index).padStart(4, '0')}`, pairs)
})
}
test('矩阵预聚合与逐格 filter 结果逐字相同', () => {
const rows = [
fixtureItem('A1', [['Shop a', 'UK'], ['Shop a', 'uk'], ['ShopB', ''], ['ShopB', 'DE']]),
fixtureItem('A2', [['ShopC', 'FR']]),
]
const columns = storeColumnsOf(rows)
const cells = buildMatrixCells(rows, columns)
const blanks = blankViews(columns)
columns.forEach((column, index) => {
for (const item of rows) {
assert.deepEqual(fastCell(cells, item, column, blanks[index]), legacyCell(item, column), `${item.asin}/${column}`)
}
})
// 每行只给「本行真涉及」的列建格:A1 涉及 2 店(大小写/空格归一后同店)+ A2 涉及 1 店。
assert.equal(cells.size, 3)
})
test('列集或行集为空时不建任何格', () => {
const rows = [fixtureItem('A1', [['ShopA', 'UK']])]
assert.equal(buildMatrixCells(rows, []).size, 0)
assert.equal(buildMatrixCells([], ['ShopA']).size, 0)
})
/** 列窗口:只给本窗点名的列建格(120 列的夹具切 40 列窗口,格子数就按 40 乘)。 */
test('列窗口切窗后每行最多铺满窗口宽度的格', () => {
const window = 40
const rows = Array.from({ length: 50 }, (_, index) =>
fixtureItem(`A${index}`, Array.from({ length: window * 3 }, (_, shop) => [`Shop${shop}`, 'UK'])))
const all = storeColumnsOf(rows)
assert.equal(all.length, window * 3, '夹具本身就有 120 列(不设上限时的形状)')
const columns = all.slice(0, window)
const cells = buildMatrixCells(rows, columns)
assert.equal(columns.length, window, '本窗只铺 40 列')
assert.equal(cells.size, rows.length * window, '窗口外的 80 列一格都不建')
})
/**
* B60 判据的读数:200 列 × 50 行,同一把尺前后各跑一遍(5 轮取最好一次——本机同时有别的路在跑,
* 单次读数能被调度噪声放大好几倍)。
*
* 度量对象是「矩阵格集合的 JS 计算」,审计点名的就是这条。**浏览器首屏/交互耗时本机拿不到**
* (没有真实店铺数据、也没有浏览器现场),按准出括注登记为现网复量项,不许拿这条当"首屏已实测"读。
*/
test('200列×50行:预聚合与按列切窗都必须快过逐格 filter', () => {
const columns = Array.from({ length: 200 }, (_, index) => `Shop${index}`)
const blanks = blankViews(columns)
const windowColumns = columns.slice(0, 40)
const windowBlanks = blanks.slice(0, 40)
const best = (run: () => unknown): number => {
let ms = Number.POSITIVE_INFINITY
for (let attempt = 0; attempt < 5; attempt++) {
const start = performance.now()
run()
ms = Math.min(ms, performance.now() - start)
}
return ms
}
const readings: string[] = []
for (const shopsPerRow of [3, 40]) {
const rows = matrixFixture(columns, shopsPerRow)
const legacySweep = () => {
const out: CellView[] = []
for (const item of rows) for (const column of columns) out.push(legacyCell(item, column))
return out
}
const precomputedSweep = (cols: string[], cellBlanks: CellView[]) => {
const cells = buildMatrixCells(rows, cols)
const out: CellView[] = []
for (const item of rows) {
cols.forEach((column, index) => out.push(fastCell(cells, item, column, cellBlanks[index])))
}
return out
}
assert.deepEqual(precomputedSweep(columns, blanks), legacySweep(), '前后必须同一份格子(快不是靠少算)')
const beforeMs = best(legacySweep)
const precomputeMs = best(() => precomputedSweep(columns, blanks))
const shippedMs = best(() => precomputedSweep(windowColumns, windowBlanks))
readings.push(`每行${shopsPerRow}店:逐格filter=${beforeMs.toFixed(1)}ms → 预聚合=${precomputeMs.toFixed(1)}ms(${(beforeMs / precomputeMs).toFixed(1)}×) → 预聚合+切窗40列=${shippedMs.toFixed(1)}ms(${(beforeMs / shippedMs).toFixed(1)}×)`)
assert.ok(precomputeMs < beforeMs, `预聚合没省下来(每行${shopsPerRow}店):${beforeMs.toFixed(1)}ms → ${precomputeMs.toFixed(1)}ms`)
assert.ok(shippedMs * 2 < beforeMs, `切窗后仍不够快(每行${shopsPerRow}店):${beforeMs.toFixed(1)}ms → ${shippedMs.toFixed(1)}ms`)
}
console.log(`[B60 读数] 200列×50行 ${readings.join(' | ')}`)
})
@@ -2,8 +2,9 @@ import test from 'node:test'
import assert from 'node:assert/strict'
import { parseDuplicateConsole, parseLedgerPage, parseConsoleGroup, parseLedgerRow } from '../src/pages/tasks/duplicate-console-model.ts'
import {
buildMatrixCells,
indexShopGroups,
dupWithinGroup,
matrixCellOf,
storeColumnsOf,
} from '../src/pages/tasks/duplicate-console-logic.ts'
@@ -49,6 +50,21 @@ test('test_dup_console_model_parses_overview_dup_and_groups', () => {
assert.deepEqual(group, { name: 'GroupA', shopCount: 2, asinUnique: 4, recordCount: 6, dupCount: 2 })
})
/** B60:console 多了行窗口三键;缺字段要退得回安全默认(page 至少 1,pageSize 缺省 0=调用方自持)。 */
test('test_dup_console_model_parses_row_window', () => {
const windowed = parseDuplicateConsole({
success: true,
data: { pending: false, dup: [], groups: [], total_dup: 2650, page: 3, page_size: 50 },
})
assert.equal(windowed.totalDup, 2650, 'total_dup 是该范围未分页总数,不是本页行数')
assert.equal(windowed.page, 3)
assert.equal(windowed.pageSize, 50)
const legacy = parseDuplicateConsole({ success: true, data: { pending: false, dup: [], groups: [] } })
assert.equal(legacy.page, 1, '没有 page 字段时读成第一页,别让分页控件显示第 0 页')
assert.equal(legacy.pageSize, 0)
})
test('test_dup_console_parse_group_ignores_missing_name', () => {
assert.equal(parseConsoleGroup({ shop_count: 1 }), null)
assert.ok(parseConsoleGroup({ name: 'G', shop_count: 2 }))
@@ -71,15 +87,9 @@ test('test_dup_console_group_derivation_restricts_to_members', () => {
])
assert.deepEqual(groups.members.GroupA, ['ShopA', 'ShopB'])
assert.deepEqual(groups.shopGroupNames.ShopC, ['GroupC'])
const inGroupA = dupWithinGroup([dupA, dupE], groups.members.GroupA)
assert.equal(inGroupA.length, 2)
// E 组内只剩 ShopA/ShopB 两条记录。
const e = inGroupA.find((item) => item.asin === 'E')
assert.equal(e?.shopCount, 2)
assert.equal(e?.recordCount, 2)
// 单店成员组内不会命中(ShopD 不在数据里)。
assert.deepEqual(dupWithinGroup([dupA, dupE], ['ShopD']), [])
assert.deepEqual(storeColumnsOf([dupA, dupE], groups.members.GroupA), ['ShopA', 'ShopB'])
// 「组内 ≥2 店才算撞款」的裁行只剩服务端一处正本(console 的 dup_group)——
// 页面原先在客户端用 dupWithinGroup 再裁一遍,那是同一规则的第二个正本,B60 收掉它。
})
test('test_dup_console_store_columns_order_and_restriction', () => {