• 聊聊Excel的大批量导入导出

    几乎每个后台管理系统都难逃excel导入和导出的功能，目前针对大数据量的导入和导出多数是使用EasyExcel，EasyExcel极大地简单了java对excel的读写操作，从pom的依赖上知道easyexcel依赖POI，那么EasyExcel是如何实现高性能的excel读写操作呢，实现上和POI有什么区别和联系呢？

    要讲EasyExcel，必须先讲一下excel版本和POI。

    关于Excel版本

    版本

    最大数据量

    后缀

    文档类型

    解压后的文件结构

    2003

    65535

    .xls

    复合文档

    2007

    1048575

    .xlsx

    XML文档

    Excel2007及以上版本，其文件由多个xml文件打包组成，其存数据的文件位于xl/worksheets/下，一个sheet以一个xml文件的形成存在，而正是由于这个文件结构，java可凭借其丰富强大的xml解析类库，实现对xml文件的流式追加写入和流式读取，避免全量读入数据而内存溢出，使读取大批量数据成为可能。

    POI

    可用于操作Microsoft Office的相关文件(可用于excel,word,ppt等)的一套程序库，apache出品。POI用于操作Excel的对象都是实现了Workbook接口的类.

    Workboot是创建Excel对象或Sheet等的顶级对象,主要的子类有：E

    实现类

    Excel版本

    特点

    HSSFWorkbook

    2003及以前

    对象常驻内存，易OOM

    XSSFWorkbook

    2007及以后

    对象常驻内存，易OOM

    SXSSFWorkbook

    2007及以后

    流式的XSSFWorkbook，

    有效避免OOM，仅用于写

    这三套实现，还对应着各自的家族成员

    工作簿HSSFWorkbookXSSFWorkbookSXSSFWorkbook
    SheetHSSFSheetXSSFSheetSXSSFSheet
    行HSSFRowXSSFRowSXSSFRow
    单元格HSSFCellXSSFCellSXSSFCell

    其中HSSFWorkbook和XSSFWorkbook对Excel的处理和解析是非常吃内存的，每个单元格都是一个 Cell对象，每个Cell对象又有CellStyle对象，想想1个10列*10W行，单单它的Cell对象就已经有100W个，如果需要全部加载进内存，无疑是程序的灾难，于是SXSSFWorkbook随之出现。

    SXSSFWorkbook

    SXSSFWorkbook是streaming版本的XSSFWorkbook,它只会保存最新的excel rows（默认100行）在内存里供查看，在此之前的excel rows都会被写入到硬盘里。被写入到硬盘里的rows对程序而言是不可见的,详见：

    SXSSFSheet#createRow

    1. public SXSSFRow createRow(int rownum) {
    2.         int maxrow = SpreadsheetVersion.EXCEL2007.getLastRowIndex();
    3.         if (rownum < 0 || rownum > maxrow) {
    4.             throw new IllegalArgumentException("Invalid row number (" + rownum
    5.                     + ") outside allowable range (0.." + maxrow + ")");
    6.         }
    7.  
    8.         // attempt to overwrite a row that is already flushed to disk
    9.         if(rownum <= _writer.getLastFlushedRow() ) {
    10.             throw new IllegalArgumentException(
    11.                     "Attempting to write a row["+rownum+"] " +
    12.                     "in the range [0," + _writer.getLastFlushedRow() + "] that is already written to disk.");
    13.         }
    14.  
    15.         // attempt to overwrite a existing row in the input template
    16.         if(_sh.getPhysicalNumberOfRows() > 0 && rownum <= _sh.getLastRowNum() ) {
    17.             throw new IllegalArgumentException(
    18.                     "Attempting to write a row["+rownum+"] " +
    19.                             "in the range [0," + _sh.getLastRowNum() + "] that is already written to disk.");
    20.         }
    21.  
    22.         SXSSFRow newRow = new SXSSFRow(this);
    23.         _rows.put(rownum, newRow);
    24.         allFlushed = false;
    25.         if(_randomAccessWindowSize >= 0 && _rows.size() > _randomAccessWindowSize) {
    26.             try {
    27.                //如果写入的行数>_randomAccessWindowSize(默认100),则将老的记录写入磁盘
    28.                flushRows(_randomAccessWindowSize);
    29.             } catch (IOException ioe) {
    30.                 throw new RuntimeException(ioe);
    31.             }
    32.         }
    33.         return newRow;
    34.     }

    在创建新行的过程中，SXSSFSheet通过flushRows()将多于随机读取窗口大小的Row写入磁盘的临时文件中，同时从内存中移除，从而实现内存减负，避免OOM的出现。

    原生POI，通过SXSSF系列API，可以实现100W数据无压力输出（在-Xmx20M下即可运行）

    POI版的导出程序(DEMO)

    1. import java.io.File;
    2. import java.io.FileOutputStream;
    3. import java.io.IOException;
    4. import java.lang.reflect.Field;
    5. import java.util.Collection;
    6.  
    7. import org.apache.commons.beanutils.BeanUtils;
    8. import org.apache.poi.ss.usermodel.Row;
    9. import org.apache.poi.xssf.streaming.SXSSFSheet;
    10. import org.apache.poi.xssf.streaming.SXSSFWorkbook;
    11.  
    12. import com.alibaba.excel.annotation.ExcelProperty;
    13.  
    14. public class PoiWriter {
    15.  
    16. 	private SXSSFWorkbook workbook = null;
    17. 	private SXSSFSheet sheet = null;
    18. 	private Class head = null;
    19. 	private boolean headerInited = false;
    20. 	private int rowNum = 0;
    21. 	
    22. 	public PoiWriter(Class head) {
    23. 		this.workbook = new SXSSFWorkbook();
    24. 		this.sheet = workbook.createSheet("sheet0");
    25.     	this.head = head;
    26. 	}
    27. 	
    28. 	public void write(Collection dataset) throws Exception {
    29. 		initHeader();
    30. 		for (T object : dataset) {
    31. 			writeRow(object);
    32. 		}
    33. 	}
    34.  
    35. 	private void writeRow(T object) throws Exception {
    36. 		Field[] fields = head.getDeclaredFields();
    37. 		Row row = sheet.createRow(rowNum ++);
    38. 		int index = 0;
    39. 		for (Field field : fields) {
    40. 			String value = BeanUtils.getProperty(object, field.getName());
    41. 			row.createCell(index ++).setCellValue(value);
    42. 		}
    43. 	}
    44.  
    45. 	public void flush(String fileName) throws IOException {
    46. 		FileOutputStream fos = new FileOutputStream(new File(fileName));
    47. 		workbook.write(fos);
    48. 		fos.close();
    49. 	}
    50. 	
    51. 	private void initHeader() {
    52. 		if(!headerInited) {
    53. 			createHeader();
    54. 			headerInited = true;
    55. 		}
    56. 	}
    57.  
    58. 	private void createHeader() {
    59. 		Field[] fields = head.getDeclaredFields();
    60. 		int index = 0;
    61. 		Row row = sheet.createRow(rowNum ++);
    62. 		for (Field field : fields) {
    63. 			ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
    64. 			String columnName = excelProperty != null ? excelProperty.value()[0] : field.getName();
    65. 			row.createCell(index ++).setCellValue(columnName);
    66. 		}
    67. 	}
    68. 	
    69. }
    1. public class PoiWriterTest {
    2.  
    3. 	@Test
    4. 	public void write() throws Exception {
    5. 		PoiWriter poiWriter = new PoiWriter<>(Student.class);
    6. 		int pageSize = 1000;
    7. 		for (int pageNo = 1; pageNo <= 100; pageNo++) {
    8. 			poiWriter.write(pageQuery(pageNo, pageSize));
    9. 		}
    10. 		poiWriter.flush("D:/stu.xlsx");
    11. 	}
    12.     
    13.     //模拟分页查询
    14. 	private List pageQuery(int pageNo, int pageSize) {
    15. 		List students = new ArrayList<>();
    16. 		for (int i = 0; i < pageSize; i++) {
    17. 			int index = (pageNo - 1) * pageSize + i;
    18. 			students.add(build(index));
    19. 		}
    20. 		return students;
    21. 	}
    22.     
    23. 	private Student build(int index) {
    24. 		Student s = new Student();
    25. 		s.setName("学生" + index);
    26. 		s.setAddress("地址" + index);
    27. 		s.setAge(String.valueOf(RandomUtils.nextInt(20, 30)));
    28. 		s.setClazz("班别" + index % 8);
    29. 		s.setGrade("年级" + index % 6);
    30. 		s.setTel(String.valueOf(13500000000L + RandomUtils.nextInt(1, 10000000)));
    31. 		s.setChinese(String.valueOf(RandomUtils.nextInt(50, 100)));
    32. 		s.setEnglish(String.valueOf(RandomUtils.nextInt(50, 100)));
    33. 		return s;
    34. 	}
    35. }
    1. @Data
    2. public class Student {
    3. 	
    4. 	@ExcelProperty(value="英语")
    5. 	private String english;
    6. 	@ExcelProperty(value="姓名")
    7. 	private String name;
    8. 	@ExcelProperty(value="年龄")
    9. 	private String age;
    10. 	@ExcelProperty(value="学校")
    11. 	private String school;
    12. 	@ExcelProperty(value="年级")
    13. 	private String grade;
    14. 	@ExcelProperty(value="班别")
    15. 	private String clazz;
    16. 	@ExcelProperty(value="地址")
    17. 	private String address;
    18. 	@ExcelProperty(value="电话")
    19. 	private String tel;
    20. 	@ExcelProperty(value="语文")
    21. 	private String chinese;
    22. 	@ExcelProperty(value="数学")
    23. 	private String math;
    24.  
    25. }

    注意，这时的写到磁盘，只是当前用户的一个临时目录，是一个xml文件，里面记录着行的内容，格式化后形如：

    1. <row r="1">
    2.     <c r="A1" s="1" t="inlineStr">
    3.         <is>
    4.             <t>内容1t>
    5.         is>
    6.     c>
    7.     <c r="B1" s="1" t="inlineStr">
    8.         <is>
    9.             <t>内容2t>
    10.         is>
    11.     c>
    12. row>

    表示一行，表示一个单元格，记录单元格的内容，其它各自脑补。

    SXSSFWorkbook只实现了流式写，并没有实现流式读，流式读取excel需要通过Sax模式的事件API进行实现，该核心实现如下：

    POI版Excel解析(DEMO)

    1. public class PoiSaxReader {
    2. 	
    3. 	public void read(String path, AbstractSheetHandler handler) throws Exception {
    4.         // 1.根据excel报表获取OPCPackage
    5.         OPCPackage opcPackage = OPCPackage.open(path, PackageAccess.READ);
    6.         // 2.创建XSSFReader
    7.         XSSFReader reader = new XSSFReader(opcPackage);
    8.         // 3.获取SharedStringTable对象
    9.         SharedStringsTable table = reader.getSharedStringsTable();
    10.         // 4.获取styleTable对象
    11.         StylesTable stylesTable = reader.getStylesTable();
    12.         // 5.创建Sax的xmlReader对象
    13.         XMLReader xmlReader = XMLReaderFactory.createXMLReader();
    14.         // 6.注册事件处理器
    15.         XSSFSheetXMLHandler xmlHandler = new XSSFSheetXMLHandler(stylesTable, table, handler, false);
    16.         xmlReader.setContentHandler(xmlHandler);
    17.         // 7.第一个sheet的流数据
    18.         XSSFReader.SheetIterator sheetIterator = (XSSFReader.SheetIterator) reader.getSheetsData();
    19.         InputStream stream = sheetIterator.next();
    20.         InputSource is = new InputSource(stream);
    21.         // 8.最关键:执行xml解析,解析过程中会回调XSSFSheetXMLHandler的startElement等方法
    22.         xmlReader.parse(is);
    23. 	}
    24. 	
    25. 	static class StudentHandler extends AbstractSheetHandler {
    26. 		
    27. 		private int total = 0;
    28. 		
    29. 		@Override
    30. 		protected void invoke(Student object) {
    31. 			total += 1;
    32. 			if(total % 1000 == 0) {
    33. 				System.out.println("读取到:"+total);
    34. 				System.out.println(object);
    35. 			}
    36. 		}
    37. 		
    38. 	}
    39. 	
    40. 	public static void main(String[] args) throws Exception {
    41. 		PoiSaxReader reader = new PoiSaxReader();
    42. 		reader.read("D:/stu_100W.xlsx", new StudentHandler());
    43. 	}
    44. 	
    45. }
    1. /**
    2.  * 基于Sax的解析处理器抽象
    3.  */
    4. public abstract class AbstractSheetHandler implements XSSFSheetXMLHandler.SheetContentsHandler {
    5.  
    6.     // 将输出到excel的对象
    7.     private T object;
    8.     private Class clazz;
    9.     
    10.     @SuppressWarnings("unchecked")
    11. 	public AbstractSheetHandler() {
    12.     	Type genType = getClass().getGenericSuperclass();
    13. 		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    14. 		this.clazz = (Class) params[0];
    15.     }
    16.  
    17.     /**
    18.      * 当开始解析某一行的时候触发
    19.      */
    20.     @Override
    21.     public void startRow(int i) {
    22. 		try {
    23. 			object = clazz.newInstance();
    24. 		} catch (InstantiationException | IllegalAccessException e) {
    25. 			e.printStackTrace();
    26. 		}
    27.     }
    28.  
    29.     /**
    30.      * 当结束解析某一行的时候触发
    31.      */
    32.     @Override
    33.     public void endRow(int i) {
    34.     	invoke(object);
    35.     }
    36.  
    37.     
    38. 	protected abstract void invoke(T object);
    39. 	/**
    40.      * cellReference:单元格引用,形如A1,B1
    41.      */
    42.     @Override
    43.     public void cell(String cellReference, String value, XSSFComment xssfComment) {
    44.         Field[] fields = clazz.getDeclaredFields();
    45.         int columnIndex = new CellReference(cellReference).getCol();
    46.         try {
    47. 			BeanUtils.setProperty(object, fields[columnIndex].getName(), value);
    48. 		} catch (IllegalAccessException | InvocationTargetException e) {
    49. 			e.printStackTrace();
    50. 		}
    51.     }
    52. }

    以上程序，同样在-Xmx20M下可以成功运行。该程序只是孤立地对每一条数据进行处理，真实情况下程序可能需要拿到所有行的完整视图，如果需要将所有对象放进一个List中，那所消耗的内存当然远不止20M，但这种只能说是业务消耗的内存，而非POI消耗的内存。

    上面用到的一些类可能都相对陌生，其核心逻辑就是解压xlsx文件，然后通过sax事件驱动模式对excel数据(即xml)进行逐行解释。这里重要的一个点是XSSFSheetXMLHandler 

    XSSFSheetXMLHandler

    该类继承自DefaultHandler，XMLReader执行解析的过程中，会回调其startElement/endElement/characters等方法，后面说到的easyexcel，其解析过程是easyexcel自己搞一个XlsxRowHandler。

    原生的POI虽然可以实现大数据量的导入和导出，但对于业务开发人员来说，使用起来还是没那么友好，特别是在处理大数据量导入的时候，EasyExcel基于POI，主要解决易用度的问题，同时也对POI使用Sax事件API进行数据行解释那一块进行了重写，减少了内存消耗。见EasyExcel官网的解释

    Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出；03版依赖POI的sax模式，在上层做了模型转换的封装，让使用者更加简单方便

    EasyExcel

    读Excel 

    1.     @Test
    2. 	public void read() {
    3.         EasyExcel.read("D:/stu_100W.xlsx", Student.class, new PageReadListener(dataList -> {
    4.         	log.info("读取到:{}", dataList.size());
    5.         })).sheet().doRead();
    6. 	}

    EasyExcel的API确实很简洁，一波debug跟进，来到XlsxSaxAnalyser#execute

    XlsxSaxAnalyser#execute 

    1. @Override
    2.     public void execute() {
    3.         for (ReadSheet readSheet : sheetList) {
    4.             readSheet = SheetUtils.match(readSheet, xlsxReadContext);
    5.             if (readSheet != null) {
    6.                 xlsxReadContext.currentSheet(readSheet);
    7.                 // 注意这个 XlsxRowHandler
    8.                 parseXmlSource(sheetMap.get(readSheet.getSheetNo()), new XlsxRowHandler(xlsxReadContext));
    9.                 readComments(readSheet);
    10.                 xlsxReadContext.analysisEventProcessor().endSheet(xlsxReadContext);
    11.             }
    12.         }
    13.     }
    14.  
    15.     private void parseXmlSource(InputStream inputStream, ContentHandler handler) {
    16.         InputSource inputSource = new InputSource(inputStream);
    17.         try {
    18.             SAXParserFactory saxFactory;
    19.             String xlsxSAXParserFactoryName = xlsxReadContext.xlsxReadWorkbookHolder().getSaxParserFactoryName();
    20.             if (StringUtils.isEmpty(xlsxSAXParserFactoryName)) {
    21.                 saxFactory = SAXParserFactory.newInstance();
    22.             } else {
    23.                 saxFactory = SAXParserFactory.newInstance(xlsxSAXParserFactoryName, null);
    24.             }
    25.             try {
    26.                 saxFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
    27.             } catch (Throwable ignore) {}
    28.             try {
    29.                 saxFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
    30.             } catch (Throwable ignore) {}
    31.             try {
    32.                 saxFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
    33.             } catch (Throwable ignore) {}
    34.             SAXParser saxParser = saxFactory.newSAXParser();
    35.             XMLReader xmlReader = saxParser.getXMLReader();
    36.             xmlReader.setContentHandler(handler);
    37.             //和POI一样的套路
    38.             xmlReader.parse(inputSource);
    39.             inputStream.close();
    40.         } catch (IOException | ParserConfigurationException | SAXException e) {
    41.             throw new ExcelAnalysisException(e);
    42.         } finally {
    43.             if (inputStream != null) {
    44.                 try {
    45.                     inputStream.close();
    46.                 } catch (IOException e) {
    47.                     throw new ExcelAnalysisException("Can not close 'inputStream'!");
    48.                 }
    49.             }
    50.         }
    51.     }

     XlsxRowHandler

    1. public class XlsxRowHandler extends DefaultHandler {
    2.     private final XlsxReadContext xlsxReadContext;
    3.     private static final Map XLSX_CELL_HANDLER_MAP = new HashMap(32);
    4.  
    5.     static {
    6.         CellFormulaTagHandler cellFormulaTagHandler = new CellFormulaTagHandler();
    7.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.CELL_FORMULA_TAG, cellFormulaTagHandler);
    8.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_CELL_FORMULA_TAG, cellFormulaTagHandler);
    9.         CellInlineStringValueTagHandler cellInlineStringValueTagHandler = new CellInlineStringValueTagHandler();
    10.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.CELL_INLINE_STRING_VALUE_TAG, cellInlineStringValueTagHandler);
    11.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_CELL_INLINE_STRING_VALUE_TAG, cellInlineStringValueTagHandler);
    12.         CellTagHandler cellTagHandler = new CellTagHandler();
    13.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.CELL_TAG, cellTagHandler);
    14.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_CELL_TAG, cellTagHandler);
    15.         CellValueTagHandler cellValueTagHandler = new CellValueTagHandler();
    16.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.CELL_VALUE_TAG, cellValueTagHandler);
    17.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_CELL_VALUE_TAG, cellValueTagHandler);
    18.         CountTagHandler countTagHandler = new CountTagHandler();
    19.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.DIMENSION_TAG, countTagHandler);
    20.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_DIMENSION_TAG, countTagHandler);
    21.         HyperlinkTagHandler hyperlinkTagHandler = new HyperlinkTagHandler();
    22.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.HYPERLINK_TAG, hyperlinkTagHandler);
    23.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_HYPERLINK_TAG, hyperlinkTagHandler);
    24.         MergeCellTagHandler mergeCellTagHandler = new MergeCellTagHandler();
    25.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.MERGE_CELL_TAG, mergeCellTagHandler);
    26.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_MERGE_CELL_TAG, mergeCellTagHandler);
    27.         RowTagHandler rowTagHandler = new RowTagHandler();
    28.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.ROW_TAG, rowTagHandler);
    29.         XLSX_CELL_HANDLER_MAP.put(ExcelXmlConstants.X_ROW_TAG, rowTagHandler);
    30.     }
    31.  
    32.     public XlsxRowHandler(XlsxReadContext xlsxReadContext) {
    33.         this.xlsxReadContext = xlsxReadContext;
    34.     }
    35.  
    36.     @Override
    37.     public void startElement(String uri, String localName, String name, Attributes attributes) throws SAXException {
    38.         XlsxTagHandler handler = XLSX_CELL_HANDLER_MAP.get(name);
    39.         if (handler == null || !handler.support(xlsxReadContext)) {
    40.             return;
    41.         }
    42.         xlsxReadContext.xlsxReadSheetHolder().getTagDeque().push(name);
    43.         handler.startElement(xlsxReadContext, name, attributes);
    44.     }
    45.  
    46.     @Override
    47.     public void characters(char[] ch, int start, int length) throws SAXException {
    48.         String currentTag = xlsxReadContext.xlsxReadSheetHolder().getTagDeque().peek();
    49.         if (currentTag == null) {
    50.             return;
    51.         }
    52.         XlsxTagHandler handler = XLSX_CELL_HANDLER_MAP.get(currentTag);
    53.         if (handler == null || !handler.support(xlsxReadContext)) {
    54.             return;
    55.         }
    56.         handler.characters(xlsxReadContext, ch, start, length);
    57.     }
    58.  
    59.     @Override
    60.     public void endElement(String uri, String localName, String name) throws SAXException {
    61.         XlsxTagHandler handler = XLSX_CELL_HANDLER_MAP.get(name);
    62.         if (handler == null || !handler.support(xlsxReadContext)) {
    63.             return;
    64.         }
    65.         handler.endElement(xlsxReadContext, name);
    66.         xlsxReadContext.xlsxReadSheetHolder().getTagDeque().pop();
    67.     }
    68.  
    69. }

    相比于XSSFSheetXMLHandler,XlsxRowHandler维护一个XlsxTagHandler的集合，XlsxRowHandler充当一个门面，解析逻辑交给各个具体的XlsxTagHandler

    XlsxTagHandler

    easyexcel实现了如下的XlsxTagHandler:

    ​

     其中CellTagHandler解析元素，CellValueTagHandler和CellInlineStringValueTagHandler解析和等元素，提取出单元格内容，这里不做过多阐述。

    写Excel

    1.     @Test
    2. 	public void export() {
    3. 		ExcelWriter excelWriter = EasyExcel.write("D:/student_100W.xlsx", Student.class).build();
    4. 		WriteSheet sheet0 = EasyExcel.writerSheet("sheet0").build();
    5. 		for (int pageNo = 1; pageNo <= 2; pageNo++) {
    6. 			excelWriter.write(studentService.pageQuery(pageNo, pageSize), sheet0);
    7. 		}
    8. 		excelWriter.finish();
    9. 	}

    EasyExcel的POI进行了良好的封装，简单易用，API在使用上很符合大家使用日常操作excel的习惯：

     

    得益于POI的SXSSFSheet.createRow时，会进行自动将老的Row进行刷盘操作，EasyExcel只在SXSSF家族上面做一个封装，即可实现大数据量的写入操作。主要代码见：

    ExcelWriteAddExecutor#add

    1. public void add(Collection data) {
    2.         if (CollectionUtils.isEmpty(data)) {
    3.             data = new ArrayList<>();
    4.         }
    5.         WriteSheetHolder writeSheetHolder = writeContext.writeSheetHolder();
    6.         int newRowIndex = writeSheetHolder.getNewRowIndexAndStartDoWrite();
    7.         if (writeSheetHolder.isNew() && !writeSheetHolder.getExcelWriteHeadProperty().hasHead()) {
    8.             newRowIndex += writeContext.currentWriteHolder().relativeHeadRowIndex();
    9.         }
    10.         // BeanMap is out of order, so use sortedAllFieldMap
    11.         Map sortedAllFieldMap = new TreeMap<>();
    12.         int relativeRowIndex = 0;
    13.         for (Object oneRowData : data) {
    14.             int lastRowIndex = relativeRowIndex + newRowIndex;
    15.             addOneRowOfDataToExcel(oneRowData, lastRowIndex, relativeRowIndex, sortedAllFieldMap);
    16.             relativeRowIndex++;
    17.         }
    18.     }
    19.  
    20. //向Excel写入一行
    21. private void addOneRowOfDataToExcel(Object oneRowData, int rowIndex, int relativeRowIndex,
    22.         Map sortedAllFieldMap) {
    23.         if (oneRowData == null) {
    24.             return;
    25.         }
    26.         RowWriteHandlerContext rowWriteHandlerContext = WriteHandlerUtils.createRowWriteHandlerContext(writeContext,
    27.             rowIndex, relativeRowIndex, Boolean.FALSE);
    28.         WriteHandlerUtils.beforeRowCreate(rowWriteHandlerContext);
    29.         //这里调用:SXSSFSheet#createRow
    30.         Row row = WorkBookUtil.createRow(writeContext.writeSheetHolder().getSheet(), rowIndex);
    31.         rowWriteHandlerContext.setRow(row);
    32.  
    33.         WriteHandlerUtils.afterRowCreate(rowWriteHandlerContext);
    34.  
    35.         if (oneRowData instanceof Collection) {
    36.             addBasicTypeToExcel(new CollectionRowData((Collection)oneRowData), row, rowIndex, relativeRowIndex);
    37.         } else if (oneRowData instanceof Map) {
    38.             addBasicTypeToExcel(new MapRowData((Map)oneRowData), row, rowIndex, relativeRowIndex);
    39.         } else {
    40.             addJavaObjectToExcel(oneRowData, row, rowIndex, relativeRowIndex, sortedAllFieldMap);
    41.         }
    42.  
    43.         WriteHandlerUtils.afterRowDispose(rowWriteHandlerContext);
    44.     }

    总结：

    1.EasyExcel的写，借助于SXSSFSheet.createRow解决导出时的内存消耗问题

    2.EasyExcel的读，自己实现了DefaultHandler，对Excel文件包中xml数据文件进行流式解释，解决读时的内存消耗问题。

    by simple

  • 相关阅读:
    哈希表的实现
    php查询大量sql语句时内存溢出的解决方法
    Python并发编程之托管对象
    【设计模式】3种工厂模式
    ST表倒序释放：1019T1
    C高级作业 【使用shell脚本】 实现一个对数组求和的函数，数组通过实参传递给函数+写一个函数输出当前用户的uid和gid，并使用变量接收结果
    获取系统信息==Linux应用编程3
    ReentrantLock源码浅析
    【算法优选】双指针专题——贰
    使用 乐天 / V-IM 作为网页即时聊天
  • 原文地址：https://blog.csdn.net/vipshop_fin_dev/article/details/126697159