Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

int count = 0; int maxTries = 2; while (true) { //xlsx…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with chatgpt-4o-latest-20250326’s answer.
  1. User

    int count = 0; int maxTries = 2; while (true) { //xlsx Roc.logEvent("Downloader:download", "tryOpen"); try { // The compression ratio is limited to five thousandths ZipSecureFile.setMinInflateRatio(0.005); return new XSSFWorkbook(OPCPackage.open(inputStream)); } catch (OLE2NotOfficeXmlFileException | InvalidFormatException e) { // handle exception if (++count == maxTries) { Roc.logEvent("Downloader:download", "IOException"); inputStream.close(); throw new IOException("The file format is incorrect; it is not in xls/xlsx format.", e); } } }

    代码优化,避免出现OOM情况

  2. Assistant

    下面给出两种思路来优化上述打开 XLSX 的逻辑,一方面保证重试时能真正重读流(否则重试没意义),另一方面在可能的场景下对大文件做“流式”读取,避免一次性把整个表加载到内存,导致 OOM。


    一、通用重试 + 完整关闭流

    如果您的场景文件不是特别大,只是想做“最多重试两次”的保护,可以:

    1. 先把 InputStream 全部读到内存或临时文件里;
    2. 每次重试都用新的流打开;
    3. 用完后保证 OPCPackage 和流都关闭。
    import org.apache.poi.openxml4j.opc.OPCPackage;
    import org.apache.poi.openxml4j.util.ZipSecureFile;
    import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    import org.apache.poi.poifs.filesystem.OfficeXmlFileException;
    import org.apache.poi.InvalidFormatException;
    
    public class ExcelUtils {
    
        /**
         * 打开一个 XLSX 工作簿,最多重试 maxTries 次;若都失败则抛 IOException
         */
        public static XSSFWorkbook openWorkbookWithRetry(byte[] data, int maxTries) throws IOException {
            int attempt = 0;
            while (true) {
                attempt++;
                try (   // 每次重试都用新的 ByteArrayInputStream + OPCPackage
                        ByteArrayInputStream bis = new ByteArrayInputStream(data);
                        OPCPackage pkg = OPCPackage.open(bis);
                ) {
                    // 防范 zip 炸弹
                    ZipSecureFile.setMinInflateRatio(0.005);
                    return new XSSFWorkbook(pkg);
                } catch (OfficeXmlFileException | InvalidFormatException e) {
                    if (attempt >= maxTries) {
                        throw new IOException("文件格式不正确;不是有效的 xlsx", e);
                    }
                    // else 继续重试
                }
            }
        }
    
        /**
         * 外层调用示例:先把原始流读到 byte[]
         */
        public static XSSFWorkbook downloadAndOpen(InputStream inputStream) throws IOException {
            // 1. 把 upstream 的流读成 byte[]
            byte[] data = IOUtils.toByteArray(inputStream);
            // 2. 最多重试2次
            return openWorkbookWithRetry(data, 2);
        }
    }
    

    这样重试时用的是同一份 byte[] 数据,能够保证每次都从头开始解析。

    缺点:如果文件真很大,IOUtils.toByteArray 本身就会把它一次性加载到内存。


    二、超大文件时的“流式”读取(SAX/Event API)

    如果文件很大,确实无法一次性 new XSSFWorkbook(...),建议用 Apache POI 的 Event API,按行/按单元格回调,不把整个表载入内存。代码示例如下:

    import org.apache.poi.openxml4j.opc.OPCPackage;
    import org.apache.poi.ooxml.util.SAXHelper;
    import org.apache.poi.xssf.eventusermodel.XSSFReader;
    import org.apache.poi.xssf.model.SharedStringsTable;
    import org.xml.sax.Attributes;
    import org.xml.sax.ContentHandler;
    import org.xml.sax.helpers.DefaultHandler;
    
    public class StreamingXlsxParser {
    
        public interface RowHandler {
            /** 每读到一行就回调一次,cells 按列序号填入,空单元格会用 null 占位 */
            void handle(int sheetIndex, int rowNum, List<String> cells);
        }
    
        public static void parse(InputStream xlsxStream, RowHandler rowHandler) throws Exception {
            try (OPCPackage pkg = OPCPackage.open(xlsxStream)) {
                XSSFReader reader = new XSSFReader(pkg);
                SharedStringsTable sst = reader.getSharedStringsTable();
    
                XMLReader parser = SAXHelper.newXMLReader();
                for (int sheetIndex = 0; reader.getSheetsData().hasNext(); sheetIndex++) {
                    try (InputStream sheetIs = reader.getSheetsData().next()) {
                        ContentHandler handler = new SheetHandler(sst, sheetIndex, rowHandler);
                        parser.setContentHandler(handler);
                        parser.parse(new InputSource(sheetIs));
                    }
                }
            }
        }
    
        private static class SheetHandler extends DefaultHandler {
            private final SharedStringsTable sst;
            private final int sheetIndex;
            private final RowHandler rowHandler;
            private List<String> curRow;
            private String curCellRef;
            private boolean isStringCell;
            private StringBuilder curValue = new StringBuilder();
    
            public SheetHandler(SharedStringsTable sst, int sheetIndex, RowHandler rowHandler) {
                this.sst = sst;
                this.sheetIndex = sheetIndex;
                this.rowHandler = rowHandler;
            }
    
            // 省略 startElement/endElement/characters 方法的细节实现……
            // 核心思路:
            //  - 在 <row> 开始时 new ArrayList<>();
            //  - 在 <c r="A1" t="s"> 读取单元格类型和引用,遇到 <v>…</v> 收集值,
            //    若是共享字符串就从 sst.getItemAt(idx) 拿文本;
            //  - 在 </row> 时回调 rowHandler.handle(sheetIndex, rowNum, curRow);
        }
    }
    

    调用示例:

    StreamingXlsxParser.parse(inputStream, (sheetIndex, rowNum, cells) -> {
        // 只要实时处理,不用把整个 Workbook 放在内存里
        System.out.println("sheet=" + sheetIndex + " row=" + rowNum + " cells=" + cells);
    });
    

    优点:

    • 整个过程不构造 XSSFWorkbook,内存占用非常低,只要按行/按单元格处理即可。
    • 适合>100MB 的 Excel 文件。

    总结

    • 如果文件不大,只想做“最多重试两次”且格式异常要抛出,第一种「ByteArray + 重试」即可。
    • 如果文件可能非常大(几十甚至上百 MB),千万别用 new XSSFWorkbook(...),应当走 POI 的 Event API(SAX)或第三方的 StreamingReader。

    按你具体场景任选其一即可,有效避免 OOM 并且保证流重试机制生效。

  3. User

    如何使用POI 的 Event API处理大文件

  4. Assistant

    下面给出一个完整示例,演示如何用 Apache POI 的 Event API(基于 SAX)对 .xlsx 做“流式”解析,避免一次性把整个工作簿加载到内存,从而适合处理几百 MB 的大文件。

    1. 引入依赖(Maven)

    <dependencies>
      <!-- POI core -->
      <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>5.2.3</version>
      </dependency>
      <!-- POI OOXML (XLSX) -->
      <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>5.2.3</version>
      </dependency>
    </dependencies>
    

    2. 核心代码

    import org.apache.poi.openxml4j.opc.OPCPackage;
    import org.apache.poi.xssf.eventusermodel.XSSFReader;
    import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
    import org.apache.poi.xssf.model.StylesTable;
    import org.apache.poi.xssf.model.SharedStringsTable;
    import org.xml.sax.InputSource;
    import org.xml.sax.XMLReader;
    import org.xml.sax.helpers.XMLReaderFactory;
    
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    public class StreamingXlsxParser {
    
        /**
         * 解析 .xlsx 文件,对每行回调 handleRow()
         */
        public static void parse(InputStream xlsxInputStream, RowHandler handler) throws Exception {
            // 1. 打开包
            try (OPCPackage pkg = OPCPackage.open(xlsxInputStream)) {
                XSSFReader reader = new XSSFReader(pkg);
                StylesTable styles = reader.getStylesTable();
                SharedStringsTable sst = reader.getSharedStringsTable();
    
                XMLReader parser = XMLReaderFactory.createXMLReader();
                // sheet 数据迭代器
                XSSFReader.SheetIterator sheets = (XSSFReader.SheetIterator) reader.getSheetsData();
                int sheetIndex = 0;
                while (sheets.hasNext()) {
                    try (InputStream sheetStream = sheets.next()) {
                        String sheetName = sheets.getSheetName();
                        // 设置内容处理器:传入样式表、共享字符串表,以及自定义的行处理器
                        XSSFSheetXMLHandler sheetHandler = new XSSFSheetXMLHandler(
                            styles, 
                            sst, 
                            new SimpleSheetContentsHandler(sheetIndex, sheetName, handler),
                            /*是否要保留空单元格*/ true
                        );
                        parser.setContentHandler(sheetHandler);
                        parser.parse(new InputSource(sheetStream));
                        sheetIndex++;
                    }
                }
            }
        }
    
        /**
         * 每读一行就回调:sheetIndex, sheetName, rowNum, rowCells
         */
        public interface RowHandler {
            void handleRow(int sheetIndex, String sheetName, int rowNum, List<String> rowCells);
        }
    
        /**
         * XSSFSheetXMLHandler.SheetContentsHandler 默认实现,按行收集所有 cell 值
         */
        private static class SimpleSheetContentsHandler implements XSSFSheetXMLHandler.SheetContentsHandler {
            private final int sheetIndex;
            private final String sheetName;
            private final RowHandler rowHandler;
            private int currentRow = -1;
            private List<String> cellList;
    
            public SimpleSheetContentsHandler(int sheetIndex, String sheetName, RowHandler rowHandler) {
                this.sheetIndex = sheetIndex;
                this.sheetName = sheetName;
                this.rowHandler = rowHandler;
            }
    
            @Override
            public void startRow(int rowNum) {
                currentRow = rowNum;
                cellList = new ArrayList<>();
            }
    
            @Override
            public void endRow(int rowNum) {
                rowHandler.handleRow(sheetIndex, sheetName, rowNum, cellList);
            }
    
            @Override
            public void cell(String cellReference, String formattedValue, XSSFSheetXMLHandler.CellComment comment) {
                // cellReference 比如 "A1","B3"…… 这里只按顺序放入 List
                cellList.add(formattedValue);
            }
    
            @Override
            public void headerFooter(String text, boolean isHeader, String tagName) {
                // 无需关心
            }
        }
    }
    

    3. 使用示例

    import java.io.FileInputStream;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) throws Exception {
            try (FileInputStream fis = new FileInputStream("big-data.xlsx")) {
                StreamingXlsxParser.parse(fis, (sheetIndex, sheetName, rowNum, rowCells) -> {
                    // 在这里处理每一行的数据
                    System.out.printf("sheet[%d]=%s row=%d values=%s%n",
                        sheetIndex, sheetName, rowNum, rowCells);
                });
            }
        }
    }
    

    4. 原理和优点

    1. 基于 SAX 事件驱动
      不会把整个文档或表格一次性载入内存,只在解析到一个 <row> 时创建 List,行结束后马上回调处理,再丢弃该 List。
    2. 低内存占用
      适合上百 MB 的 Excel 文件。POI 内部只缓存当前解析片段所需数据(SharedStrings、Styles);大部分行/单元格数据解析完即释放。
    3. 灵活
      • 你可以自定义 RowHandler,比如只对某些列感兴趣,或者遇到特定行直接终止解析(抛个控制流异常)
      • XSSFSheetXMLHandler 也支持更细粒度的事件(每个单元格类型、注释等)

    这样,你就可以在有限内存环境下安全、快速地处理任意大小的 .xlsx 文件了。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.