本文包含以下内容，由于篇幅较长，可以根据需要选择阅读：
1. POI的介绍
2. 如何使用POI及POI的不足
3. 如何使用easyexcel

Apache POI是一套基于 OOXML 标准（Office Open XML）和 OLE2 标准来读写各种格式文件的 Java API，也就是说只要是遵循以上标准的文件，POI 都能够进行读写，而不仅仅只能操作我们熟知的办公程序文件。本文只会涉及到 excel 相关内容，其他文件的操作可以参考poi官方网站。

这里先总结下 POI 的使用体验。POI 面向接口的设计非常巧妙，使用 ss.usermodel 包读写 xls 和 xlsx 时，可以使用同一套代码，即使这两种文件格式采用的是完全不同的标准。POI 提供了SXSSFWorkbook用于解决 xlsx 写大文件时容易出现的 OOM 问题。但是，还是存在以下不足（都只针对读场景）：

  1. 使用 ss.usermodel 包解析 excel 效率较低、内存占用较大，且容易出现 OOM。类似于 xml 中的 DOM，这种方式会在内存中构建整个文档的结构，在处理大文件时容易出现 OOM。然而，大部分场景我们并不需要随机地去访问 excel 中的节点。
  2. POI 提供的 SAX 解析可以解决第一个问题，但是 API 太过复杂。为了解决第一个问题，POI 提供了基于事件驱动的 SAX 方式，这种方式内存占用小、效率高， 但是 API 太过繁琐，开发者必须在熟知文档规范的前提下才能使用，而且 xls 和 xlsx 使用的是完全不同的两套 API，实际项目中必须针对不同文件类型分别实现。这一点可以从本文的例子看出来。

针对以上问题，阿里的 easyexcel 对 POI 进行高级封装，提供了一套非常简便的 API，其中，读部分只封装了 SAX 部分 API，事实上，使用 easyexcel 读 excel 只会采用 SAX 方式，另外，easyexcel 重写了 POI 对 xlsx 的解析，能够原本一个3M的 excel 用 POI SAX 依然需要100M左右内存降低到几M，easyexcel 的内容本文也会涉及到。

OLE2 和 OOXML 本质上都是一种文件格式规范或标准，平时看到的 excel 中，有字体、公式、颜色、图片等等，看起来非常复杂，但是在文件结构上都遵循着固定的格式。

OLE2 文件一般包括 xls、doc、ppt 等，是二进制格式的文件。 相关内容可以参考：复合文档Ole对象二进制储存格式。

OOXML文件一般包括 xlsx、docx、pptx 等。该类文件以指定格式的 xml 为基础并以 zip 格式压缩，这里我利用解压工具解压本地的一个 xml 文件，可以看到以下文件结构，在本文例子中，我们会重点关注 sharedStrings.xml 和 sheet1.xml 的内容，因为使用 SAX API 时必须用到：

xlsx文件结构

针对不同应用的文件，使用时需要引入对应的 maven 依赖，这里给出官方给出的指引。如果我们不使用 SAX API 方式读写 excel，一般只会用到这个 org.apache.poi.ss 中的 API，具体的实现类放在 org.apache.poi.hssf 或 org.apache.poi.xssf 。

组件 作用 Maven依赖
POIFS OLE2 Filesystem poi
HPSF OLE2 Property Sets poi
HSSF Excel XLS poi
HSLF PowerPoint PPT poi-scratchpad
HWPF Word DOC poi-scratchpad
HDGF Visio VSD poi-scratchpad
HPBF Publisher PUB poi-scratchpad
HSMF Outlook MSG poi-scratchpad
DDF Escher common drawings poi
HWMF WMF drawings poi-scratchpad
OpenXML4J OOXML poi-ooxml plus either poi-ooxml-schemas or ooxml-schemas and ooxml-security
XSSF Excel XLSX poi-ooxml
XSLF PowerPoint PPTX poi-ooxml
XWPF Word DOCX poi-ooxml
XDGF Visio VSDX poi-ooxml
Common SL PowerPoint PPT 和 PPTX 共用组件 poi-scratchpad and poi-ooxml
Common SS Excel XLS 和 XLSX 共用组件 poi-ooxml

JDK：1.8.0_201

maven：3.6.1

IDE：Spring Tool Suite 4.3.2.RELEASE

POI：4.1.2

easyexcel：2.1.6

mysql：5.7.28

项目类型Maven Project，打包方式 jar。

  1.         <!-- junit -->
  2.         <dependency>
  3.             <groupId>junit</groupId>
  4.             <artifactId>junit</artifactId>
  5.             <version>4.12</version>
  6.             <scope>test</scope>
  7.         </dependency>
  8.         <!-- poi-ooxml -->
  9.         <dependency>
  10.             <groupId>org.apache.poi</groupId>
  11.             <artifactId>poi-ooxml</artifactId>
  12.             <version>4.1.2</version>
  13.         </dependency>
  14.         <!-- easyexcel -->
  15.         <dependency>
  16.             <groupId>com.alibaba</groupId>
  17.             <artifactId>easyexcel</artifactId>
  18.             <version>2.1.6</version>
  19.         </dependency>
  20.         <!-- hikari -->
  21.         <dependency>
  22.             <groupId>com.zaxxer</groupId>
  23.             <artifactId>HikariCP</artifactId>
  24.             <version>2.6.1</version>
  25.         </dependency>
  26.         <!-- mysql驱动 -->
  27.         <dependency>
  28.             <groupId>mysql</groupId>
  29.             <artifactId>mysql-connector-java</artifactId>
  30.             <version>8.0.15</version>
  31.         </dependency>

读取指定 excel 第一个单元格的内容。该指定文件第一个单元格内容为“测试”。

建议采用WorkbookFactory来获取Workbook实例，而不是根据文件类型写死具体的实现类。另外，获取单元格对象时建议采用 SheetUtil获取，里面会对行对象进行判空操作。

  1.     @Test
  2.     public void test01() throws IOException {
  3.         // 处理XSSF
  4.         String path = "extend\\file\\poi_test_01.xlsx";
  5.         // 处理HSSF
  6.         //String path = "extend\\file\\poi_test_01.xls";
  7.         
  8.         // 创建工作簿，会根据excel命名选择不同的Workbook实现类
  9.         Workbook wb = WorkbookFactory.create(new File(path));
  11.         // 获取工作表
  12.         Sheet sheet = wb.getSheetAt(0);
  14.         // 获取行
  15.         Row row = sheet.getRow(0);
  17.         // 获取单元格
  18.         Cell cell = row.getCell(0);
  19.         
  20.         // 也可以采用以下方式获取单元格
  21.         // Cell cell = SheetUtil.getCell(sheet, 0, 0);
  23.         // 获取单元格内容
  24.         String value = cell.getStringCellValue();
  25.         System.err.println("第一个单元格字符：" + value);
  27.         // 释放资源
  28.         wb.close();
  29.     }

运行以上方法，控制台打印出第一个单元格的内容：

ReadTest01

生成一个 excel 文件，并给第一个单元格赋值为”测试”，并设置列宽 26，行高 20.25，内容居中，下框线，单元格橙色填充。

CellUtil是 POI 自带的工具类，这里简化了三句代码（创建单元格，设置样式，赋值）。注意，当写入 xlsx 的大文件时，可以考虑使用SXSSFWorkbook来避免 OOM。

  1.     @Test
  2.     public void test01() throws FileNotFoundException, IOException {
  3.         // 处理XSSF
  4.         String path = "extend\\file\\poi_test_01.xlsx";
  5.         // 处理HSSF
  6.         // String path = "extend\\file\\poi_test_01.xls";
  8.         // 创建工作簿
  9.         boolean flag = path.endsWith(".xlsx");
  10.         Workbook wb = WorkbookFactory.create(flag ? true : false);
  11.         // Workbook wb = new SXSSFWorkbook(100);//内存仅保留100行数据，可避免OOM
  13.         // 创建工作表
  14.         Sheet sheet = wb.createSheet(WorkbookUtil.createSafeSheetName("MySheet001"));
  15.         // 设置列宽
  16.         sheet.setColumnWidth(0, 26 * 256);
  18.         // 创建行(索引从0开始)
  19.         Row row = sheet.createRow(0);
  20.         // 设置行高
  21.         row.setHeightInPoints(20.25f);
  23.         // 创建单元格样式对象
  24.         CellStyle style = wb.createCellStyle();
  25.         // 设置样式
  26.         style.setAlignment(HorizontalAlignment.CENTER); // 横向居中
  27.         style.setVerticalAlignment(VerticalAlignment.CENTER);// 纵向居中
  28.         style.setBorderBottom(BorderStyle.THIN);
  29.         style.setFillForegroundColor(IndexedColors.ORANGE.getIndex());
  30.         style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
  32.         // 创建单元格、设置样式和内容
  33.         CellUtil.createCell(row, 0, "测试", style);
  35.         // 保存到本地目录
  36.         OutputStream out = new FileOutputStream(new File(path));
  37.         wb.write(out);
  39.         // 释放资源
  40.         out.close();
  41.         wb.close();
  42.     }

运行以上方法，指定路径下生成了 excel 文件，并填充了第一个单元格：

WriteTest01

将 excel 中的用户数据导入到数据库（sql 已提供，在当前项目的 extend/sql 下），数据格式如下：

ReadTest02

该文件总计1000条数据，xls 大小 128 KB，xlsx 大小 40 KB，两种类型文件内容一致。

一般 excel 的内容格式是提前约定好的，我们知道用户数据哪一列是用户名，哪一列是电话号码，所以，在获取单元格数据后可以准确地转换，但这种方式需要针对不同的对象分别定义一个转换方法。

  1.     @Test
  2.     public void test02() throws SQLException, IOException {
  3.         // 处理XSSF
  4.         String path = "extend\\file\\user_data.xlsx";
  5.         // 处理HSSF
  6.         //String path = "extend\\file\\user_data.xls";
  7.         
  8.         // 定义集合，用于存放excel中的用户数据
  9.         List<UserDTO> list = new ArrayList<>();
  11.         InputStream in = new FileInputStream(path);
  12.         // 创建工作簿
  13.         Workbook wb = WorkbookFactory.create(in);
  15.         // 获取工作表
  16.         Sheet sheet = wb.getSheetAt(0);
  18.         // 获取所有行
  19.         Iterator<Row> iterator = sheet.iterator();
  21.         int rowNum = 0;
  22.         // 遍历行
  23.         while(iterator.hasNext()) {
  24.             Row row = iterator.next();
  25.             // 跳过标题行
  26.             if(rowNum == 0 || rowNum == 1) {
  27.                 rowNum++;
  28.                 continue;
  29.             }
  30.             // 将用户对象保存到集合中
  31.             list.add(constructUserByRow(row));
  32.         }
  33.         // 批量保存
  34.         new UserService().save(list);
  36.         // 释放资源
  37.         in.close();
  38.         wb.close();
  39.     }
  40.     /**
  41.      * <p>通过行数据构造用户对象</p>
  42.      */
  43.     private UserDTO constructUserByRow(Row row) {
  44.         UserDTO userDTO = new UserDTO();
  45.         Cell cell = null;
  46.         // 用户名
  47.         cell = row.getCell(1);
  48.         userDTO.setName(cell.getStringCellValue());
  49.         // 性别
  50.         cell = row.getCell(2);
  51.         userDTO.setGenderStr(cell.getStringCellValue());
  52.         // 年龄
  53.         cell = row.getCell(3);
  54.         userDTO.setAge(((Double)cell.getNumericCellValue()).intValue());
  55.         // 电话
  56.         cell = row.getCell(4);
  57.         userDTO.setPhone(cell.getStringCellValue());
  59.         return userDTO;
  60.     }

运行以上方法，可以在数据库看到导入的数据：

ReadTest03

将数据库的用户数据导出到excel中。这个例子使用模板进行导出，模板如下（如果是 xlsx 的大文件，为了能够使用SXSSFWorkbook最好不要用模板）。

WriteTest02

写入的时候使用样式还是比较繁琐，实际开发能不使用尽量不要用，或者也可以单独封装成一个方法。注意，构造Workbook时不要使用WorkbookFactory.create(file)方式，否则，模板也会被修改。

  1.     @Test
  2.     public void test02() throws SQLException, IOException {
  3.         // 处理XSSF
  4.         String templatePath = "extend\\file\\user_data_template.xlsx";
  5.         String outpath = "extend\\file\\user_data.xlsx";
  7.         // 处理HSSF
  8.         // String templatePath = "extend\\file\\user_data_template.xls";
  9.         // String path = "extend\\file\\user_data.xls";
  11.         InputStream in = new FileInputStream(templatePath);
  13.         // 创建工作簿，注意，这里如果传入File对象，模板也会被改写
  14.         Workbook wb = WorkbookFactory.create(in);
  16.         // 读取工作表
  17.         Sheet sheet = wb.getSheetAt(0);
  19.         // 定义复用变量
  20.         int rowIndex = 0; // 行的索引
  21.         int cellIndex = 1; // 单元格的索引
  22.         Row nRow = null;
  23.         Cell nCell = null;
  25.         // 读取大标题行
  26.         nRow = sheet.getRow(rowIndex++); // 使用后 +1
  27.         // 读取大标题的单元格
  28.         nCell = nRow.getCell(cellIndex);
  29.         // 设置大标题的内容
  30.         nCell.setCellValue("2020年2月用户表");
  32.         // 跳过第二行(模板的小标题)
  33.         rowIndex++;
  35.         // 读取第三行,获取它的样式
  36.         nRow = sheet.getRow(rowIndex);
  37.         // 读取行高
  38.         float lineHeight = nRow.getHeightInPoints();
  39.         // 获取第三行的4个单元格中的样式
  40.         CellStyle cs1 = nRow.getCell(cellIndex++).getCellStyle();
  41.         CellStyle cs2 = nRow.getCell(cellIndex++).getCellStyle();
  42.         CellStyle cs3 = nRow.getCell(cellIndex++).getCellStyle();
  43.         CellStyle cs4 = nRow.getCell(cellIndex++).getCellStyle();
  45.         // 查询用户列表
  46.         List<UserDTO> userList = new UserService().findAll().stream().map((x) -> new UserDTO(x)).collect(Collectors.toList());
  47.         // 遍历数据
  48.         for(UserDTO user : userList) {
  49.             // 创建数据行
  50.             nRow = sheet.createRow(rowIndex++);
  51.             // 设置数据行高
  52.             nRow.setHeightInPoints(lineHeight);
  53.             // 重置cellIndex,从第一列开始写数据
  54.             cellIndex = 1;
  56.             // 创建数据单元格，设置单元格内容和样式
  57.             // 用户名
  58.             nCell = nRow.createCell(cellIndex++);
  59.             nCell.setCellStyle(cs1);
  60.             nCell.setCellValue(user.getName());
  61.             // 性别
  62.             nCell = nRow.createCell(cellIndex++);
  63.             nCell.setCellStyle(cs2);
  64.             nCell.setCellValue(user.getGenderStr());
  65.             // 年龄
  66.             nCell = nRow.createCell(cellIndex++);
  67.             nCell.setCellStyle(cs3);
  68.             nCell.setCellValue(user.getAge());
  69.             // 手机号
  70.             nCell = nRow.createCell(cellIndex++);
  71.             nCell.setCellStyle(cs4);
  72.             nCell.setCellValue(user.getPhone());
  73.         }
  75.         // 保存到本地目录
  76.         OutputStream out = new FileOutputStream(new File(outpath));
  77.         wb.write(out);
  79.         // 释放资源
  80.         out.close();
  81.         wb.close();
  82.     }

运行以上方法，在指定文件夹可以看到生成的文件：

WriteTest03

使用 SAX 的方式将 xls 中的用户数据导入到数据库，数据与以上例子一样。

相比前面的例子，使用 SAX 方式内存占用小，效率高，但是 POI 提供的这套 API 用起来非常繁琐，使用时不得不必须去了解 xls 文件的结构。我这里只是简单展示，监听器部分的代码不太严谨，实际项目还是用 easyexcel 来操作吧。

  1.     @Test
  2.     public void test02() throws Exception {
  3.         // 创建POIFSFileSystem
  4.         String filename = "extend\\file\\user_data.xls";
  5.         POIFSFileSystem poifs = new POIFSFileSystem(new File(filename));
  7.         // 创建HSSFRequest，并添加自定义监听器
  8.         HSSFRequest req = new HSSFRequest();
  9.         EventExample listener = new EventExample();
  10.         req.addListenerForAllRecords(listener);
  12.         // 解析和触发事件
  13.         HSSFEventFactory factory = new HSSFEventFactory();
  14.         factory.processWorkbookEvents(req, poifs);
  15.         
  16.         // 保存用户到数据库
  17.         new UserService().save(listener.getList());
  18.         
  19.         poifs.close();
  20.     }
  22.     private static class EventExample implements HSSFListener {
  24.         private SSTRecord sstrec;
  26.         private int lastCellRow = -1;
  28.         private int lastCellColumn = -1;
  30.         private List<UserDTO> list = new ArrayList<UserDTO>();
  32.         private UserDTO user;
  34.         @Override
  35.         public void processRecord(Record record) {
  36.             switch(record.getSid()) {
  38.             // 进入新的sheet
  39.             case BoundSheetRecord.sid:
  40.                 lastCellRow = -1;
  41.                 lastCellColumn = -1;
  42.                 break;
  43.             
  44.             // excel中的数值类型和字符存放在不同的位置
  45.             case NumberRecord.sid:
  46.                 NumberRecord numrec = (NumberRecord)record;
  47.                 // 用户年龄
  48.                 user.setAge(Double.valueOf(numrec.getValue()).intValue());
  49.                 lastCellRow = numrec.getRow();
  50.                 lastCellColumn = numrec.getColumn();
  51.                 break;
  53.             // SSTRecords中存储着excel中使用的字符，重复的会合并为一个
  54.             case SSTRecord.sid:
  55.                 sstrec = (SSTRecord)record;
  56.                 break;
  58.             // 读取到单元格的字符
  59.             case LabelSSTRecord.sid:
  60.                 LabelSSTRecord lrec = (LabelSSTRecord)record;
  61.                 int thisRow = lrec.getRow();
  62.                 // 用户数据从第三行开始
  63.                 if(thisRow >= 2) {
  64.                     // 进入新行时，原对象放入集合，并创建新对象
  65.                     if(thisRow != lastCellRow) {
  66.                         if(user != null) {
  67.                             list.add(user);
  68.                         }
  69.                         user = new UserDTO();
  70.                     }
  71.                     // 根据列数为用户对象设置属性
  72.                     switch(lrec.getColumn()) {
  73.                     case 1:
  74.                         // 用户名
  75.                         user.setName(sstrec.getString(lrec.getSSTIndex()).getString());
  76.                         break;
  77.                     case 2:
  78.                         // 用户性别
  79.                         user.setGenderStr(sstrec.getString(lrec.getSSTIndex()).getString());
  80.                         break;
  81.                     case 4:
  82.                         // 用户电话
  83.                         user.setPhone(sstrec.getString(lrec.getSSTIndex()).getString());
  84.                         break;
  85.                     default:
  86.                         break;
  87.                     }
  88.                     lastCellRow = thisRow;
  89.                     lastCellColumn = lrec.getColumn();
  90.                 }
  91.                 break;
  92.             case EOFRecord.sid:
  93.                 // 最后一行读取完后直接放入集合
  94.                 if(lastCellRow != -1 && user != null && lastCellColumn == 4) {
  95.                     list.add(user);
  96.                 }
  97.                 break;
  98.             default:
  99.                 break;
  100.             }
  101.         }
  103.         public List<UserDTO> getList() {
  104.             return list;
  105.         }
  106.     }

运行以上方法，可以在数据库看到导入的数据：

ReadTest03

使用 SAX 的方式将 xlsx 中的用户数据导入到数据库，数据与以上例子一样。

POI 针对 xlsx 的 SAX API 也是非常繁琐，属于非常低级的封装，这里竟然需要使用 JDK 原生的 SAX 解析来处理事件，定义事件处理器时，我必须去了解 xml 的节点结构。和上面例子一样，这里也只是简单地演示这套 API 的使用，具体代码不太严谨，当然，实际开发我们不会采用这种方式，建议还是使用 easyexcel 吧。

  1.     @Test
  2.     public void test01() throws Exception {
  4.         String filename = "extend\\file\\user_data.xlsx";
  5.         OPCPackage pkg = OPCPackage.open(filename);
  6.         XSSFReader r = new XSSFReader(pkg);
  8.         // 获取sharedStrings.xml的内容，这里存放着excel中的字符
  9.         SharedStringsTable sst = r.getSharedStringsTable();
  11.         // 接下来就是采用SAX方式解析xml的过程
  12.         // 构造解析器，这里会设置自定义的处理器
  13.         XMLReader parser = XMLHelper.newXMLReader();
  14.         SheetHandler handler = new SheetHandler(sst);
  15.         parser.setContentHandler(handler);
  17.         // 解析指定的sheet
  18.         InputStream sheet2 = r.getSheet("rId1");
  19.         parser.parse(new InputSource(sheet2));
  21.         // 保存用户到数据库
  22.         new UserService().save(handler.getList());
  23.         // handler.getList().forEach(System.err::println);
  25.         sheet2.close();
  26.     }
  28.     private static class SheetHandler extends DefaultHandler {
  30.         private SharedStringsTable sst;
  32.         private String cellContents;
  34.         private boolean cellContentsIsString;
  36.         private int cellColumn = -1;
  38.         private int cellRow = -1;
  40.         List<UserDTO> list = new ArrayList<>();
  42.         UserDTO user;
  44.         private SheetHandler(SharedStringsTable sst) {
  45.             this.sst = sst;
  46.         }
  48.         @Override
  49.         public void startElement(String uri, String localName, String name, Attributes attributes) throws SAXException {
  50.             // 读取到行
  51.             if("row".equals(name)) {
  52.                 cellRow++;
  53.                 if(cellRow >= 2) {
  54.                     // 换行时重新创建用户实例
  55.                     user = new UserDTO();
  56.                 }
  57.             }
  58.             // 读取到列 c => cell
  59.             if("c".equals(name) && cellRow >= 2) {
  60.                 // 设置当前读取到哪一列
  61.                 char columnChar = attributes.getValue("r").charAt(0);
  62.                 switch(columnChar) {
  63.                 case 'B':
  64.                     cellColumn = 1;
  65.                     break;
  66.                 case 'C':
  67.                     cellColumn = 2;
  68.                     break;
  69.                 case 'D':
  70.                     cellColumn = 3;
  71.                     break;
  72.                 case 'E':
  73.                     cellColumn = 4;
  74.                     break;
  75.                 default:
  76.                     cellColumn = -1;
  77.                     break;
  78.                 }
  79.                 // 当前单元格中的值是否为字符，是的话对应的值被放在SharedStringsTable中
  80.                 if("s".equals(attributes.getValue("t"))) {
  81.                     cellContentsIsString = true;
  82.                 }
  83.             }
  84.             // Clear contents cache
  85.             cellContents = "";
  86.         }
  88.         @Override
  89.         public void endElement(String uri, String localName, String name) throws SAXException {
  90.             // 跳过标题
  91.             if(cellRow < 2) {
  92.                 return;
  93.             }
  94.             // v节点是c的子节点，表示单元格的值
  95.             if(name.equals("v")) {
  96.                 int idx;
  97.                 if(cellContentsIsString) {
  98.                     idx = Integer.parseInt(cellContents);
  99.                 } else {
  100.                     idx = Double.valueOf(cellContents).intValue();
  101.                 }
  102.                 switch(cellColumn) {
  103.                 case 1:
  104.                     user.setName(sst.getItemAt(idx).getString());
  105.                     break;
  106.                 case 2:
  107.                     user.setGenderStr(sst.getItemAt(idx).getString());
  108.                     break;
  109.                 case 3:
  110.                     // 年龄的值是数值类型，不在SharedStringsTable中
  111.                     user.setAge(idx);
  112.                     break;
  113.                 case 4:
  114.                     user.setPhone(sst.getItemAt(idx).getString());
  115.                     break;
  116.                 default:
  117.                     break;
  118.                 }
  119.             }
  120.             
  121.             // 读取完一行，将用户对象放入集合中
  122.             if("row".equals(name) && user != null) {
  123.                 list.add(user);
  124.             }
  125.             
  126.             // 重置参数
  127.             if("c".equals(name)) {
  128.                 cellColumn = -1;
  129.                 cellContentsIsString = false;
  130.             }
  132.         }
  134.         @Override
  135.         public void characters(char[] ch, int start, int length) {
  136.             cellContents += new String(ch, start, length);
  137.         }
  139.         public List<UserDTO> getList() {
  140.             return list;
  141.         }
  142.     }

运行以上方法，可以在数据库看到导入的数据：

ReadTest03

通过以上例子，我们会发现，POI SAX 方式的 API 确实非常繁琐，使用时我必须熟悉地掌握 OLE2 或 OOXML 的规范，才能够使用。这是比较低层级的封装。相比之下，ss.usermodel 的 API 要好用很多，但是这套 API 底层解析 方式有点类似 DOM，效率较低，且内存占用较大。

前面已经讲过，easyexcel 对 POI 进行了高级封装，极大地方便了我们读写 excel，而且只会采用 SAX 这种更快的方式来读取，下面补充下如何使用 easyexcel 读写 excel。

使用 easyexcel 读写 excel 时，我们不需要自己写 row => entity 或者 entity => row 的方法，只要按照以下注解好就行。被@ExcelProperty注解的属性对应 row 中的具体内容，而被@ExcelIgnore注解表示不需要与 row 进行转换。

  1. @ContentRowHeight(16)
  2. public class UserDTO implements Serializable {
  4.     private static final long serialVersionUID = 1L;
  5.     
  6.     @ExcelIgnore
  7.     private String id;
  9.     /**
  10.      * <p>用户名</p>
  11.      */
  12.     @ExcelProperty(value = { "用户名" }, index = 1)
  13.     private String name;
  15.     /**
  16.      * <p>性别</p>
  17.      */
  18.     @ExcelProperty(value = { "性别" }, index = 2)
  19.     private String genderStr;
  21.     /**
  22.      * <p>年龄</p>
  23.      */
  24.     @ExcelProperty(value = { "年龄" }, index = 3)
  25.     private Integer age;
  27.     /**
  28.      * <p>电话号码</p>
  29.      */
  30.     @ExcelProperty(value = { "手机号" }, index = 4)
  31.     @ColumnWidth(14)
  32.     private String phone;
  33.     
  34.     @ExcelIgnore
  35.     private Integer gender = 0;
  36.     
  37.     // 以下省略setter/getter方法
  38. }

easyexcel 封装或重写了 POI SAX 部分的 API，所以也是需要设置回调的监听器，以下方式会采用默认的监听器，并返回封装好的对象。

  1.     @Test
  2.     public void test02() throws SQLException, IOException {
  3.         // XSSF
  4.         String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xlsx";
  5.         // HSSF
  6.         // String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xls";
  8.         // 读取excel
  9.         List<UserDTO> list = EasyExcel.read(path).head(UserDTO.class).sheet(0).headRowNumber(2).doReadSync();
  10.         // 保存
  11.         new UserService().save(list);
  12.     }

当然，我们也可以采用自定义的监听器，如下：

  1.     @Test
  2.     public void test01() throws SQLException, IOException {
  3.         // XSSF
  4.         String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xlsx";
  5.         
  6.         // HSSF
  7.         // String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xls";
  9.         List<UserDTO> list = new ArrayList<UserDTO>();
  10.         
  11.         // 定义回调监听器
  12.         ReadListener<UserDTO> syncReadListener = new AnalysisEventListener<UserDTO>() {
  13.             @Override
  14.             public void invoke(UserDTO data, AnalysisContext context) {
  15.                 list.add(data);
  16.             }
  18.             @Override
  19.             public void doAfterAllAnalysed(AnalysisContext context) {
  20.                 // TODO Auto-generated method stub
  21.             }
  22.         };
  23.         // 读取excel
  24.         EasyExcel.read(path, UserDTO.class, syncReadListener).sheet(0).headRowNumber(2).doRead();
  25.         // 保存
  26.         new UserService().save(list);
  27.     }

和读一样，这里也只用了一行代码就完成了对 excel 的操作。

  1.     @Test
  2.     public void test01() throws SQLException, IOException {
  3.         // XSSF
  4.         String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xlsx";
  6.         // HSSF
  7.         // String path = "D:\\growUp\\git_repository\\09-poi-demo\\extend\\file\\user_data.xls";
  9.         // 获取用户数据
  10.         List<UserDTO> list = new UserService().findAll().stream().map((x) -> new UserDTO(x)).collect(Collectors.toList());
  11.         // 写入excel
  12.         EasyExcel.write(path, UserDTO.class).sheet(0).relativeHeadRowIndex(1).doWrite(list);
  13.     }

Apache POI – the Java API for Microsoft Documents

本文为原创文章，转载请附上原文出处链接：https://github.com/ZhangZiSheng001/01-spi-demo

版权声明：本文为ZhangZiSheng001原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/ZhangZiSheng001/p/12532074.html