鸿蒙PC 异常分诊台实战:把 566 次崩溃收敛成 5 组——报错聚合去重、列表渲染优化与 ArkUI/跨平台框架选型治理
鸿蒙PC 异常分诊台实战:把 566 次崩溃收敛成 5 组——报错聚合去重、列表渲染优化与 ArkUI/跨平台框架选型治理
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言:崩溃上报列表是所有客户端团队的公共垃圾场——一条
TypeError: Cannot read property length of null能在三天里堆出四百多次,几十条堆栈长得几乎一样,谁也说不清它们到底是一个 bug 还是二十个 bug。手机端的做法通常是「丢进缺陷池慢慢看」,因为手机上的会话短、场景少;但这套经验搬到鸿蒙PC 上会立刻失效。2in1 桌面形态意味着单个用户的会话可以连续八小时、窗口可以任意拉伸、鼠标 hover 每秒上百次扫过控件、后台任务与前台渲染同时在跑,同一条空指针在手机上是一次偶发闪退,在鸿蒙PC 上就是一条持续上扬的曲线,而且用户第二天打开应用还会再碰到它一次。本文拿一套真实的鸿蒙PC 工程当样本:应用「拆叠 · Triage」是一个纯 ArkTS + ArkUI 声明式 UI、只面向 2in1 的异常日志分诊实验台,deviceTypes只保留['2in1'],SDK 26.0.0,零三方依赖,六个手写.ets文件、993 行代码。它把一条原始报错拆成四个工作面——异常总览、堆栈详情、处理时间线、治理规则——并用「签名聚合 → 状态机认领 → 排查清单门禁 → 规则催办」这条链把「看日志」变成「定责与验收」。文章走三条线:报错排查(566 次崩溃如何压成 5 组签名、如何避免重复计数)、性能优化(build()里的 O(n) 派生统计、ForEachkey 抖动、5 张卡片只铺出 2 张的布局缺陷、时间线堆叠)、方案选型治理(为什么这个台面选 ArkUI 原生而不是引入跨平台框架,什么条件下才该反过来选)。需要提前把话说清楚:本工程使用的是 ArkUI,不是 ArkUI-X;文中出现的 ArkUI-X、Flutter、Compose Multiplatform 只作选型对照,工程里没有引入任何跨平台框架运行时。另外,界面上的 566 次、96 次、349 次全部是Models.ets里的本地演示常量,工程不采集真实日志(页脚已写明);凡是能静态数出来的数字,我会给文件与行号,凡是估算,我会说明估算依据,不把演示数据包装成实测性能。
关键词:鸿蒙PC、鸿蒙 PC、开源鸿蒙PC、跨平台框架、ArkUI、ArkUI-X 选型对照、异常分诊、崩溃聚合去重、签名分组、状态机认领、排查清单门禁、ForEach key 抖动、List 虚拟化、Grid 布局缺陷、方案选型治理、AtomGit。

开篇图 鸿蒙PC 真机完整桌面:应用窗口停在「异常总览」。顶部深色标题栏是「拆叠 · Triage / 崩溃与异常日志分诊实验台 · 演示原型」,右侧一枚「模拟异常入库」按钮;页签行是「异常总览 / 堆栈详情 / 处理时间线 / 治理规则」,右上角状态摘要写着「待诊 2 · 已派 2 · 已结 1」;中间一排三张统计卡是崩溃 566 次、卡死 96 次、错误 349 次;下方是签名聚合后的异常组卡片,G1 带红色「崩溃」徽标、「412 次 · 187 人」与倾斜的「待诊」印章,G2 带「卡死」徽标、「96 次 · 51 人」与「已派 / 负责人 王工」;页脚一句「异常、堆栈与处理记录均为本地演示数据,不采集真实日志」
这张图既是入口,也是全文要解决的问题的完整呈现。请注意它有三个细节。
第一,566 不等于 566 条堆栈。统计卡上的 566 是把两组崩溃(412 次 + 154 次)的「发生次数」相加得到的,而屏幕上只出现 G1、G2 两张卡——聚合把「次数」和「条目」彻底分开了,这正是分诊台存在的理由。
第二,屏幕只铺出两张卡,而数据里有五组。剩下的 G3、G4、G5 需要滚动才能看到,且两张卡片内部有大片空白(G1 的文字只占了上方约四分之一)。这不是设计留白,是一个布局缺陷,第四章会把它摊开。
第三,两个统计口径互不重叠:566/96/349 是「同类异常的发生次数之和」,而「待诊 2 · 已派 2 · 已结 1」是「异常组数量」。口径混用是排查工具最常见的错误来源——把 566 当成待办条数,工程师会被数字压垮;把 5 当成严重度,管理者会低估影响面。分诊台的第一条设计原则就是:次数用于排序,组数用于排班。
一、先把事实边界钉死:截图、工程、修复稿各是什么
技术文章最容易失信的地方,是把「我截到的界面」当成「我测到的数据」。所以先分三层,后面每一条论断都挂在这三层上。
第一层,问题样本:五张鸿蒙PC 真机完整截图。 五张都是同一台鸿蒙PC 设备的完整桌面:底部是系统 Dock(文件、浏览器、邮件、应用市场、云空间、图库等一整套系统图标),右下角是系统托盘(网络、音量、电池)与「下午9:00 / 11月15日」时间,前台是应用窗口,标题栏里最小化、最大化、关闭三个系统按钮齐全。前三张分别停「异常总览」「堆栈详情」「治理规则」,第四张停「处理时间线」,第五张把 DevEco Studio 与本应用窗口叠在一起,能看到工程树里 build-profile.json5、hvigorfile.ts、oh-package.json5、entry 与右侧「签名配置」面板。它们是应用真实的工作面,不是手机截图、不是应用内裁剪图,也不是设计稿。
第二层,配套工程:项目源码/Triage_ohos。 一个纯 ArkTS / ArkUI 声明式 UI、Stage 模型的 2in1 工程,包名 com.triage.console,deviceTypes 只有 ['2in1'],compatibleSdkVersion 与 targetSdkVersion 均为 26.0.0,工程级与模块级 dependencies 全为空。它没有接 FaultLogger、没有接 hiAppEvent、没有读任何系统日志——界面上的 5 组异常、6 条处理事件、5 条排查清单、5 份堆栈样本,全部来自 Models.ets 里 Library 的静态数据集,另有 3 条 incoming 供「模拟异常入库」按钮循环取用。
第三层,本文的修复稿。 第三到第七章给出的 .ets 片段,是针对工程里静态可见缺陷的修改建议,全部用 ArkUI 原生能力写、可独立编译,文中会逐条标明改哪个文件、改哪几行、改完能看到什么变化。它们不冒充实测性能报告,只承诺一件事:改前改后的差异可以用眼睛复现。
三层互不冒充,是本文结论可信的前提。
工程基线表(每一项都能在源码里查到,不是估值):
| 项 | 实际值 | 证据 |
|---|---|---|
| 应用 / 包名 | 「拆叠 · Triage」/ com.triage.console | AppScope/app.json5 |
| 版本 | versionCode 1000000、versionName 1.0.0 | AppScope/app.json5 |
| 设备形态 | 仅 ['2in1'],无 phone / tablet | module.json5:7 |
| SDK | compatibleSdkVersion / targetSdkVersion 均 26.0.0 | build-profile.json5:21-22 |
| 构建模型 | hvigor + ohpm,Stage 模型,strictMode.useNormalizedOHMUrl: true | build-profile.json5:26 |
| 三方依赖 | 工程级、模块级 dependencies 均为 {} | oh-package.json5 |
| 页面入口 | windowStage.loadContent('pages/Index'),单页应用 | EntryAbility.ets:12 |
| 源码规模 | 6 个手写 .ets,合计 993 行 | entry/src/main/ets/ |
| 状态中心 | Index.ets 712 行、7 个 @State、四页签互斥分支 | pages/Index.ets:9-15 |
| 数据层 | Models.ets 150 行,5 组 / 6 事件 / 5 清单项 / 5 份堆栈 / 3 条模拟入库 | common/Models.ets |
| 主题 | 硬编码色板 15 色 + 字号 5 级 | common/Theme.ets |
| 主页面测试入口 | 主页面清单只有 pages/Index 一条 | main_pages.json |
这张表说明两件事。其一,这是一个零三方依赖的鸿蒙PC 原生 2in1 工程:进程启动后直接加载单页,没有框架运行时抢主线程,所以任何卡顿都更容易归因到业务代码本身;代价是所有聚合、统计、落盘都得自己写。其二,桌面形态适配只做了一半:Grid 用 columnsTemplate('1fr 1fr') 固定两列,没有跟随窗口宽度做断点收敛;hover 只做了按钮级着色,没有做事件合并。
也必须坦白它的另一面:这个工程目前是方法论原型,不是可用的排查工具。三处证据:Models.ets 里 5 组异常的 lastSeen 是「11-15 16:20」这类字符串而不是时间戳,所以无法真正算 SLA 超时;Index.ets:116-124 的「模拟异常入库」只是把 incoming 里的常量换个 id 再塞回列表,不是真实的聚合管道;Index.ets:152-153 的「去复核」按钮只切换页签,没有任何去重计算。换句话说,它验证的是流程形状,不是数据管道。想把它变成真工具,第一件事是接 FaultLogger 与 hiAppEvent,把 Library 换成异步加载的档案仓库,并把 lastSeen 换成毫秒时间戳。
二、报错排查:566 次崩溃怎么压成 5 组
排查工具的第一性原理不是「列出错误」,而是「把同类错误折叠成一个可以指派、可以关闭、可以验收的实体」。本工程用四步完成折叠,每一步都能对应到具体代码。
2.1 第一步:签名(signature)是聚合键,不是描述文案
ExGroup 有 12 个字段,其中真正决定「它是不是同一个问题」的只有 sig。看它的定义:
// common/Models.ets:1-35(节选)
export class ExGroup {
id: string;
title: string;
kind: number; // 0 崩溃 / 1 卡死 / 2 错误
count: number; // 累计发生次数
users: number; // 影响用户数
firstSeen: string;
lastSeen: string;
sig: string; // 签名:聚合键
status: number; // 0 待诊 / 1 已派 / 2 已结
trend: number[]; // 近 7 天趋势
owner: string;
rootCause: string;
constructor(id: string, title: string, kind: number, count: number, users: number, firstSeen: string,
lastSeen: string, sig: string, status: number, trend: number[], owner: string, rootCause: string) {
this.id = id;
// …逐字段赋值
this.sig = sig;
this.status = status;
// …
}
withStatus(status: number, owner: string, rootCause: string): ExGroup {
return new ExGroup(this.id, this.title, this.kind, this.count, this.users, this.firstSeen,
this.lastSeen, this.sig, status, this.trend, owner, rootCause);
}
}
Library.groups 里第一条的 sig 是 TypeError: Cannot read property length of null @ ListDataSource.getItem——注意这个写法:异常类型 + 消息模板 + 最内层业务帧,三段拼接。为什么是这三段?因为只取类型会把所有 TypeError 合成一个巨无霸;只取消息会把「下标 3」和「下标 7」拆成两条;只有加上最内层业务帧,才能做到「同一个函数、同一个错误形态」才归为一组。status 与 kind 用数字而不是字符串,是为了让 ForEach 的 key 拼接与比较更便宜,同时避免枚举字符串在 ArkTS 严格模式下带来的类型收窄麻烦。
withStatus 这个方法值得单独说一句:它返回新实例而不是原地改字段,是不可变更新。ArkUI 对 @State 数组的观测以「引用是否变化」为准,this.groups = this.groups.map(...) 才会触发重渲染;如果直接 g.status = 1,界面不会动。这一点在 3.3 节会再出现一次,它是这套代码里最容易踩的坑。
2.2 第二步:去重窗口 + 聚合规约
签名只是「相同」,还需要一条「多久之内算相同」的规约。工程把它写在了界面上(图 1 的右上角):
// pages/Index.ets:451
Text('聚合规则:同一调用链 24h 内合并')
这句话不是装饰。聚合窗口设得太短,同一条崩溃会被拆成几十组,分诊台变成噪音发生器;设得太长,一个改了两次代码的 bug 会把修复前后的曲线糊在一起。24 小时的取法背后有个朴素判断:桌面应用的灰度发布节奏通常以天为单位,一小时内的重复基本是同一批用户反复触发,跨天之后的增长大概率来自新版本或新场景,值得单独成组。
2.3 第三步:状态机,而不是「已读 / 未读」
只有两个状态(看过 / 没看过)的排查台,最后一定会退化成备忘录。本工程用三个状态构成一条窄状态机:0 待诊 → 1 已派 → 2 已结,并且每个迁移都有守卫条件。
// pages/Index.ets:97-114
private assign(gid: string): void {
this.groups = this.groups.map((g: ExGroup) =>
g.id === gid ? g.withStatus(1, '值班 · 我', g.rootCause) : g);
this.pushEvent(gid, '异常已认领,进入排查流程。', 1);
this.toast(this.groupById(gid).title + ' 已认领');
}
private resolve(gid: string): void {
const done: number = this.doneCount(gid);
if (done < Library.checklist.length) {
this.toast('排查清单还差 ' + (Library.checklist.length - done).toString() + ' 项,暂不能结案');
return;
}
this.groups = this.groups.map((g: ExGroup) =>
g.id === gid ? g.withStatus(2, g.owner, '按排查清单完成定位与回归(演示)。') : g);
this.pushEvent(gid, '已结案:根因已记录,回归用例已归档。', 2);
this.toast(this.groupById(gid).title + ' 已结案');
}
resolve 的前四行是全工程最值得抄的一段:结案不是一个按钮,而是一次判定。少勾一项就早退,toast 会明确告诉你还差几项。这条门禁把「我以为查完了」变成「清单说了算」,也把后面第五章的治理规则从文案变成了可执行约束。
状态在视觉上也没浪费:StatusBadge 把三个状态画成三枚圆形印章,并用 rotate({ angle: -12 }) 转出一个「盖章」的角度。
// components/StatusBadge.ets:21-32
build() {
Text(this.label())
.fontSize(F.caption)
.fontWeight(FontWeight.Bold)
.fontColor(this.colorHex())
.width(40)
.height(40)
.textAlign(TextAlign.Center)
.border({ width: 2, color: this.colorHex() })
.borderRadius(20)
.rotate({ angle: -12 })
}
图 1 里 G1 右上角那枚倾斜的红章,就是这段代码画的。它比一个灰色小圆点贵,但在一屏 5 张卡的密度下,倾斜 12° 的形状比颜色更容易被余光捕获——这是 2in1 大屏特有的收益:手机上没人会在 6 英寸屏里扫 5 张卡。

图 1 鸿蒙PC 真机完整桌面:「堆栈详情」页。顶部是 G1–G5 的分组切换条(当前选中 G1,黑底),下方三块内容依次是异常头卡(「崩溃」徽标、标题「列表滚动时空指针崩溃」、签名行、累计 412 次 / 影响 187 人 / 首次 11-12 / 最近 11-15 16:20、「认领排查」按钮与「清单进度 0/5」)、深色堆栈样本卡(四行调用帧,末行 --- background clear raced with scroll prefetch --- 用琥珀色标出,表示这是推断的因果注释而非真实帧)、排查清单卡(五项全部未勾选)
图 1 是排查方法论的落点。它把一次崩溃拆成三层证据,缺一层就没法定责:
- 签名层(
ListDataSource.getItem+ 消息模板):回答「是不是同一个问题」。 - 堆栈层(
getItem→RecommendedList.buildRows→Index.build):回答「谁调用谁」。四行里前三行都是业务帧,没有一帧是框架层——这是判断「该改谁的代码」的关键。很多排查工作就死在这一步:把框架帧当成根因,然后去写 workaround。 - 注释层(
--- background clear raced with scroll prefetch ---):回答「为什么会发生」。这行不是真实栈帧,是人工写进样本的因果假设,也正是Models.ets:115里StackSample.lines混装两种内容的原因。
2.4 第四步:把「修复动作」也变成清单项
Library.checklist 的五项是全局的,不分签名:核对签名与最近提交差异、比较受影响版本范围与灰度比例、复现路径走查、检查资源释放与空值防护、补齐回归用例。看起来过于笼统,但这恰恰是它可用的原因——排查步骤是流程资产,根因是数据资产。流程对所有异常都一样,所以能做成常量;根因只有同一个签名才共享,所以它是 ExGroup.rootCause 字段。把两者混在一起,是很多自研平台第二个月就没人用的根本原因。
三、性能优化(一):把 build() 当成热路径来读
ArkUI 是声明式 UI:状态变化后框架重新执行 build() 生成新的视图描述,与旧树做差分,只把差异提交给渲染管线。差分的成本取决于「树的规模」与「差异的粒度」。本工程所有状态都压在 pages/Index.ets 一个 struct 里:
// pages/Index.ets:9-15
@State tabIdx: number = 0;
@State groups: ExGroup[] = Library.groups;
@State events: HandleEvent[] = Library.events;
@State doneKeys: string[] = [];
@State selGid: string = 'g1';
@State fixedChecks: string[] = [];
@State seedIdx: number = 0;
七个 @State,任何一个变化都会让 Index.build() 完整执行一次;四个页签又是 if / else if 互斥分支,所以「当前页签有多大」直接等于「一次状态更新的描述成本」。异常总览一屏是三张统计卡加五张组卡,堆栈详情一屏是头卡 + 堆栈卡 + 五项清单,都不是小树。下面三处是我按源码静态数出来的浪费,它们的共同点是:每一处都不影响正确性,只影响「点一下要等多久」。
3.1 派生统计在 build() 里反复扫描全表
先看统计卡怎么取数:
// pages/Index.ets:37-67(节选)
private countOfKind(kind: number): number {
let n: number = 0;
for (const g of this.groups) {
if (g.kind === kind) {
n += g.count;
}
}
return n;
}
private sparkH(v: number): number {
let maxV: number = 1;
for (const g of this.groups) {
for (const t of g.trend) {
if (t > maxV) {
maxV = t;
}
}
}
return 6 + Math.round(v / maxV * 20);
}
按 Key 顺手数一遍开销:countOfKind 在 OverviewTab 里被调用 3 次(崩溃 / 卡死 / 错误),每次遍历 5 组,共 15 次比较;sparkH 更贵——它被 Spark 里每一根柱子各调用一次,5 张卡 × 7 根柱 = 35 次调用,每次内部扫全表的 5 × 7 = 35 个数值,合计 1225 次比较。而这 1225 次比较的结果,在整个 groups 不变的前提下是常量。用户在鸿蒙PC 上点一下页签、认领一条异常、甚至只勾一个清单项,这 1225 次比较都要重跑一遍。
更要命的是 ForEach 的数据源也在变:
// pages/Index.ets:339-345
Grid() {
ForEach(this.groups, (g: ExGroup) => {
GridItem() {
this.GroupCard(g)
}
}, (g: ExGroup) => g.id + '-' + g.status.toString() + '-' + g.count.toString())
}
修复思路是「一次算完,存成状态」:
// common/Stats.ets(新增文件)
import { ExGroup } from './Models';
export class DerivedStats {
kinds: number[] = [0, 0, 0]; // 崩溃 / 卡死 / 错误 的累计次数
status: number[] = [0, 0, 0]; // 待诊 / 已派 / 已结 的组数
maxTrend: number = 1; // 全表趋势柱最大值,供柱高归一化
}
export function computeStats(groups: ExGroup[]): DerivedStats {
const s: DerivedStats = new DerivedStats();
for (const g of groups) {
if (g.kind >= 0 && g.kind < 3) {
s.kinds[g.kind] += g.count;
}
if (g.status >= 0 && g.status < 3) {
s.status[g.status] += 1;
}
for (const v of g.trend) {
if (v > s.maxTrend) {
s.maxTrend = v;
}
}
}
return s;
}
在 Index 里加一个 @State stats: DerivedStats = computeStats(Library.groups),然后在每次真正改动 groups 的地方(assign / resolve / simulateException)追一行 this.stats = computeStats(this.groups)。收益是:一次状态更新内的统计开销从「每帧 3 + 35 次函数调用」降到「每次数据变更 1 次遍历」,而浏览、切页签、勾清单这些不改数据的操作彻底不再触发统计。GroupCard 里把 this.sparkH(v) 换成 this.sparkH(v, this.stats.maxTrend),OverviewTab 里三张卡直接读 this.stats.kinds[0..2],TabRow 里的「待诊 2 · 已派 2 · 已结 1」直接读 this.stats.status。
3.2 ForEach 的 key 把「可变字段」拼了进去
上一段那个 key 是 g.id + '-' + g.status + '-' + g.count。它保证了「状态一变卡片必重建」,所以界面是对的;代价是重建的是整张卡——包括那 7 根趋势柱、三行文本和边框。勾一下清单、改一个状态,五张卡里至少一张被整体销毁重建,ForEach 的 diff 省下的钱全花在这上面了。
同类问题还有两处:
// pages/Index.ets:499 清单项 key 含勾选态
}, (c: CheckItem) => c.id + '-' + this.isDone(gid, c.id).toString())
// pages/Index.ets:242 趋势柱 key 含高度
}, (v: number, idx: number) => idx.toString() + '-' + v.toString())
正确的做法是让 key 稳定、让变化下沉到子组件:key 只用不可变标识,把会变的字段做成子组件的 @Prop。例如把组卡提成独立组件:
// components/GroupCardView.ets(新增)
import { ExGroup } from '../common/Models';
import { F, Pal } from '../common/Theme';
import { StatusBadge } from './StatusBadge';
@Component
export struct GroupCardView {
@Prop gid: string = '';
@Prop title: string = '';
@Prop sig: string = '';
@Prop kindName: string = '';
@Prop statusVal: number = 0;
@Prop count: number = 0;
@Prop users: number = 0;
@Prop trend: number[] = [];
@Prop maxTrend: number = 1;
onOpen: (id: string) => void = () => {};
private barH(v: number): number {
return 6 + Math.round(v / this.maxTrend * 20);
}
build() {
Column({ space: 8 }) {
Row({ space: 8 }) {
Text(this.kindName).fontSize(10).fontColor(Pal.paper)
.padding({ left: 8, right: 8, top: 3, bottom: 3 })
.backgroundColor(Pal.seal).borderRadius(7)
Text(this.gid.toUpperCase()).fontSize(F.caption).fontColor(Pal.inkFaint)
Blank()
StatusBadge({ statusVal: this.statusVal })
}.width('100%')
Text(this.title).fontSize(F.body).fontWeight(FontWeight.Bold)
.fontColor(Pal.ink).maxLines(1)
Text(this.sig).fontSize(11).fontColor(Pal.inkDim).maxLines(2)
.textOverflow({ overflow: TextOverflow.Ellipsis })
Row({ space: 3 }) {
ForEach(this.trend, (v: number, i: number) => {
Column().width(9).height(this.barH(v))
.backgroundColor(i === 6 ? Pal.seal : Pal.line).borderRadius(3)
}, (v: number, i: number) => i.toString())
}
Row({ space: 12 }) {
Blank()
Column({ space: 1 }) {
Text(this.count.toString()).fontSize(20).fontWeight(FontWeight.Bold).fontColor(Pal.seal)
Text('次 · ' + this.users.toString() + ' 人').fontSize(10).fontColor(Pal.inkFaint)
}.alignItems(HorizontalAlign.End)
}.width('100%')
}
.width('100%')
.padding(16)
.backgroundColor(Pal.card)
.borderRadius(16)
.border({ width: 1, color: Pal.line })
.alignItems(HorizontalAlign.Start)
.onClick(() => this.onOpen(this.id))
}
}
调用侧改为稳定 key,并由父组件把可变字段传进去:
// pages/Index.ets(改造后)
Grid() {
ForEach(this.groups, (g: ExGroup) => {
GridItem() {
GroupCardView({
gid: g.id, title: g.title, sig: g.sig, kindName: Library.kindNames[g.kind],
statusVal: g.status, count: g.count, users: g.users,
trend: g.trend, maxTrend: this.stats.maxTrend,
onOpen: (id: string): void => { this.openStack(id); }
})
}
}, (g: ExGroup) => g.id) // key 只认身份
}
.columnsTemplate('1fr 1fr')
.columnsGap(14)
.rowsGap(14)
.layoutWeight(1)
这样「认领」只让 @Prop statusVal 变化,ForEach 不再销毁重建整张卡,StatusBadge 只重画那一枚印章。趋势柱的 key 也顺带修好了:i.toString() 保证柱子的身份只跟位置有关,高度变化只是属性更新。
3.3 状态下沉的另一半:数组全量替换
doneKeys 与 fixedChecks 都是 string[],每次改动都新建数组:
// pages/Index.ets:74-81
private toggleCheck(gid: string, itemId: string): void {
const key: string = gid + ':' + itemId;
if (this.doneKeys.indexOf(key) >= 0) {
this.doneKeys = this.doneKeys.filter((k: string) => k !== key);
} else {
this.doneKeys = this.doneKeys.concat([key]);
}
}
写法没错(ArkTS 里 @State 数组要靠新引用触发观测),但它和 3.1 的统计、3.2 的 key 叠在一起就是三重放大:勾一下 → 数组换引用 → Index.build() 全量执行 → 统计重算 1225 次比较 → 组卡 key 里的 status/count 没变所以不重建,但清单项 key 含 isDone 所以五条全重建。一处小交互,三层无效工作。
我的处理顺序建议是:先把 3.1 的统计挪出 build()(收益最大且改动最小),再做 3.2 的稳定 key(收益次大,但要新增组件),最后才考虑把 doneKeys 收进 Set 语义的自定义类。反过来做,你会发现改完 key 之后统计还是每帧在跑,白改。
四、性能优化(二):三处能一眼看见的布局与渲染缺陷
上一章是三处「看不见的浪费」,这一章是三处「看得见的错误」。它们的证据就在截图里,任何读者都能对上号。
4.1 五组异常只铺出两张卡:Grid 没有行模板,卡片又是 height('100%')
先看组卡的样式尾部和容器:
// pages/Index.ets:298-307
.width('100%')
.height('100%') // ← 关键
.padding(16)
.backgroundColor(Pal.card)
.borderRadius(16)
.border({ width: 1, color: g.status === 0 ? Pal.sealSoft : Pal.line })
.alignItems(HorizontalAlign.Start)
// pages/Index.ets:339-350
Grid() {
ForEach(this.groups, /* … */)
}
.columnsTemplate('1fr 1fr')
.columnsGap(14)
.rowsGap(14)
.layoutWeight(1)
Grid 只声明了列模板,没声明 rowsTemplate,行高交给内容决定;而内容(GridItem 里的组卡)又声明了 height('100%')。这是一个循环依赖:行高取决于卡片高度,卡片高度取决于行高。 框架只能取一个可行解,结果是「一行吃掉整块剩余高度」,于是第一行两张卡占满屏幕,剩下三组被推到滚动区外——这正是开篇图里只看到 G1、G2 的原因。卡片内部那个 Blank()(Index.ets:293)又把内容往上顶、把空白留在下方,所以 G1 的文字只占上四分之一,下半张卡全是背景色。
修复只需要两步:去掉卡片的 height('100%') 与内部的 Blank(),让高度由内容撑开;如果确实要「一屏 2×2 定高网格」,就显式写死行模板。
// 方案 A:内容自适应高度(推荐,卡片多时更自然)
Column({ space: 8 }) { /* … */ }
.width('100%')
.padding(16) // 去掉 .height('100%')
.backgroundColor(Pal.card)
.borderRadius(16)
.alignItems(HorizontalAlign.Start) // 去掉内部 Blank()
// 方案 B:固定 2×2 视口,超出滚动
Grid() { /* … */ }
.columnsTemplate('1fr 1fr')
.rowsTemplate('1fr 1fr')
.columnsGap(14)
.rowsGap(14)
.layoutWeight(1)
方案 A 是我给这个工程的建议:分组数量会随版本变化(今天是 5 组,明天模拟入库后可能是 8 组),固定行模板一遇到数量变化就要改代码;自适应高度 + Grid 自身滚动才是稳的。桌面窗口还能被拉到很高,自适应让「窗口越高、一屏看到的卡越多」这个直觉成立。
4.2 时间线全挤在底部:行高塌陷 + 缺滚动容器

图 2 鸿蒙PC 真机完整桌面:「处理时间线」页。页签「处理时间线」为激活态,整页从上到下有约七成是空白,六条处理记录全部堆在窗口底部并彼此重叠,只能勉强辨认「王工认领,怀疑首帧布局嵌套过深」「李工认领,502 重试缺少异常包裹」「崩溃量连续三天上升,标记为最高优先级」等文字;页脚仍是「本地演示数据」声明
图 2 是一个必须承认的缺陷,而不是「大气留白」。原因有两层,都在代码里。
第一层,容器没有滚动能力。TimelineTab 用 Column 直接平铺全部事件:
// pages/Index.ets:562-578
@Builder
TimelineTab() {
Column({ space: 0 }) {
ForEach(this.events, (ev: HandleEvent) => {
TimelineRow({ date: ev.time, code: ev.gid.toUpperCase(), text: ev.text, kind: ev.kind })
}, (ev: HandleEvent) => ev.id)
Text('').height(10)
}
.width('100%')
.layoutWeight(1)
.padding({ left: 40, right: 40, top: 14, bottom: 6 })
}
第二层,单行内部用 layoutWeight(1) 画竖线,行高没有被约束:
// components/TimelineRow.ets:18-31
Row({ space: 14 }) {
Column({ space: 4 }) {
Text('').width(12).height(12).borderRadius(6).backgroundColor(this.dotColor())
Text('').layoutWeight(1).width(2).backgroundColor(Pal.line) // ← 纵向连接线
}
.width(16)
.alignItems(HorizontalAlign.Center)
// …右侧时间、编号、正文
}
在 Column 里给一条线 layoutWeight(1),等于要求这条线去吃掉剩余的纵向空间;而外层没有 Scroll、List 提供确定的高度,剩余空间的计算就失去参照,多行之间互相挤压,最终表现为「文字叠在底部」。手机上一屏 3 条事件时不明显,鸿蒙PC 上事件累积到 6 条、10 条就会立刻暴露——这就是「手机能跑」和「桌面能用」之间最典型的一道坎。
修复要同时解决两件事:把容器换成具备虚拟化的 List,把行内竖线改成由行自身决定高度的普通绘制。
// pages/Index.ets(改造后)
@Builder
TimelineTab() {
List({ space: 8 }) {
ForEach(this.events, (ev: HandleEvent) => {
ListItem() {
TimelineRow({ date: ev.time, code: ev.gid.toUpperCase(), text: ev.text, kind: ev.kind })
}
}, (ev: HandleEvent) => ev.id)
}
.width('100%')
.layoutWeight(1)
.scrollBar(BarState.Auto)
.padding({ left: 28, right: 28, top: 14, bottom: 6 })
}
// components/TimelineRow.ets(重写)
import { F, Pal } from '../common/Theme';
@Component
export struct TimelineRow {
@Prop date: string = '';
@Prop code: string = '';
@Prop text: string = '';
@Prop kind: number = 0;
private dotColor(): string {
if (this.kind === 2) {
return Pal.pine;
}
return this.kind === 1 ? Pal.seal : (this.kind === 3 ? Pal.inkFaint : Pal.amber);
}
build() {
Row({ space: 12 }) {
Column()
.width(10)
.height(10)
.borderRadius(5)
.backgroundColor(this.dotColor())
.margin({ top: 6 })
Column({ space: 4 }) {
Row({ space: 8 }) {
Text(this.code).fontSize(F.caption).fontWeight(FontWeight.Bold).fontColor(Pal.pine)
Text(this.date).fontSize(F.caption).fontColor(Pal.inkFaint)
}
Text(this.text).fontSize(F.body).fontColor(Pal.ink).width('100%')
}
.alignItems(HorizontalAlign.Start)
.layoutWeight(1)
}
.width('100%')
.alignItems(VerticalAlign.Top)
.padding({ left: 12, right: 12, top: 10, bottom: 10 })
.backgroundColor(Pal.card)
.borderRadius(10)
.border({ width: 1, color: Pal.line })
}
}
改动有三处值得说明:① List + ListItem 替代 Scroll + Column,长列表只构建可视区节点,事件累积到几百条也不会一次生成几百个组件;② 圆点 + 卡片替代「圆点 + 竖线」,用卡片背景本身表达「一条记录」,比一根必须依赖父容器高度的连线更可靠;③ 去掉 layoutWeight,行高由文字内容自然决定。如果确实想要连续的时间轴视觉,正确写法是给 TimelineRow 设定固定 height(例如 64)后,再用 Divider().vertical(true).height('100%') 画连接线——关键是行高必须先有确定值。
4.3 事件数组没有上限,常驻一天就线性增长
// pages/Index.ets:69-72
private pushEvent(gid: string, text: string, kind: number): void {
const ev: HandleEvent = new HandleEvent('en' + Date.now().toString(), '11-15 18:xx', gid, text, kind);
this.events = [ev].concat(this.events);
}
每次操作都 concat 出一个新数组,长度只增不减。对一个「开一整天」的鸿蒙PC 工具来说,这是典型的内存泄漏雏形:即便换成 List 虚拟化,数组本身仍在增长,concat 每次还要复制整个数组(O(n) 分配)。加一行上限就够了:
private static readonly EVENT_CAP: number = 200;
private pushEvent(gid: string, text: string, kind: number): void {
const ev: HandleEvent = new HandleEvent('en' + Date.now().toString(), '11-15 18:xx', gid, text, kind);
this.events = [ev].concat(this.events).slice(0, Index.EVENT_CAP);
}
slice 保留最近的 200 条,既控制内存也控制 ForEach 的节点规模。真实产品里这 200 条之外的记录应该异步落盘(fs 写 JSONL),界面只留窗口——这与「日志查看器」和「分诊台」的分界一致:界面负责决策,存储负责留存。
五、治理规则:把「今天谁该动手」写成代码
排错只解决一条异常,治理解决「一批异常为什么总是拖」。本工程把治理写成三条卡片 + 四条规则常量,卡片不是静态文案,而是带显示条件的动作入口。
// pages/Index.ets:140-156
private applyCheck(id: string): void {
if (id === 'urge') {
for (const g of this.groups) {
if (g.status === 0) {
this.pushEvent(g.id, '治理催办:待诊异常当日必须认领。', 3);
}
}
this.toast('已对待诊异常发出催办');
} else if (id === 'rootcause') {
this.pushEvent('g3', '补充根因记录:重试队列未包裹异常,修复随下版本发布。', 3);
this.toast('根因记录已补齐');
} else if (id === 'dedupe') {
this.tabIdx = 0;
return;
}
this.fixedChecks = this.fixedChecks.concat([id]);
}
// pages/Index.ets:643-654(节选)
if (this.fixedChecks.indexOf('urge') < 0 && this.statusCount(0) > 0) {
this.GovernanceCard(this.statusCount(0).toString() + ' 个异常组待诊超时',
'规则 R1:崩溃与卡死类异常当日必须认领,可一键催办。', '催办认领', 'urge')
}
if (this.fixedChecks.indexOf('rootcause') < 0) {
this.GovernanceCard('已派异常缺少根因记录',
'规则 R2:结案前必须沉淀根因,先补录再进入回归。', '补录根因', 'rootcause')
}
这里有一个很实用的设计:卡片自己会消失。fixedChecks 里记下已处理的规则 id,处理完的卡片从列表里移除;「待诊超时」这张卡还额外带一个 statusCount(0) > 0 的前置条件——没人待诊时它根本不出现。这套「条件渲染 + 处理后自愈」的写法,比一个永远显示「0 个待诊」的静态面板有用得多,也是桌面常驻工具必须具备的自净能力。
四条规则常量则承担「政策可见」:
// pages/Index.ets:656-664
Column({ space: 4 }) {
Text('治理规则(本地演示)').fontSize(F.caption).fontColor(Pal.inkFaint)
this.RuleLine('R1', '崩溃/卡死当日认领,错误类两日内认领。')
this.RuleLine('R2', '结案必须记录根因与回归用例。')
this.RuleLine('R3', '同签名异常自动聚合,避免重复计数。')
this.RuleLine('R4', '趋势连续三天上升的异常自动提级。')
}
但「政策可见」不等于「政策可执行」。这四条里只有 R2 真正被代码强制(resolve 的清单门禁),R3 在数据层靠人工签名保证,R4 完全没有实现,R1 只是「催办」按钮的文案。改进方向很清楚:把规则变成可计算的判定函数。
// common/SlaPolicy.ets(新增)
export class SlaPolicy {
// 崩溃 24h / 卡死 24h / 错误 48h 内必须认领
static readonly claimHours: number[] = [24, 24, 48];
static overdue(kind: number, status: number, ageHours: number): boolean {
if (status !== 0) {
return false;
}
return ageHours > SlaPolicy.claimHours[kind];
}
// 近 7 天趋势后三天严格高于前三天 → 提级
static surging(trend: number[]): boolean {
if (trend.length < 7) {
return false;
}
const early: number = trend[0] + trend[1] + trend[2];
const late: number = trend[4] + trend[5] + trend[6];
return late > early;
}
}
要让 overdue 真正可用,ExGroup 必须多一个数值型的 ageHours(或把 lastSeen 换成毫秒时间戳)。这一步看起来只是「加个字段」,实际上是从演示原型走向可用工具的分水岭:一旦规则由数据算出,「待诊超时」就不再依赖按钮点击,而是每次进入治理页自动重算。这也解释了为什么第五章的问题归根到底是数据模型的问题,而不是界面问题。

图 3 鸿蒙PC 真机完整桌面:「治理规则」页。顶部三张统计卡是「5 异常分组 / 2 待诊 / 6 处理事件」;中间三张治理卡片各带一条规则说明与右侧黑色动作按钮(「催办认领」「补录根因」「去复核」);下方是灰底规则区,R1–R4 四条政策逐行列出,编号用黑色方块承载

图 4 同一个鸿蒙PC 桌面:DevEco Studio 在前台打开了 Triage_ohos 工程,左侧工程树可见 build-profile.json5、hvigorfile.ts、oh-package.json5 与 entry 模块,右侧是「项目结构 → Project/Product → 签名配置 / 编译选项」面板,Permissa_ohos 为当前签名配置;构建输出区末尾留着 in 457 ms、in 245 ms 这类任务耗时行(这是构建任务的耗时,不是界面数据);应用窗口浮在 IDE 之上,仍是治理规则页
图 4 的价值在于把「工程 ↔ 运行态」对上:左侧那套 993 行 .ets 编译出的 HAP,就是浮在 IDE 上的这个窗口。也提醒一件很实际的事——鸿蒙PC 上调试 2in1 应用,DevEco 的窗口与你的应用窗口是同一块桌面,应用一旦做成「全屏满窗口 + 深色背景」,它和 IDE 的边界感会变弱。本工程用 Pal.paper(#F7F4ED)做底色而非纯白,正是为了在这种叠放场景下仍能与 IDE 的深色主题区分开。
六、方案选型治理:这个台面为什么用 ArkUI 原生,而不是跨平台框架
前面五章都在讲「怎么写」,这一章讲「该不该这么写」。一个 2in1 桌面工具要不要引入跨平台框架,是最容易拍脑袋、也最贵的决定:选错了不是改几行代码,而是换掉渲染栈、调试链和 CI。
先把候选摊开。下面四列是这套需求真实面对过的选项,我把评估维度按「桌面应用实际会被用户投诉的点」排序,而不是按框架热度排序:
| 维度 | ArkUI 原生(本工程) | ArkUI-X | Flutter(鸿蒙适配版) | Compose Multiplatform |
|---|---|---|---|---|
| 2in1 桌面形态 | 一等公民:deviceTypes 直接声明 2in1,窗口级 API 与断点能力就是框架本身 | 复用 ArkUI 语法跨端,桌面细节需自行补齐 | 自绘渲染,桌面即一个大画布,系统亲和需自行补齐 | 同上,且依赖 Skia 渲染后端 |
| 系统能力接入 | @kit.* 直接 import(hilog、window、剪贴板、文件) | 跨端桥接,新 API 覆盖通常滞后 | 插件 / FFI 桥接,滞后于 ArkUI | expect/actual 逐平台实现 |
| 启动与包体 | 无额外运行时,起步最小 | 小 | 需打包 Dart 运行时 | 需打包 Skia 与运行时,通常最大 |
| 调试链路 | DevEco + hilog + Profiler,一条链 | DevEco | 自建工具链 + hdc 组合 | Gradle + hdc 组合 |
| 多端复用价值 | 0(只服务鸿蒙PC) | 高(手机 / 平板 / PC 一套 UI) | 高 | 高 |
| 团队成本 | 会 ArkTS 即可 | 会 ArkTS + 跨端差异 | 需 Dart / Flutter 经验 | 需 Kotlin / Gradle 经验 |
表格里最关键的不是哪一列分高,而是最后一行的「多端复用价值」:跨平台框架的全部溢价都来自「一套 UI 跑多端」,一旦这个前提不成立,它就只剩成本。 本工程的前提是明确的——deviceTypes: ['2in1'](module.json5:7),没有手机端计划,界面里所有交互都是桌面独有:Grid 两列自适应、hover 着色、Scroll 横向分组切换条、页面留白 28px 起。这些在手机上都用不上。
于是我给自己定了三条判定,按顺序问:
- 这套 UI 是否需要同时跑在手机 / 平板 / 鸿蒙PC 上? 只有 PC → 不走跨平台框架。
- 是否依赖 ArkUI 的桌面专属能力(窗口级 API、2in1 断点、右键与悬停语义)? 依赖 → 原生优先。
- 团队是否已有跨平台存量代码、示例、CI? 有 → 跨平台框架的复用收益才成立。
三条全过才值得引入跨平台。本工程在第 1 条就停了:它是一台「内部值班工具」,生命周期以季度计、用户量以人计、界面以信息密度取胜——这类应用的胜率来自「改一版能当天发」,而不是「一次编写多端运行」。
反过来也要说清楚什么情况该选跨平台框架:如果分诊台的产品形态是「桌面看板 + 手机随时确认 + 平板巡场」,三个形态共享同一套状态与列表,那么 ArkUI-X 这类跨平台框架就值得,因为它省掉的是三套 UI 的长期维护成本;如果团队已经有 Flutter 或 Compose Multiplatform 的存量组件库与 CI,硬切 ArkUI 原生等于把资产清零。选型不是站队,是把「复用收益」和「系统亲和」放在同一张表上称一次。
最后纠正一个表达上的常见错误:本文工程用的是 ArkUI,它是鸿蒙原生声明式 UI 框架;ArkUI-X 是把它扩展到 Android / iOS 的跨平台方案,两者不是同一件事。工程里没有 ArkUI-X 依赖、没有跨端工程结构、没有任何一端适配层——oh-package.json5 的 dependencies 是空对象就是最直接的证据。写文章时把「ArkUI」写成「ArkUI-X」,和把 Kotlin 写成 Kotlin/JS 一样,是能力边的混淆。
七、修复清单:五处改动,按收益排序
把前面散落的改动收成一张可执行的清单。每一条都标了「改哪个文件、看得见的效果」,你可以按顺序做,也可以只做第一条。
| 序号 | 改动 | 文件 | 看得见的效果 |
|---|---|---|---|
| 1 | 统计从 build() 抽到 computeStats,只在数据变更时重算 | 新增 common/Stats.ets + pages/Index.ets | 切页签、勾清单不再触发 1225 次比较 |
| 2 | ForEach key 改稳定 id,组卡提成 GroupCardView 组件 | 新增 components/GroupCardView.ets | 认领一条异常只重画一枚印章,不再整卡重建 |
| 3 | 去掉组卡 height('100%') 与内部 Blank() | pages/Index.ets:293-299 | 一屏从 2 张卡变成 4 张卡,卡内空白消失 |
| 4 | 时间线改 List + ListItem,行内竖线改圆点 + 卡片 | pages/Index.ets:562-578、components/TimelineRow.ets | 6 条事件正常分行显示,不再堆在底部重叠 |
| 5 | pushEvent 加 200 条上限 | pages/Index.ets:69-72 | 常驻一整天,事件节点数不再线性增长 |
前两条是「性能」,后三条是「可用性」。这个顺序不是随便排的:性能问题用户说不清,可用性问题用户会直接投诉——所以先修看得见的 3、4、5,再回头做 1、2 也完全合理。如果只有半天时间,我的建议是先做 3 和 4,因为它们直接影响「这个工具能不能被同事接受」,而 1、2 的收益要等数据量上去才显现。
八、三条验收线,和五个我踩过的坑
改完不等于改对。分诊台这类工具的验收必须可复算,我给三条最低标准:
验收线一:聚合口径守恒。 无论怎么分组,sum(组.count) 必须等于原始上报条数,sum(组.users) 不能超过去重后的独立设备数。本工程的 566 = 412 + 154、349 = 288 + 61 就是这个恒等式的体现。加了「模拟异常入库」之后,每点一次,sum 应精确增加该条数据的 count——如果对不上,说明聚合管道有重复计数。
验收线二:状态迁移幂等。 对一条 status = 1 的异常再次点「认领」,不应产生第二条「已认领」事件;对 status = 2 的异常点「结案」,不应再写事件。本工程靠 if (g.status === 0) / if (g.status === 1) 的条件渲染规避,但真正的守卫应该写在 assign / resolve 函数入口——界面上不显示按钮,不等于业务层不会被调用。
验收线三:渲染规模可预测。 事件累积到 200 条时,时间线首屏构建的节点数应保持在「一屏可见条数」量级,而不是 200 条全建。判据很土但有效:把 events 手动灌到 200 条,拖动滚动条,如果首帧明显卡顿、内存曲线台阶式上涨,说明虚拟化没生效。
五条踩坑,都是这套代码里真实存在或真实修过的:
@State数组要换引用。this.groups.map()才会触发重渲染,g.status = 1不会——withStatus这个「返回新实例」的方法就是为此存在的。ForEach的 key 不能既想稳定又想表达变化。把可变字段拼进 key 换来的「能刷新」,代价是整项重建;正确姿势是稳定 key + 子组件@Prop。layoutWeight在不定高容器里会塌。TimelineRow那条竖线就是典型:父级没有确定高度,layoutWeight(1)没有参照物,多行互相挤压。Grid只写columnsTemplate时,子项height('100%')会反噬。行高与卡片高度互相依赖,最后表现为「一行吃掉整屏」。- 桌面应用的数组必须有上限。手机上一次会话几分钟,鸿蒙PC 上是一整天,
concat无上限就是内存与节点数的双线性增长。
还有一条不算坑、但很容易误判:界面上的数字要标清来源。 本工程的 566/96/349 是 Models.ets 里的常量,页脚已经写明「不采集真实日志」。技术文章如果把这些数字当成实测指标讲,读者照着做一遍就会对不上——真实性和可复现性在这里是同一件事。
九、小结:分诊台的三条硬约束
回到开头那个问题:566 次崩溃怎么在半小时内定责。这套工程的答案是三条硬约束,与用了什么框架无关:
第一条,签名先于统计。 没有稳定的聚合键,任何「次数」都是噪音。sig = 异常类型 + 消息模板 + 最内层业务帧 这个三段式,是整篇文章里最值得独立抄走的一行设计。
第二条,结案必须被门禁拦住。 resolve 里那四行早退代码,把「我觉得查完了」变成「清单说了算」。治理规则只有落到这种不可绕过的判定上才算落地,否则 R1–R4 就只是四行好看的文案。
第三条,性能优化要按「数据变更」而不是「界面变化」来组织。 一次派生统计的搬迁、一次 key 的稳定化,省下的不是几毫秒,而是「这个工具能不能被同事长期开着」的资格——桌面端应用的生命周期以「天」为单位,任何每帧的浪费都会被放大成千上万倍。
至于选型,我的结论保持不变:这是一台只服务鸿蒙PC 的 2in1 桌面工具,用 ArkUI 原生是天经地义的;只有当同一套界面真的要在手机、平板、鸿蒙PC 三端同时维护时,引入跨平台框架(ArkUI-X、Flutter、Compose Multiplatform)才算把成本花在了刀刃上。 先算清楚「多端复用价值」这一列,再谈框架,顺序不能反。
工程源码可按开源鸿蒙PC 社区的惯例托管到 AtomGit,通过社区组织下的新建项目入口(https://atomgit.com/OpenHarmonyPCDeveloper)申请仓库;如果后续把它接上 FaultLogger 与 hiAppEvent,我建议第一步只做一件事——把 lastSeen 换成毫秒时间戳,让 R1 的「当日认领」第一次具备可计算性。这一步做完,这个原型才算真正开始变成工具。
更多推荐




所有评论(0)