一次 Excel 导入导出引发的 OOM 排查与优化记录

2026-06-12后端9 分钟67 次阅读
AI 摘要salmon-ai

本文详细解析了一次 Excel 导入导出引发的 OOM 排查与优化过程:从错误报告生成、EasyExcel 全量读取到动态表头转换,定位出 `XSSFWorkbook`、`

一、问题背景

最近在排查服务内存上涨和 OOM 风险时,发现部分批量导入、错误 Excel 回写相关代码存在较明显的内存和资源管理问题。

业务场景大致是:

  1. 用户上传 Excel 文件。
  2. 系统读取 Excel 内容并转换成业务 DTO。
  3. 校验每一行数据。
  4. 如果存在错误,则基于原始 Excel 生成一份“错误报告 Excel”。
  5. 将错误报告上传到文件服务,返回错误文件地址。

这个流程在普通小文件场景下通常不会暴露问题,但在以下场景中风险会明显放大:

  • Excel 文件较大。
  • 一次批量导入行数较多。
  • 批量任务并发执行。
  • 错误数据较多,需要生成错误报告。
  • 上传失败或校验失败频繁触发错误 Excel 生成。
  • JVM 堆内存配置较紧张。

本次重点排查了两个方向:

  • XSSFWorkbook、InputStream、ByteArrayOutputStream 等资源没有正确关闭。
  • EasyExcel 读取时存在全量加载和重复缓存,导致内存峰值偏高。

二、问题表现

从代码层面看,主要存在以下几类隐患。

1. 错误 Excel 生成时未关闭 XSSFWorkbook

典型代码如下:

java 复制代码
public String saveErrExcelToServer(String url, List<LemengCellErr> cellErrList) {
    InputStream inputStream = FileUtil.transformInputStream(url);
    try {
        XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
        XSSFSheet sheet = workbook.getSheetAt(0);

        // 修改 sheet,追加错误信息

        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        workbook.write(outputStream);

        MultipartFile file = new MockMultipartFile(
                "excel-err",
                "excel-err.xlsx",
                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                outputStream.toByteArray()
        );

        InfrastructureService infrastructureService = SpringContextHolder.getBean(InfrastructureService.class);
        Resp<String> upload = infrastructureService.upload(file);
        return Resp.getData(upload);
    } catch (IOException e) {
        log.error("Excel生成错误文件异常", e);
        return null;
    }
}

问题点:

  • InputStream 没有关。
  • XSSFWorkbook 没有关。
  • ByteArrayOutputStream 没有关。
  • workbook.write(outputStream) 后又 outputStream.toByteArray(),会产生额外字节数组拷贝,内存峰值变高。

其中最关键的是 XSSFWorkbook 和 InputStream。

XSSFWorkbook 是 Apache POI 的 DOM 模式读取方式,会把整个 XLSX 解压并加载到内存结构中。一个几 MB 的 XLSX,在内存中可能膨胀数倍甚至数十倍。如果没有及时 close(),相关 DOM 对象、ZIP 包资源、底层流资源都会延迟释放。

2. EasyExcel Listener 额外缓存数据

公共读取方法原来类似这样:

java 复制代码
public static <T> List<T> readSingleExcel(InputStream stream, Class<T> t, int headRowNumber) throws IOException {
    return EasyExcel.read(stream, t, new ExcelListener())
            .sheet()
            .headRowNumber(headRowNumber)
            .doReadSync();
}

而 ExcelListener 中又维护了一个 datas:

java 复制代码
public class ExcelListener extends AnalysisEventListener {

    private List<Object> datas = new ArrayList<>();

    @Override
    public void invoke(Object object, AnalysisContext context) {
        datas.add(object);
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // datas.clear();
    }
}

这里容易忽略一点:

doReadSync() 本身就会返回完整的 List<T>,也就是说所有解析结果已经被 EasyExcel 收集了一份。

如果 Listener 里又 datas.add(object),就相当于额外缓存一份数据。

因此实际内存结构大致变成:

text 复制代码
EasyExcel doReadSync 返回 List<T>
+
ExcelListener.datas 额外保存 List<Object>

对于大 Excel,这会明显增加内存占用。

3. 动态表头 Worker 中存在 Map + DTO 双份数据

部分 Worker 为了支持动态表头,使用了如下模式:

java 复制代码
List<Map<Integer, Object>> uploadFileList = EasyExcel.read(inputStream)
        .sheet()
        .doReadSync();

this.dataList = new ArrayList<>(uploadFileList.size() - 1);

for (int i = 1; i < uploadFileList.size(); i++) {
    Map<Integer, Object> dataMap = uploadFileList.get(i);

    JSONObject jo = new JSONObject();
    for (int k = 0; k < refList.size(); k++) {
        Object value = dataMap.get(k);
        Field field = refList.get(k);
        jo.put(field.getName(), value);
    }

    HourlyStoreSkuExcelBO data = jo.toJavaObject(HourlyStoreSkuExcelBO.class);
    dataList.add(data);
}

这里的内存占用包括:

  • 原始 Excel 行数据:List<Map<Integer, Object>>
  • 每行临时 JSON 对象:JSONObject
  • 转换后的业务 DTO:List<HourlyStoreSkuExcelBO>

理论上转换完成后,uploadFileList 已经不再需要,但原代码没有及时清理,导致原始 Map 数据和 DTO 同时驻留在内存中。


三、可能造成什么问题

这些问题不一定每次都会直接导致 OOM,但在批量导入场景中会显著放大内存峰值。

1. 堆内存快速上涨

Excel 文件本身体积不大,但 XLSX 是压缩格式,解压后对象数量非常多。

例如一个 5MB 的 XLSX 文件,读取后可能占用几十 MB 到上百 MB 堆内存。

如果再叠加:

  • POI DOM 模型。
  • EasyExcel 返回列表。
  • Listener 额外缓存。
  • 原始 Map。
  • 转换后的 DTO。
  • 错误报告输出字节数组。
  • toByteArray() 再复制一份。

那么一次导入的内存峰值会明显高于文件本身体积。

2. 批量任务并发时风险更高

单次任务可能只是内存升高,但如果多个导入任务同时执行:

text 复制代码
任务 A 加载 Excel
任务 B 加载 Excel
任务 C 生成错误报告
任务 D 生成错误报告

这些对象会在同一时间段内堆积,容易触发频繁 GC,甚至 OOM。

3. 文件流和底层资源泄漏

InputStream 来自:

java 复制代码
FileUtil.transformInputStream(url)

内部通过 HTTP 连接获取远程文件流。

如果不关闭输入流,可能导致:

  • HTTP 连接释放不及时。
  • 文件句柄占用增加。
  • 网络资源释放延迟。
  • 在异常场景下问题更明显。

4. 错误报告生成进一步放大内存峰值

错误文件生成流程是:

text 复制代码
读取原 Excel
-> XSSFWorkbook 加载完整 workbook
-> 删除无错误行
-> 写入 ByteArrayOutputStream
-> toByteArray 复制字节数组
-> MockMultipartFile 保存字节数组
-> 上传文件

这个流程本身就比较重,如果资源不及时关闭,风险会更大。


四、排查过程

1. 先从 OOM 相关路径反查 Excel 操作

通过搜索关键字定位 Excel 读取和写入路径:

bash 复制代码
rg -n "saveErrExcelToServer|EasyExcelUtil|writeSingleExcelToFile|LemengBaseExcelWorker"

重点关注:

  • saveErrExcelToServer
  • new XSSFWorkbook
  • new ByteArrayOutputStream
  • EasyExcel.read
  • doReadSync
  • ExcelListener

2. 定位错误报告生成代码

发现多个模块中存在类似代码:

  • ms-lemeng
  • ms-product
  • ms-permission
  • ms-pos
  • ms-order

这些 Worker 里都有类似:

java 复制代码
InputStream inputStream = FileUtil.transformInputStream(url);
try {
    XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
    ...
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    workbook.write(outputStream);
    ...
}

属于同一段逻辑复制到了多个模块。

3. 检查公共 Excel 读取工具

继续排查公共方法:

java 复制代码
EasyExcelUtil.readSingleExcel(...)

发现其使用:

java 复制代码
EasyExcel.read(stream, t, new ExcelListener())
        .sheet()
        .headRowNumber(headRowNumber)
        .doReadSync();

再看 ExcelListener,发现 Listener 自己也在保存数据:

java 复制代码
datas.add(object);

但实际业务并没有使用 getDatas() 的结果。

搜索确认:

bash 复制代码
rg -n "getDatas\\(|setDatas\\(|new ExcelListener\\("

发现 getDatas() 基本没有业务使用,因此这份缓存是冗余的。

4. 排查动态表头 Worker

继续搜索:

bash 复制代码
rg -n "List<Map<Integer, Object>> uploadFileList|doReadSync"

定位到多个动态表头转换 Worker:

  • HourlyStoreSkuUpdateExcelWorker
  • HourlyGoodsUpdateExcelWorker
  • GoodsUpdateExcelWorker
  • StoresUpdateExcelLemonOpenWorker
  • StoresUpdateExcelLemonCloseWorker

这些类会先读取为 List<Map<Integer, Object>>,再转成业务 DTO。

因此它们存在原始 Map 和 DTO 同时持有的问题。


五、最终优化方案

这次优化选择了保守路线:优先修复资源关闭和明显的重复缓存,不直接大规模重构为流式处理。

原因是当前很多 Worker 的逻辑依赖完整 dataList:

  • 全局校验。
  • 重复校验。
  • 查询数据库补全字段。
  • 错误行回写。
  • 后续任务处理。

如果直接改成 ReadListener 分批流式处理,会牵动业务结构,风险较高。

1. XSSFWorkbook 和 InputStream 使用 try-with-resources

优化前:

java 复制代码
InputStream inputStream = FileUtil.transformInputStream(url);
try {
    XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
    ...
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    workbook.write(outputStream);
}

优化后:

java 复制代码
try (InputStream inputStream = FileUtil.transformInputStream(url);
     XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
     ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {

    XSSFSheet sheet = workbook.getSheetAt(0);

    // 修改 sheet

    workbook.write(outputStream);

    MultipartFile file = new MockMultipartFile(
            "excel-err",
            "excel-err.xlsx",
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            outputStream.toByteArray()
    );

    InfrastructureService infrastructureService = SpringContextHolder.getBean(InfrastructureService.class);
    Resp<String> upload = infrastructureService.upload(file);
    return Resp.getData(upload);
}

优化效果:

  • InputStream 会自动关闭。
  • XSSFWorkbook 会自动关闭。
  • ByteArrayOutputStream 虽然 close 是空操作,但统一使用 try-with-resources,代码语义更清晰。
  • 异常场景下也能释放资源。

2. EasyExcelUtil.writeSingleExcelToFile 使用 try-with-resources

优化前:

java 复制代码
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
EasyExcel.write(byteArrayOutputStream, tClass)
        .autoCloseStream(Boolean.FALSE)
        .sheet(sheetName)
        .doWrite(tList);

return new MockMultipartFile(..., byteArrayOutputStream.toByteArray());

优化后:

java 复制代码
try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
    EasyExcel.write(byteArrayOutputStream, tClass)
            .autoCloseStream(Boolean.FALSE)
            .registerWriteHandler(new CustomCellWriteHandler())
            .registerWriteHandler(CustomerCellStyleHandler.getCustomerCellStyle())
            .sheet(sheetName)
            .doWrite(tList);

    return new MockMultipartFile(
            fileName,
            fileName + ".xlsx",
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            byteArrayOutputStream.toByteArray()
    );
}

3. 修复 ExcelListener 的重复缓存

最初尝试将公共读取方法改成:

java 复制代码
EasyExcel.read(stream, t)

但项目当前使用的是 cn.idev.excel 版本,该 API 参数不匹配,因此最终保留三参调用:

java 复制代码
return EasyExcel.read(stream, t, new ExcelListener())
        .sheet()
        .headRowNumber(headRowNumber)
        .doReadSync();

同时修改 ExcelListener,不再缓存数据:

java 复制代码
@Override
public void invoke(Object object, AnalysisContext context) {
    doSomething();
}

@Override
public void doAfterAllAnalysed(AnalysisContext context) {
    datas.clear();
}

这样既保持当前 EasyExcel API 兼容,又避免 Listener 额外保存一份数据。

4. 动态表头 Worker 转换后及时清理原始 Map

优化前:

java 复制代码
for (int i = 1; i < uploadFileList.size(); i++) {
    Map<Integer, Object> dataMap = uploadFileList.get(i);

    JSONObject jo = new JSONObject();
    ...
    T data = jo.toJavaObject(T.class);
    dataList.add(data);
}

优化后:

java 复制代码
for (int i = 1; i < uploadFileList.size(); i++) {
    Map<Integer, Object> dataMap = uploadFileList.get(i);

    JSONObject jo = new JSONObject();
    for (int k = 0; k < refList.size(); k++) {
        Object value = dataMap.get(k);
        Field field = refList.get(k);
        jo.put(field.getName(), value);
    }

    T data = jo.toJavaObject(T.class);
    dataList.add(data);

    dataMap.clear();
}
uploadFileList.clear();

优化效果:

  • DTO 转换完成后,原始 Map<Integer, Object> 不再长期持有单元格对象。
  • uploadFileList.clear() 后,原始行数据列表可以更早被 GC 回收。
  • 不改变业务校验和后续处理逻辑。

5. URL 构造器中的 InputStream 自动关闭

优化前:

java 复制代码
public BaseExcelWorker(String url, int headRowNumber) throws IOException {
    InputStream inputStream = FileUtil.transformInputStream(url);
    init(inputStream, headRowNumber);
}

优化后:

java 复制代码
public BaseExcelWorker(String url, int headRowNumber) throws IOException {
    try (InputStream inputStream = FileUtil.transformInputStream(url)) {
        init(inputStream, headRowNumber);
    }
}

这样可以确保通过 URL 读取远程 Excel 后,输入流被及时关闭。


六、为什么没有一次性改成完全流式处理

理论上,最彻底的方案是使用 EasyExcel 的 ReadListener 分批处理,例如每 500 行处理一批:

java 复制代码
public class BatchReadListener<T> implements ReadListener<T> {

    private static final int BATCH_SIZE = 500;

    private final List<T> cachedDataList = new ArrayList<>(BATCH_SIZE);

    @Override
    public void invoke(T data, AnalysisContext context) {
        cachedDataList.add(data);
        if (cachedDataList.size() >= BATCH_SIZE) {
            process(cachedDataList);
            cachedDataList.clear();
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        process(cachedDataList);
        cachedDataList.clear();
    }
}

但本次没有直接这么做,主要是因为现有业务逻辑大量依赖全量 dataList:

java 复制代码
globalCheckData(dataList);
checkExcelReadDate();
getTransformData();
saveErrExcelToServer(...);

并且很多校验不是单行校验,而是全局校验:

  • 查重。
  • 校验门店编码是否存在。
  • 校验商品编码是否唯一。
  • 根据全部 skuId 批量查询数据库。
  • 构造错误行信息。
  • 回写原 Excel 错误报告。

如果直接改成分块,会涉及:

  • 错误信息如何按原行号回写。
  • 分批数据库查询是否影响校验结果。
  • 跨批次重复校验如何处理。
  • 原有 dataList 生命周期如何改造。
  • 任务结果和错误报告如何保持一致。

因此本次选择低风险优化,先解决:

  • 资源泄漏。
  • 重复缓存。
  • 原始 Map 长时间持有。
  • 输入流关闭。

后续如果还需要继续降低峰值内存,再针对具体 Worker 做流式重构。


七、关于行数限制

本次排查也发现,有些入口已经做了行数限制,例如:

java 复制代码
ExcelUtil.checkBlankRowAndSize(file, 10002, 2);

但并不是所有入口都有统一限制。

需要注意的是,不能简单全局加一个统一的 10000 行限制,因为代码里存在部分入口允许更大的行数,例如 100000 行。

更合理的方式是:

  1. 按业务场景定义上限。
  2. 普通运营导入类限制 10000 行左右。
  3. 对账、结算、特殊批量任务可以单独配置更高上限。
  4. 上限最好配置化,而不是硬编码散落在各处。
  5. 超出限制时,提前失败,不进入 Excel 全量解析。

示例:

java 复制代码
ExcelUtil.checkBlankRowAndSize(file, maxRows, headRowNumber);

其中 maxRows 可以来自配置:

properties 复制代码
excel.import.max-rows.default=10000
excel.import.max-rows.statement=100000

八、优化效果

本次优化不会改变正常业务结果,主要降低内存风险。

1. 减少资源泄漏

InputStream 和 XSSFWorkbook 自动关闭后,错误报告生成完成即可释放相关资源。

2. 降低重复缓存

ExcelListener 不再额外保存一份 datas,避免 doReadSync() 返回结果之外的冗余内存。

3. 降低动态表头转换峰值

Map 转 DTO 后主动清理原始 Map,缩短原始单元格数据生命周期。

4. 降低异常路径风险

try-with-resources 可以保证异常场景下也能释放资源,避免失败任务比成功任务更容易泄漏。


九、经验总结

这次问题的核心不是某一行代码直接导致 OOM,而是多个 Excel 处理细节叠加后造成内存峰值过高:

text 复制代码
XSSFWorkbook DOM 加载
+ doReadSync 全量读取
+ Listener 重复缓存
+ Map 原始数据
+ DTO 转换数据
+ ByteArrayOutputStream 输出缓存
+ toByteArray 字节复制
+ 错误文件 MockMultipartFile

Excel 导入导出场景有几个经验值得记录:

  1. XSSFWorkbook 一定要关闭,尤其是从远程文件流读取时。
  2. InputStream 谁打开,谁负责关闭。
  3. doReadSync() 适合小文件,不适合无限制大文件。
  4. Listener 中不要无意识缓存数据。
  5. Map 转 DTO 后,原始 Map 如果不再使用,应尽早释放引用。
  6. 错误报告生成往往比正常读取更吃内存,需要重点关注。
  7. 行数限制要在解析前做,而不是解析后再判断。
  8. 真正的大文件导入,最终还是应该走流式处理和分批落库/校验。

本次优化属于第一阶段:低风险修复资源泄漏和重复缓存。

后续如果还要继续治理,可以按以下方向推进:

  • 为所有上传入口补齐业务行数限制。
  • 针对大文件入口改造为 ReadListener 分批处理。
  • 将全局校验拆成可流式校验和最终汇总校验。
  • 错误报告不再基于原始 Excel 修改,而是单独生成错误清单文件。
  • 对导入任务增加内存、耗时、文件行数、错误行数等监控指标。

整体来看,这次优化不会改变正常业务行为,但能明显降低批量导入和错误报告生成时的 OOM 风险。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句