解决大批量数据导出Excel产生内存溢出的方案

POI或者JXL在导出大量数据的时候，由于它们将每一个单元格生都成一个Cell对象，所以很容易导致内存溢出。解决这个问题，唯一的办法是弄清楚Excel的二进制格式（汗），并且用流的方式读写Excel。POI和JXL其实提供了二进制方式读写Excel的API，只是因为缺少文档和实例，所以使用的人不多。我编写了这个简单的合并Excel的类，它只适合合并结构相同的多个Excel文件。好在这个功能已经可以解决数据导出产生OOM的问题：将数据分批导出然后合并。
下面的代码使用POI3.1，合并11个3000多行的文档用时约6秒，我实在找不到更多的测试用的文档了。

Java代码
1.@SuppressWarnings("unchecked")  
2.public class XlsMergeUtil {  
3.  private static Logger logger = LoggerFactory.getLogger(XlsMergeUtil.class);  
4. 
5.  /** 
6.   * 将多个Xls文件合并为一个，适用于只有一个sheet，并且格式相同的文档 
7.   * @param inputs 输入的Xls文件 
8.   * @param out 输出文件 
9.   */ 
10.  public static void merge(InputStream[] inputs, OutputStream out) {  
11.    if (inputs == null || inputs.length <= 1) {  
12.      throw new IllegalArgumentException("没有传入输入流数组,或只有一个输入流.");  
13.    }  
14. 
15.    List<Record> rootRecords = getRecords(inputs[0]);  
16.    Workbook workbook = Workbook.createWorkbook(rootRecords);  
17.    List<Sheet> sheets = getSheets(workbook, rootRecords);  
18.    if(sheets == null || sheets.size() == 0) {  
19.      throw new IllegalArgumentException("第一篇文档的格式错误，必须有至少一个sheet");  
20.    }  
21.    //以第一篇文档的最后一个sheet为根，以后的数据都追加在这个sheet后面  
22.    Sheet rootSheet = sheets.get(sheets.size() - 1);   
23.    int rootRows = getRowsOfSheet(rootSheet); //记录第一篇文档的行数，以后的行数在此基础上增加  
24.    rootSheet.setLoc(rootSheet.getDimsLoc());  
25.    Map<Integer, Integer> map = new HashMap(10000);  
26. 
27.    for (int i = 1; i < inputs.length; i++) { //从第二篇开始遍历  
28.      List<Record> records = getRecords(inputs[i]);  
29.      int rowsOfCurXls = 0;  
30.      //遍历当前文档的每一个record  
31.      for (Iterator itr = records.iterator(); itr.hasNext();) {  
32.        Record record = (Record) itr.next();  
33.        if (record.getSid() == RowRecord.sid) { //如果是RowRecord  
34.          RowRecord rowRecord = (RowRecord) record;  
35.          //调整行号  
36.          rowRecord.setRowNumber(rootRows + rowRecord.getRowNumber());  
37.          rootSheet.addRow(rowRecord); //追加Row  
38.          rowsOfCurXls++; //记录当前文档的行数  
39.        }  
40.        //SST记录，SST保存xls文件中唯一的String，各个String都是对应着SST记录的索引  
41.        else if (record.getSid() == SSTRecord.sid) {  
42.          SSTRecord sstRecord = (SSTRecord) record;  
43.          for (int j = 0; j < sstRecord.getNumUniqueStrings(); j++) {  
44.            int index = workbook.addSSTString(sstRecord.getString(j));  
45.            //记录原来的索引和现在的索引的对应关系  
46.            map.put(Integer.valueOf(j), Integer.valueOf(index));  
47.          }  
48.        } else if (record.getSid() == LabelSSTRecord.sid) {  
49.          LabelSSTRecord label = (LabelSSTRecord) record;  
50.          //调整SST索引的对应关系  
51.          label.setSSTIndex(map.get(Integer.valueOf(label.getSSTIndex())));  
52.        }  
53.        //追加ValueCell  
54.        if (record instanceof CellValueRecordInterface) {  
55.          CellValueRecordInterface cell = (CellValueRecordInterface) record;  
56.          int cellRow = cell.getRow() + rootRows;  
57.          cell.setRow(cellRow);  
58.          rootSheet.addValueRecord(cellRow, cell);  
59.        }  
60.      }  
61.      rootRows += rowsOfCurXls;  
62.    }  
63.    byte[] data = getBytes(workbook, sheets.toArray(new Sheet[0]));  
64.    write(out, data);  
65.  }  
66. 
67.  static void write(OutputStream out, byte[] data) {  
68.    POIFSFileSystem fs = new POIFSFileSystem();  
69.    // Write out the Workbook stream  
70.    try {  
71.      fs.createDocument(new ByteArrayInputStream(data), "Workbook");  
72.      fs.writeFilesystem(out);  
73.      out.flush();  
74.    } catch (IOException e) {  
75.      e.printStackTrace();  
76.    } finally {  
77.      try {  
78.        out.close();  
79.      } catch (IOException e) {  
80.        e.printStackTrace();  
81.      }  
82.    }  
83.  }  
84. 
85.  static List<Sheet> getSheets(Workbook workbook, List records) {  
86.    int recOffset = workbook.getNumRecords();  
87.    int sheetNum = 0;  
88. 
89.    // convert all LabelRecord records to LabelSSTRecord  
90.    convertLabelRecords(records, recOffset, workbook);  
91.    List<Sheet> sheets = new ArrayList();  
92.    while (recOffset < records.size()) {  
93.      Sheet sh = Sheet.createSheet(records, sheetNum++, recOffset);  
94. 
95.      recOffset = sh.getEofLoc() + 1;  
96.      if (recOffset == 1) {  
97.        break;  
98.      }  
99.      sheets.add(sh);  
100.    }  
101.    return sheets;  
102.  }  
103. 
104.  static int getRows(List<Record> records) {  
105.    int row = 0;  
106.    for (Iterator itr = records.iterator(); itr.hasNext();) {  
107.      Record record = (Record) itr.next();  
108.      if (record.getSid() == RowRecord.sid) {  
109.        row++;  
110.      }  
111.    }  
112.    return row;  
113.  }  
114.    
115.  static int getRowsOfSheet(Sheet sheet) {  
116.    int rows = 0;  
117.    sheet.setLoc(0);  
118.    while(sheet.getNextRow() != null) {  
119.      rows++;  
120.    }  
121.    return rows;  
122.  }  
123. 
124.  @SuppressWarnings("deprecation")  
125.  static List<Record> getRecords(InputStream input) {  
126.    try {  
127.      POIFSFileSystem poifs = new POIFSFileSystem(input);  
128.      InputStream stream = poifs.getRoot().createDocumentInputStream("Workbook");  
129.      return org.apache.poi.hssf.record.RecordFactory.createRecords(stream);  
130.    } catch (IOException e) {  
131.      logger.error("IO异常：{}", e.getMessage());  
132.      e.printStackTrace();  
133.    }  
134.    return Collections.EMPTY_LIST;  
135.  }  
136. 
137.  static void convertLabelRecords(List records, int offset, Workbook workbook) {  
138. 
139.    for (int k = offset; k < records.size(); k++) {  
140.      Record rec = (Record) records.get(k);  
141. 
142.      if (rec.getSid() == LabelRecord.sid) {  
143.        LabelRecord oldrec = (LabelRecord) rec;  
144. 
145.        records.remove(k);  
146.        LabelSSTRecord newrec = new LabelSSTRecord();  
147.        int stringid = workbook.addSSTString(new UnicodeString(oldrec.getValue()));  
148. 
149.        newrec.setRow(oldrec.getRow());  
150.        newrec.setColumn(oldrec.getColumn());  
151.        newrec.setXFIndex(oldrec.getXFIndex());  
152.        newrec.setSSTIndex(stringid);  
153.        records.add(k, newrec);  
154.      }  
155.    }  
156.  }  
157. 
158.  public static byte[] getBytes(Workbook workbook, Sheet[] sheets) {  
159.    // HSSFSheet[] sheets = getSheets();  
160.    int nSheets = sheets.length;  
161. 
162.    // before getting the workbook size we must tell the sheets that  
163.    // serialization is about to occur.  
164.    for (int i = 0; i < nSheets; i++) {  
165.      sheets[i].preSerialize();  
166.    }  
167. 
168.    int totalsize = workbook.getSize();  
169. 
170.    // pre-calculate all the sheet sizes and set BOF indexes  
171.    int[] estimatedSheetSizes = new int[nSheets];  
172.    for (int k = 0; k < nSheets; k++) {  
173.      workbook.setSheetBof(k, totalsize);  
174.      int sheetSize = sheets[k].getSize();  
175.      estimatedSheetSizes[k] = sheetSize;  
176.      totalsize += sheetSize;  
177.    }  
178. 
179.    byte[] retval = new byte[totalsize];  
180.    int pos = workbook.serialize(0, retval);  
181. 
182.    for (int k = 0; k < nSheets; k++) {  
183.      int serializedSize = sheets[k].serialize(pos, retval);  
184.      if (serializedSize != estimatedSheetSizes[k]) {  
185.            throw new IllegalStateException("Actual serialized sheet size (" + serializedSize  
186.            + ") differs from pre-calculated size (" + estimatedSheetSizes[k] + ") for sheet (" + k  
187.            + ")");  
188.        Sheet.serializeIndexRecord() does not  
189.      }  
190.      pos += serializedSize;  
191.    }  
192.    return retval;  
193.  }  
194. 
195.  public static void main(String[] args) throws Exception {  
196.    final String PATH = "E:\\projects\\java\\ws_0\\export\\data\\";  
197.    InputStream[] inputs = new InputStream[10];  
198.    inputs[0] = new java.io.FileInputStream(PATH + "07_10.xls");  
199.    for(int i = 1; i <= 9; i++) {  
200.      inputs[i] = new java.io.FileInputStream(PATH + "07_0" + i + ".xls");  
201.    }  
202.    OutputStream out = new FileOutputStream(PATH + "xx.xls");  
203.    long t1 = System.currentTimeMillis();  
204.    merge(inputs, out);  
205.    System.out.println(System.currentTimeMillis() - t1);//简陋的测试一下时间  
206.  }  
207. 
208.}