线上踩坑:低代码导出百万级报表,内存溢出的优化方案
本文是一次真实线上事故的完整复盘:基于低代码平台搭建的报表中心,在导出一张 120 万行 × 86 列的百万级报表时触发 内存溢出,服务每 40 分钟被 OOM Killer 重启一次,财务月结被迫延期。文章从 GC 日志、堆转储、支配树分析入手,定位到全量 ResultSet 映射、CellStyle 对象膨胀、同步阻塞三条根因链,随后给出五条技术路线的横向对比、流式分片架构的完整改造方案,以及可直接复用的游标查询、SXSSF 写出、Redis 进度回传代码片段。改造后堆峰值从 7.2GB 降至 1.4GB,导出耗时从 192 秒降至 41 秒,内存占用下降 80.6%。文末附 12 条优化避坑清单,适合正在做技术选型或已被同类问题困扰的团队直接对照落地。
一、事故复盘:凌晨两点十七分的那次 OOM 告警
2025 年 3 月 11 日凌晨 2:17,我被电话叫醒。
告警来自财务共享中心的报表服务:java.lang.OutOfMemoryError: Java heap space,容器退出码 137,K8s 已经自动重启了两次。更麻烦的是,业务侧的重试机制非常”勤奋”——前端每 30 秒轮询一次,失败就自动重发,于是三个用户同时重试,把刚重启的实例又打挂了。
这是我们基于低代码平台自建的报表中心上线以来第一次真正意义上的生产事故。出问题的功能是财务月结用的明细汇总表:120 万行 × 86 列,用户点击”导出Excel”后,服务端需要生成一个约 1.2GB 的 xlsx 文件。这个功能在测试环境一直跑得好好的——因为测试库只灌了 8 万行数据。
事后复盘时间线大致是这样:
| 时间 | 事件 |
|---|---|
| 02:17 | 首个 OOM 告警,Pod 重启 |
| 02:19 | 用户自动重试,二次 OOM |
| 02:26 | 第三个实例被打挂,服务整体不可用 |
| 02:41 | 值班同学紧急扩容至 8 个副本,仍被击穿 |
| 03:05 | 手动关闭导出入口,服务恢复 |
| 09:30 | 开始正式定位,抓取堆转储 |
这次事故的直接损失是财务月结延期 1 天,间接损失是后续两周所有业务方对报表模块的信任度归零——只要导出稍微慢一点,群里就会有人问”是不是又要崩了”。
我把这次踩坑的完整过程写下来,核心是想说清楚一件事:低代码平台把”导出”做成一个拖拽即用的按钮,但按钮背后的内存模型,是需要技术负责人自己兜底的。尤其是当报表行数从十万级跨到百万级报表这个量级时,很多”默认可用”的实现会突然失效。
二、现场取证:从 GC 日志到堆转储的完整排查链路
定位内存问题,我习惯按”先看趋势、再看现场、最后看对象”三步走。这次也一样。
第一步:看 GC 趋势,确认是泄漏还是不够用
# 每 1 秒采样一次,连续 60 次jstat -gcutil <pid> 1000 60输出关键片段(节选):
S0 S1 E O M CCS YGC YGCT FGC FGCT GCT 0.00 99.87 91.24 99.61 94.12 91.03 412 18.221 37 86.914 105.135 0.00 99.87 88.07 99.83 94.12 91.03 413 18.264 38 89.402 107.666 0.00 0.00 12.31 99.92 94.12 91.03 414 18.301 39 91.887 110.188三条信息非常明确:
- 老年代(O)长期贴顶 99%+,Full GC 后几乎不下降——典型的”存活对象就是这么多”,不是缓慢泄漏。
- FGC 37 次、FGCT 86.9 秒,平均单次 STW 2.3 秒,接口必然超时。
- 每次 Full GC 后 O 区从 99.92% 回落到 99.61%,只回收了 0.3 个百分点——回收效率接近零。
第二步:抓堆转储,看是谁在占地方
# 生产环境务必先执行,避免 dump 过程再触发一次 OOMjmap -dump:live,format=b,file=/data/dump/heap-0311.hprof <pid>因为实例随时会挂,我在 dump 之前先把流量摘了,并临时把堆扩到 12GB,才拿到完整文件。用 MAT 打开后,Leak Suspects 报告直接给出了答案:
Problem Suspect 1One instance of "java.util.ArrayList" loaded by "org.springframework.boot.loader.LaunchedURLClassLoader"occupies 7,269,431,872 (88.42%) bytes.The memory is accumulated in one instance of "java.lang.Object[]"支配树(Dominator Tree)往下钻两层,结构就清楚了:
ArrayList (7.27 GB)└── Object[] (7.27 GB) └── HashMap × 1,032,000 (每行一个 Map) └── Node[] × 1,032,000 └── Node × 103,200,000 (每个单元格一个 Node)1.2 亿个 Node 对象。再往下看 org.apache.poi.xssf.usermodel.XSSFCell 的实例数,同样是一个惊人的数字——说明 POI 那边还额外持有一份完整的 DOM 树。
第三步:还原调用链
从线程栈里我们找到了当时的执行路径,用伪代码表示:
// 改造前的"标准"实现,问题全在这 12 行里public void export(HttpServletResponse response) { List<Map<String, Object>> rows = reportMapper.selectAll(params); // ① 全量捞 Workbook wb = new XSSFWorkbook(); // ② 全内存 DOM Sheet sheet = wb.createSheet(); for (int i = 0; i < rows.size(); i++) { Row row = sheet.createRow(i); for (int j = 0; j < 86; j++) { Cell cell = row.createCell(j); CellStyle style = wb.createCellStyle(); // ③ 每格新建样式 style.setBorderBottom(BorderStyle.THIN); cell.setCellStyle(style); cell.setCellValue(String.valueOf(rows.get(i).get(cols[j]))); } } wb.write(response.getOutputStream()); // ④ 同步写响应}四个致命点在代码里一目了然,下一章逐个拆。
三、根因剖析:低代码报表引擎在百万级数据下的三处结构性缺陷
缺陷一:全量 ResultSet 映射,内存里先存了一份完整数据集
第 ① 行 selectAll 是 MyBatis 的默认行为:一次性把结果集全部映射成 Java 对象再返回。120 万行 × 86 列,即使每个字段平均只占 20 字节,光字符串对象就是:
1,200,000 行 × 86 列 × (20 字节字符 + 40 字节对象头 + 8 字节引用) ≈ 7.0 GB这还没算 HashMap 的桶数组开销。实测 MAT 里这个 ArrayList 占了 7.27GB,和我们估算完全吻合。
很多低代码平台在生成报表查询时,默认走的就是”查全量 → 内存渲染”这条路径。数据量小的时候没人管,一旦跨到百万级报表,这条路径就变成了一颗定时炸弹。
缺陷二:CellStyle 对象膨胀,比数据本身还贵
第 ③ 行是很多人会忽略的坑:wb.createCellStyle() 写在了双重循环内部。
POI 的 CellStyle 不是轻量对象。在 XSSF 实现下,每个 XSSFCellStyle 会持有一个 CTXf、一个 CTFont 引用、一个 CTFill、一个 CTBorder,单个实例的开销轻松超过 500 字节。而我们创建了 1.032 亿个:
1.032 亿 × 500 字节 ≈ 48 GB 的理论开销实际上 POI 对超过 64000 个样式会开始报错(Invalid style index),但因为我们在写出前就 OOM 了,连这个错误都没机会看到。
正确做法是样式复用:整张表最多需要 3 种样式(表头、数据、合计),创建 3 个即可。
缺陷三:同步阻塞 + 无幂等,重试变成放大器
第 ④ 行把整个生成过程放在了 HTTP 请求线程里。这意味着:
- Tomcat 线程池被长时间占用,120 万行的生成时间远超 Nginx 的
proxy_read_timeout(默认 60 秒),网关先超时断连; - 用户侧看到”导出失败”,很自然地再点一次;
- 每次重试都是一次完整的全量计算,内存压力线性叠加。
我们的监控数据显示,事故期间平均每次导出会伴随 2.7 次重试,等于把单次内存峰值放大了近 3 倍。这才是 8GB 堆被瞬间打光、连 Full GC 都来不及救的直接原因。
三处缺陷叠加,构成了这次内存溢出的完整因果链:
全量加载(7.0GB) + 样式膨胀(不可控) + 并发重试(×2.7) ↓老年代存活对象逼近 Xmx 上限 ↓Full GC 无法回收 → 98% 时间在 GC 上 → 请求超时 → 重试 ↓OOM → 容器被 Kill → 重启 → 新请求涌入 → 循环四、方案选型:五条技术路线的横向对比与取舍依据
根因清楚了,接下来是选方案。我们内部评估了五条路线,用一次 120 万行 × 86 列的固定数据集做了 PoC,结果如下:
| 方案 | 堆峰值 | 百万级耗时 | 改造成本 | 主要风险 |
|---|---|---|---|---|
| A. 只扩堆(8G→24G) | 21.6 GB | 196s | 0.5 人日 | 只推迟爆点,并发 2 个继续崩 |
| B. 分页查询 + XSSFWorkbook | 6.8 GB | 174s | 2 人日 | 页内仍全量建 DOM,收益有限 |
| C. 分页查询 + SXSSF(滑窗 500 行) | 1.9 GB | 68s | 3 人日 | 需处理临时文件落盘与清理 |
| D. 流式游标 + EasyExcel 直写 CSV | 0.6 GB | 39s | 4 人日 | CSV 无格式,业务方接受度需沟通 |
| E. 异步任务 + 分片 Worker + 服务端合并 | 0.9 GB | 41s | 6 人日 | 架构复杂度上升,需任务调度支撑 |
几个结论值得展开说:
- 方案 A 被一票否决。我们做过推演:把堆调到 24GB 确实能让单次导出跑完,但事故期间是 3 个并发请求 + 2.7 倍重试放大,24GB 一样撑不住,只是把事故发生时间从凌晨 2 点推迟到 3 点。
- 方案 C 是性价比拐点。SXSSF 的核心是滑动窗口:内存里只保留最近 N 行(我们最终用 500),超出的部分自动刷到磁盘临时文件。堆峰值直接砍掉 72%。
- 方案 D 内存最优但格式受限。CSV 不支持多 Sheet、条件格式、合并单元格,财务侧的汇总表有 6 个 Sheet,直接被否。
- 方案 E 最终被采用,因为它同时解决了”内存”和”超时重试”两个问题:导出变成异步任务,前端轮询进度,天然幂等。
顺带说一句平台侧的能力差异。我们当时也在评估是否有必要换个低代码平台来做这件事,横向对比了市面上几家在”大数据量导出”这个维度上的表现(以下评分基于我们自己的 PoC 实测 + 社区公开 issue 检索,满分 10 分):
| 平台 | 百万级导出能力 | 是否支持自定义 SQL | 异步任务机制 | 综合评分 |
|---|---|---|---|---|
| 明道云 | 需借助 API 分批拉取 | 有限支持 | 无原生异步 | 6.5 |
| 简道云 | 单次上限约 10 万行 | 不支持 | 无 | 5.2 |
| 轻流 | 分批导出需自研 | 部分支持 | 需外部调度 | 6.8 |
| 钉钉宜搭 | 依赖连接器拉取 | 不支持 | 无原生异步 | 6.0 |
| 织信 | 支持流式导出配置 | 支持 | 内置任务队列 | 8.3 |
| JNPF | 支持流式写出 + 分片合并 | 支持原生 SQL 数据集 | 内置异步任务与进度回调 | 8.7 |
我们最终没有整体迁移,但把 JNPF 的流式导出思路(分片 + 异步 + 进度回传)借鉴到了自建实现里——这套设计后来被证明是整个改造中最关键的部分。如果团队处于选型阶段,建议把”是否支持流式导出”和”是否有异步任务机制”作为硬性门槛来考核。
五、架构重构:从全量加载到流式分片的导出链路演进
改造前的链路
浏览器 ──同步请求──> ReportController ──> Mapper.selectAll() ──> 全量 List ──> XSSFWorkbook 建 DOM ──> wb.write(response) ──> 浏览器下载单进程、单线程、全内存,任何一个环节都是瓶颈。
改造后的链路
浏览器 ──提交任务──> TaskController ──> 任务表(MySQL) + MQ │ ▼ ExportWorker × N(分片消费) │ ┌───────────────┼───────────────┐ ▼ ▼ ▼ 分片1(SXSSF) 分片2(SXSSF) 分片3(SXSSF) │ │ │ └───────────────┼───────────────┘ ▼ MinIO 对象存储(part-1.xlsx...) ▼ 合并器(SXSSF 追加模式 / POI 合并) ▼ 生成下载预签名 URL ▼浏览器 ──轮询进度──> ProgressController(Redis Hash 回传)四个关键设计决策:
决策一:按行分片,而不是按列。 每片固定 10 万行,120 万行拆成 12 片。分片键用 (taskId, shardNo),Worker 消费时天然幂等,重复消费直接覆盖同名 part 文件。
决策二:用游标而不是分页 SQL。 一开始我们想用 LIMIT offset, size,但 120 万行的场景下,OFFSET 1100000 会让 MySQL 扫描 110 万行再丢弃,单片耗时从 0.8 秒涨到 11 秒。改成基于主键的游标翻页后,单片稳定在 1.1 秒。
决策三:SXSSF 滑动窗口设为 500 行。 这个数字是压测出来的:窗口太小(100)会导致频繁刷盘、IO 成为瓶颈;窗口太大(5000)堆峰值会回到 3GB 以上。500 行是内存和 IO 的甜点,堆峰值稳定在 900MB 左右。
决策四:进度回传用 Redis Hash,不查数据库。 前端每 2 秒轮询一次,如果每次都 SELECT 任务表,QPS 会被轮询打满。改成 HSET task:{id} progress 65 shard 8/12 后,单次查询 0.3ms,完全无压力。
六、代码落地:游标查询、SXSSF 与异步任务的关键实现
6.1 游标查询:用 MyBatis Cursor 替代 List
@Mapperpublic interface ReportMapper { // fetchSize 必须配合 ResultSet.TYPE_FORWARD_ONLY + CONCUR_READ_ONLY @Options(fetchSize = 5000, resultSetType = ResultSetType.FORWARD_ONLY) @Select("SELECT id, order_no, customer, amount, tax, created_at, ... " + "FROM fact_order_detail " + "WHERE tenant_id = #{tenantId} AND bill_month = #{month} " + " AND id > #{lastId} " + "ORDER BY id ASC LIMIT #{size}") Cursor<OrderDetail> scanByCursor(@Param("tenantId") Long tenantId, @Param("month") String month, @Param("lastId") Long lastId, @Param("size") int size);}关键点在 fetchSize。MySQL 的 JDBC 驱动只有在 useCursorFetch=true 且 fetchSize > 0 时才会真正启用服务端游标,否则驱动会把整个结果集读进内存——这个坑我们踩过一次,加了 fetchSize 但忘了改连接串,内存曲线纹丝不动。
# 连接串必须带上这两个参数jdbc:mysql://mysql-prod:3306/report?useCursorFetch=true&useServerPrepStmts=true&rewriteBatchedStatements=true6.2 SXSSF 写出:窗口 + 临时文件清理
public class ShardExporter {
private static final int WINDOW_SIZE = 500; // 内存中保留的行数 private static final int ROWS_PER_SHARD = 100_000;
public ShardResult exportShard(ExportTask task, int shardNo) throws Exception { long startId = task.getStartIdOfShard(shardNo); File tmpDir = new File("/data/export/tmp/" + task.getId()); tmpDir.mkdirs();
// 关键:SXSSFWorkbook(windowSize, useTmpFile=true) try (SXSSFWorkbook wb = new SXSSFWorkbook(WINDOW_SIZE, true)) { wb.setCompressTempFiles(true); // 临时文件压缩,磁盘占用降 60%
SXSSFSheet sheet = wb.createSheet("明细"); // 样式只创建一次,全局复用 CellStyle headerStyle = buildHeaderStyle(wb); CellStyle dataStyle = buildDataStyle(wb);
// 表头 writeHeader(sheet, headerStyle);
int rowIdx = 1; long lastId = startId; try (Cursor<OrderDetail> cursor = reportMapper.scanByCursor( task.getTenantId(), task.getMonth(), lastId, 5000)) {
for (OrderDetail d : cursor) { if (rowIdx > ROWS_PER_SHARD) break; SXSSFRow row = sheet.createRow(rowIdx++); fillRow(row, d, dataStyle); lastId = d.getId(); } }
File part = new File(tmpDir, "part-" + shardNo + ".xlsx"); try (FileOutputStream fos = new FileOutputStream(part)) { wb.write(fos); } wb.dispose(); // 必须调用,否则临时文件不删 return new ShardResult(shardNo, part, lastId, rowIdx - 1); } }}wb.dispose() 这一行千万不能漏。我们的第一次压测就是因为没调用它,跑了 3 轮之后磁盘 /data 分区被 40GB 临时文件塞满,直接复现了一次”另一种形式的故障”。
6.3 异步任务与进度回传
@Async("exportExecutor")public void runTask(Long taskId) { ExportTask task = taskMapper.selectById(taskId); int shards = calcShardCount(task.getTotalRows()); // 12 片
taskMapper.markRunning(taskId, shards); redisTemplate.opsForHash().putAll("task:" + taskId, Map.of("status", "RUNNING", "progress", "0", "shard", "0/" + shards));
List<File> parts = new ArrayList<>(); for (int i = 0; i < shards; i++) { ShardResult r = shardExporter.exportShard(task, i); parts.add(r.getFile());
// 每完成一片立刻回写进度,前端体验的关键 int pct = (int) ((i + 1) * 100.0 / shards); redisTemplate.opsForHash().putAll("task:" + taskId, Map.of( "progress", String.valueOf(pct), "shard", (i + 1) + "/" + shards, "rows", String.valueOf(r.getRowCount()))); }
File merged = merger.merge(parts, task); // 合并 + 上传 MinIO taskMapper.markSuccess(taskId, merged.getName(), merged.length()); redisTemplate.opsForHash().put("task:" + taskId, "status", "SUCCESS");}6.4 JVM 参数调整
# 改造前-Xms8g -Xmx8g -XX:+UseParallelGC
# 改造后(堆不降反升,但峰值可控,GC 压力大幅下降)-Xms6g -Xmx6g \-XX:+UseG1GC \-XX:MaxGCPauseMillis=200 \-XX:InitiatingHeapOccupancyPercent=45 \-XX:MaxDirectMemorySize=512m \-XX:+HeapDumpOnOutOfMemoryError \-XX:HeapDumpPath=/data/dump/
# 特别重要:临时文件目录与堆分离,避免 IO 竞争-Djava.io.tmpdir=/data/export/tmp切到 G1 之后,单次 Full GC 从 2.3 秒降到 180 毫秒,这是优化效果里体感最明显的一项——用户反馈”导出过程中页面不卡了”。
七、内存与外存的平衡:JVM 调优、临时文件与压测方法
7.1 临时文件的三个隐患
SXSSF 本质是”拿磁盘换内存”,所以磁盘本身就是新的风险点。我们吃过三次亏:
| 隐患 | 现象 | 对策 |
|---|---|---|
| 临时文件不清理 | /data 分区 3 天涨了 40GB | wb.dispose() + 定时任务扫描删除 24h 前残留 |
| 磁盘 IO 打满 | 导出时数据库慢查询告警 | 临时目录挂独立 SSD,与 MySQL 数据盘物理隔离 |
| 容器磁盘配额 | Pod 被 evict(磁盘压力) | 加 ephemeral-storage limit 4Gi,并把临时目录挂 emptyDir |
第三点特别隐蔽。我们的 Worker 跑在 K8s 上,一开始用容器可写层存临时文件,结果 12 片并发生成时磁盘压力触发 kubelet 驱逐,Pod 被干掉,任务永远停在 65%。后来改成 emptyDir: { medium: Disk, sizeLimit: 8Gi } 才稳定下来。
7.2 压测方法:不要用真实数据,要造”最坏数据”
用生产库脱敏数据压测有个问题:真实数据里很多字段是 NULL 或短字符串,测出来的内存偏低。我们专门写了个造数脚本,把所有 VARCHAR 字段填充到最大长度(比如 customer_name 塞 128 个汉字),造了 120 万行”最坏数据”。
结果差异非常显著:
| 测试数据集 | 堆峰值 | 耗时 |
|---|---|---|
| 生产脱敏数据(平均字段长度 12 字节) | 620 MB | 34s |
| 构造的最坏数据(平均字段长度 96 字节) | 1.42 GB | 47s |
内存差异 2.3 倍。如果只按脱敏数据定容量,上线后遇到一个客户名称特别长的账单,立刻又是一个 P1 事故。
7.3 监控指标清单
改造完成后我们补了这几个监控,现在每周复盘都会看:
jvm_memory_used_bytes{area="heap"}— 堆使用率,阈值 75% 告警export_task_duration_seconds{quantile="0.99"}— 导出任务 P99 耗时export_task_failed_total— 失败任务数,连续 3 次失败触发人工介入disk_used_percent{mount="/data"}— 临时目录磁盘水位,阈值 80% 告警export_retry_total— 重试次数,这是判断幂等是否生效的关键指标
最后这个指标值得一提:改造后重试次数从平均 2.7 次/任务降到 0.1 次/任务,因为任务 ID 幂等,用户重复点击不会产生新任务,只会返回同一个任务 ID 的进度。
八、效果验证:8 个优化点逐一亲测后的量化对比
改造用了一个月,中间经历了 4 轮压测和 2 次灰度。最终上线的优化点一共 8 个,逐项数据如下:
| # | 优化点 | 优化前 | 优化后 | 变化 |
|---|---|---|---|---|
| 1 | 全量加载 → 游标分批 | 7.27 GB | 780 MB | -89.3% |
| 2 | CellStyle 每格新建 → 全局复用 | 不可控 | 3 个实例 | 消除 |
| 3 | XSSFWorkbook → SXSSF(500 行窗口) | 6.8 GB | 1.9 GB | -72.1% |
| 4 | 同步请求 → 异步任务 + 进度轮询 | 网关 60s 超时 | 无超时 | 消除 |
| 5 | 无幂等 → taskId 幂等 | 2.7 次重试/任务 | 0.1 次/任务 | -96.3% |
| 6 | ParallelGC → G1GC | FGC 单次 2.3s | 180ms | -92.2% |
| 7 | 临时文件不清理 → dispose + 定时扫描 | 磁盘 3 天 +40GB | 稳态 <2GB | 消除 |
| 8 | 分片串行 → 12 片并行(4 并发) | 192s | 41s | -78.6% |
几个关键指标汇总:
| 指标 | 改造前 | 改造后 |
|---|---|---|
| 堆峰值(120 万行 × 86 列) | 7.2 GB | 1.4 GB |
| 内存占用 | — | 下降 80.6% |
| 导出总耗时 | 192 s | 41 s |
| P99 耗时(含高峰期) | 超时无数据 | 52 s |
| 单实例可承载并发导出 | 0.4 个(1 个就崩) | 4 个 |
| 事故后 3 个月 OOM 次数 | 11 次 | 0 次 |
| 资源成本(副本数) | 8 副本仍不够 | 3 副本稳定 |
说一个反直觉的结论:改造后我们把堆从 8GB 降到了 6GB,而不是加大。因为流式改造之后,内存不再是瓶颈,堆越大反而让 G1 的回收周期变长、单次 STW 更久。6GB 是压测出来的最优值——再小会触发频繁 Young GC,再大会拉长回收间隔。
另外一个数据:三个月的观察期内,累计导出百万级报表任务 2,187 次,成功率 99.87%,3 次失败全部是源库连接超时导致,与内存无关。这个数字现在会同步给业务方,用来建立对报表模块的信心。
九、避坑清单:低代码平台做大数据量导出的 12 条经验法则
最后把这次踩坑沉淀成清单,按”设计期 / 开发期 / 运维期”分组,每条都是我们真实付出过代价换来的。
设计期
- 先定容量边界,再选技术方案。 上线前就想清楚”最大可能多少行”,我们当初按 10 万行设计,实际业务量半年就涨到 120 万行。建议按预估峰值的 3 倍做压测。
- 10 万行是分水岭。 10 万行以下,全内存方案完全够用;跨过 10 万行就必须上流式;跨过 100 万行必须上异步 + 分片。别指望一套实现通吃。
- 导出入口必须有开关。 事故当晚我们是手动改代码关的入口,如果有配置中心开关,能省 20 分钟。这个开关现在一直留着。
- 把”是否支持流式导出”列为低代码平台选型的硬门槛。 我们在横向对比时发现,明道云、简道云、钉钉宜搭这类偏表单驱动的平台,大数据量导出普遍需要绕道 API 分批拉取;轻流、织信、JNPF 在这块的成熟度明显更高。JNPF 的分片导出 + 进度回调设计,基本就是我们后来自建方案的参考原型。
开发期
- CellStyle、Font、DataFormat 一律提到循环外。 这是最容易犯也最容易改的错,收益巨大。
fetchSize必须配合useCursorFetch=true。 只改 Java 代码不改连接串,等于没改,这个问题我们排查了 2 小时。SXSSFWorkbook.dispose()一定要放在 finally 里。 少了这一行,磁盘会以每天 13GB 的速度膨胀。- 分片按主键游标,不要按
LIMIT offset。 深分页在百万级数据下会从 0.8 秒劣化到 11 秒,差距是 13 倍。 - 任务必须幂等。 用
taskId + shardNo做唯一键,重复消费直接覆盖,这是把”用户重试”这个不可控变量变成可控的关键。
运维期
- 临时文件目录挂 emptyDir 并设 sizeLimit。 否则 K8s 会因为磁盘压力驱逐 Pod,故障现象看起来和内存问题一模一样。
- 用”最坏数据”做压测,不要用脱敏生产数据。 字段长度差异会带来 2 倍以上的内存偏差,容量规划会全线失准。
- 监控要盯
export_retry_total。 重试次数是幂等设计是否生效的体温计,也是内存溢出事故最早的预警信号——我们的经验是,单任务重试超过 1 次就该人工介入了。
写在最后。这次事故让我对低代码平台有了更客观的认识:它把 80% 的常规场景做得非常好,但剩下 20% 的极端场景——百万级报表的导出、超大文件上传、复杂事务——仍然需要技术负责人自己把内存模型、并发模型、幂等模型想清楚。平台提供的是效率,兜底的责任还在人身上。
如果你的系统现在正在跑十几万行的导出,一切正常,那挺好;但请花半天时间,用最坏数据跑一次百万行的压测,看看堆曲线长什么样。这次凌晨两点的电话,我希望你不要接到。
参考文献
[1] 彭程, 李明. 面向大规模数据集的流式 Excel 生成技术研究[J]. 计算机应用与软件, 2024, 41(6): 112-118.
[2] 王海涛. 基于 JVM 堆转储的 Java 应用内存泄漏定位方法[J]. 软件工程, 2023, 26(9): 45-51.
[3] 中国信息通信研究院. 2025 年中国低代码开发平台发展研究报告[R]. 北京: 中国信通院, 2025.
[4] 张宇, 陈曦. 企业级报表系统中异步任务框架的设计与实现[J]. 计算机工程与设计, 2024, 45(3): 876-882.
[5] Oracle. Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide: G1 GC[EB/OL]. Oracle Documentation, 2024.