• POI 和 EasyExcel

    POI 和 EasyExcel

    常用信息

    1、将用户信息导出为 excel 表格（导出数据....）

    2、将 Excel 表中的信息录入到网站数据库（习题上传....）大大减轻网站录入量！

    开发中经常会设计到 excel 的处理，如导出 Excel，导入 Excel 到数据库中！

    操作 Excel 目前比较流行的就是 Apache POI 和阿里巴巴的 easyExcel！

    Apache POI

    Apache POI 官网：Apache POI - the Java API for Microsoft Documents

     easyExcel

    easyExcel官网地址：https://github.com/alibaba/easyexcel

    EasyExcel 是阿里巴巴开源的一个 excel 处理框架，以使用简单、节省内存著称。

    EasyExcel 能大大减少占用内存的主要原因是在解析 Excel 时没有将文件数据一次性全部加载到内存中，而是从磁盘上一行行读取数据，逐个解析。

    内存问题：POI = 100w 先加载到内存 OOM。。在写文件 es=1

    下图是 EasyExcel 和 POI 在解析 Excel时的对比图。

    官方文档：EasyExcel（文档已经迁移） · 语雀 

    POI-Excel写

    创建项目

    1、建立一个空项目，创建普通 Maven 的 Moudle kuang-poi

    2、引入 pom 依赖

    2. <dependencies>
    3.   
    4.   
    5.   <dependency>
    6.     <groupId>org.apache.poigroupId>
    7.     <artifactId>poiartifactId>
    8.     <version>3.9version>
    9.   dependency>
    10.  
    11.   
    12.   <dependency>
    13.     <groupId>org.apache.poigroupId>
    14.     <artifactId>poi-ooxmlartifactId>
    15.     <version>3.9version>
    16.   dependency>
    17.  
    18.   
    19.   <dependency>
    20.     <groupId>joda-timegroupId>
    21.     <artifactId>joda-timeartifactId>
    22.     <version>2.10.1version>
    23.   dependency>
    24.  
    25.   
    26.   <dependency>
    27.     <groupId>junitgroupId>
    28.     <artifactId>junitartifactId>
    29.     <version>4.12version>
    30.   dependency>
    31. dependencies>

    03|07 版本的写，就是对象不同，方法一样的！

    需要注意：2003 版本和 2007 版本存在兼容性的问题！03 最多只有 65535 行！

    1、工作簿： 2、工作表： 3、行： 4、列：

    03 版本：

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/zhang-poi";
    2.  
    3. @Test
    4. public void testWirate03() throws IOException {
    5.   // 1、创建一个工作簿    03
    6.   Workbook workbook = new HSSFWorkbook();
    7.   // 2、创建一个工作表
    8.   Sheet sheet = workbook.createSheet("狂神观众统计表");
    9.   // 3、创建一个行      0 代表第一行             （1,1）
    10.   Row row1 = sheet.createRow(0);
    11.   // 4、创建一个单元格    0 代表第一个单元格
    12.   Cell cell11 = row1.createCell(0);
    13.   // 去格子里边写入一个数据      第一行的第一列     （1,1）
    14.   cell11.setCellValue("今日新增观众");
    15.   // 5、创建第二个单元格    1 代表第二个单元格
    16.   Cell cell12 = row1.createCell(1);
    17.   // 去格子里边写入一个数据   第一行的第二列        （1,2）
    18.   cell12.setCellValue(666);
    19.  
    20.   // 第二行
    21.   Row row2 = sheet.createRow(1);
    22.   // 第二行的第一列      （2,1）
    23.   Cell cell21 = row2.createCell(0);
    24.   cell21.setCellValue("统计时间");
    25.   // 第二行的第二列      （2,2）
    26.   Cell cell22 = row2.createCell(1);
    27.   String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
    28.   cell22.setCellValue(time);
    29.  
    30.   // 生成一张表（IO 流）  03 版本就是使用 xls 结尾！
    31.   FileOutputStream fileOutputStream = new FileOutputStream(PATH + "狂神观众统计表03.xls");
    32.   // 输出
    33.   workbook.write(fileOutputStream);
    34.   // 关闭流
    35.   fileOutputStream.close();
    36.  
    37.   System.out.println("狂神观众统计表03 生成完毕！");
    38. }

    07 版本：

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/zhang-poi";
    2.  
    3. @Test
    4. public void testWirate07() throws IOException {
    5.   // 1、创建一个工作簿    07
    6.   Workbook workbook = new XSSFWorkbook();
    7.   // 2、创建一个工作表
    8.   Sheet sheet = workbook.createSheet("狂神观众统计表");
    9.   // 3、创建一个行      0 代表第一行             （1,1）
    10.   Row row1 = sheet.createRow(0);
    11.   // 4、创建一个单元格    0 代表第一个单元格
    12.   Cell cell11 = row1.createCell(0);
    13.   // 去格子里边写入一个数据      第一行的第一列     （1,1）
    14.   cell11.setCellValue("今日新增观众");
    15.   // 5、创建第二个单元格    1 代表第二个单元格
    16.   Cell cell12 = row1.createCell(1);
    17.   // 去格子里边写入一个数据   第一行的第二列        （1,2）
    18.   cell12.setCellValue(777);
    19.  
    20.   // 第二行
    21.   Row row2 = sheet.createRow(1);
    22.   // 第二行的第一列      （2,1）
    23.   Cell cell21 = row2.createCell(0);
    24.   cell21.setCellValue("统计时间");
    25.   // 第二行的第二列      （2,2）
    26.   Cell cell22 = row2.createCell(1);
    27.   String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
    28.   cell22.setCellValue(time);
    29.  
    30.   // 生成一张表（IO 流）  07 版本就是使用 xlsx 结尾！
    31.   FileOutputStream fileOutputStream = new FileOutputStream(PATH + "狂神观众统计表07.xlsx");
    32.   // 输出
    33.   workbook.write(fileOutputStream);
    34.   // 关闭流
    35.   fileOutputStream.close();
    36.  
    37.   System.out.println("狂神观众统计表07 生成完毕！");
    38.  
    39. }

    注意对象的一个区别，文件后缀

    大文件写 HSSF

    缺点：最多只能处理 65536 行，否则会抛出异常

    java.lang.IllegalArgumentException: Invalid row number (65536) outside allowable range (0..65535)

    优点：过程写入缓存，不操作磁盘，最后一次性写入磁盘，速度快

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/zhang-poi";
    2.  
    3. @Test
    4. public void testWirate03BigData() throws IOException {
    5.   // 获取当前时间
    6.   long begin = System.currentTimeMillis();
    7.  
    8.   // 创建工作簿
    9.   Workbook workook = new HSSFWorkbook();
    10.   // 创建工作表
    11.   Sheet sheet = workook.createSheet();
    12.   // 写入数据                超过 65536 行就会报错   java.lang.IllegalArgumentException: Invalid row number (65536) outside allowable range (0..65535)
    13.   for (int rowNum = 0; rowNum < 65536; rowNum++) {
    14.     // 创建行
    15.     Row row = sheet.createRow(rowNum);
    16.     for (int cellNum = 0; cellNum < 10; cellNum++) {
    17.       // 创建列
    18.       Cell cell = row.createCell(cellNum);
    19.       cell.setCellValue(cellNum);
    20.     }
    21.   }
    22.  
    23.   System.out.println("over");
    24.  
    25.   // 生成一张表（io 流）      03  版本就是使用  xls 结尾！
    26.   FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWirate03BigData.xls");
    27.   // 输出
    28.   workook.write(fileOutputStream);
    29.   // 关闭流
    30.   fileOutputStream.close();
    31.   long end = System.currentTimeMillis();
    32.   double time = (double) (end - begin) / 1000;
    33.   System.out.println("时间差为：" + time);
    34. }

    大文件写 XSSF

    缺点：写数据时速度非常慢，非常耗内存，也会发生内存溢出，如 100 万条

    优点：可以写较大的数据量，如 20 万条

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/zhang-poi";
    2.  
    3. // 耗时较长！    优化，缓存
    4. @Test
    5. public void testWirate07BigData() throws IOException {
    6.   // 获取当前时间
    7.   long begin = System.currentTimeMillis();
    8.  
    9.   // 创建工作簿
    10.   Workbook workook = new XSSFWorkbook();
    11.   // 创建工作表
    12.   Sheet sheet = workook.createSheet();
    13.   // 写入数据
    14.   for (int rowNum = 0; rowNum < 100000; rowNum++) {
    15.     // 创建行
    16.     Row row = sheet.createRow(rowNum);
    17.     for (int cellNum = 0; cellNum < 10; cellNum++) {
    18.       // 创建列
    19.       Cell cell = row.createCell(cellNum);
    20.       cell.setCellValue(cellNum);
    21.     }
    22.   }
    23.  
    24.   System.out.println("over");
    25.  
    26.   // 生成一张表（io 流）      07  版本就是使用  xlsx 结尾！
    27.   FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWirate07BigData2.xlsx");
    28.   // 输出
    29.   workook.write(fileOutputStream);
    30.   // 关闭流
    31.   fileOutputStream.close();
    32.   long end = System.currentTimeMillis();
    33.   double time = (double) (end - begin) / 1000;
    34.   System.out.println("时间差为：" + time);
    35. }

    大文件写 SXSSF

    优点：可以写非常大的数据量，如 100 万条甚至更多条，写数据速度更快，占用更少内存

    注意：

    过程中会产生临时文件，需要清理临时文件

    默认由 100 条记录被保存在内存中，如果超过这数量，则最前面的数据被写入临时文件

    如果想自定义内存中的数量，可以使用 new SXSSFWorkbook（数量）

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/zhang-poi";
    2.  
    3. @Test
    4. public void testWirate07BigDataS() throws IOException {
    5.   // 获取当前时间
    6.   long begin = System.currentTimeMillis();
    7.  
    8.   // 创建工作簿
    9.   Workbook workbook = new SXSSFWorkbook();
    10.   // 创建工作表
    11.   Sheet sheet = workbook.createSheet();
    12.   // 写入数据
    13.   for (int rowNum = 0; rowNum < 1000000; rowNum++) {
    14.     // 创建行
    15.     Row row = sheet.createRow(rowNum);
    16.     for (int cellNum = 0; cellNum < 10; cellNum++) {
    17.       // 创建列
    18.       Cell cell = row.createCell(cellNum);
    19.       cell.setCellValue(cellNum);
    20.     }
    21.   }
    22.  
    23.   System.out.println("over");
    24.  
    25.   // 生成一张表（io 流）      07  版本就是使用  xlsx 结尾！
    26.   FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWirate07BigDataS2.xlsx");
    27.   // 输出
    28.   workbook.write(fileOutputStream);
    29.   // 关闭流
    30.   fileOutputStream.close();
    31.   // 清除临时文件！
    32.   ((SXSSFWorkbook) workbook).dispose();
    33.   long end = System.currentTimeMillis();
    34.   double time = (double) (end - begin) / 1000;
    35.   System.out.println("时间差为：" + time);
    36. }
    37.

    SXSSFWorkbook 来自官方的解释：实现"BigGridDemo"策略的流式 XSSFWorkbook 版本。这允许写入非常大的文件而不会耗尽内存，因为任何时候只有可配置的行部分被保存在内存中。

    请注意：仍然可能会消耗大量内存，这些内存基于您正在使用的功能，例如合并区域，注释......仍然只存储在内存中，因此如果广泛使用，可能需要大量内存。

    再使用 POI 的时候！内存问题 Jprofile

    POI-Excel读

    03|07

    03 版本

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/";   //  zhang-poi
    2.  
    3. @Test
    4. public void testRead03() throws IOException {
    5.  
    6.   // 获取文件流
    7.   FileInputStream fileInputStream = new FileInputStream(PATH + "zhang-poi狂神观众统计表03.xls");
    8.   // 1、   创建一个工作簿   将文件流放到工作簿里        使用 excel 能操作的这边也都可以操作
    9.   Workbook workbook = new HSSFWorkbook(fileInputStream);
    10.   // 2、得到表    获取第 1 个表
    11.   Sheet sheetAt = workbook.getSheetAt(0);
    12.   // 3、得到行    获取第 1 行
    13.   Row row = sheetAt.getRow(0);
    14.   // 4、得到列    获取第一个单元格里边的数据
    15.   Cell cell = row.getCell(1);
    16.  
    17.   // 读取值的时候一定要注意类型，否则就会失败
    18.  
    19.   // 取出 cell 的值   getStringCellValue()  获取字符串类型
    20.   //        System.out.println("cell.getStringCellValue() = " + cell.getStringCellValue());
    21.   System.out.println("cell.getNumericCellValue() = " + cell.getNumericCellValue());
    22.   fileInputStream.close();
    23.  
    24. }

    07 版本

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/";   //  zhang-poi
    2.  
    3. @Test
    4. public void testRead07() throws IOException {
    5.  
    6.   // 获取文件流
    7.   FileInputStream fileInputStream = new FileInputStream(PATH + "zhang-poi狂神观众统计表07.xlsx");
    8.   // 1、   创建一个工作簿   将文件流放到工作簿里        使用 excel 能操作的这边也都可以操作
    9.   Workbook workbook = new XSSFWorkbook(fileInputStream);
    10.   // 2、得到表    获取第 1 个表
    11.   Sheet sheetAt = workbook.getSheetAt(0);
    12.   // 3、得到行    获取第 1 行
    13.   Row row = sheetAt.getRow(0);
    14.   // 4、得到列    获取第一个单元格里边的数据
    15.   Cell cell = row.getCell(1);
    16.  
    17.   // 读取值的时候一定要注意类型，否则就会失败
    18.  
    19.   // 取出 cell 的值   getStringCellValue()  获取字符串类型
    20.   //        System.out.println("cell.getStringCellValue() = " + cell.getStringCellValue());
    21.   System.out.println("cell.getNumericCellValue() = " + cell.getNumericCellValue());
    22.   fileInputStream.close();
    23.  
    24. }

    注意获取值得类型即可

    读不同的数据类型（最麻烦的就是这里）

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/";   //  zhang-poi
    2.  
    3. @Test
    4. public void testCellType() throws IOException {
    5.   // 获取文件流
    6.   FileInputStream fileInputStream = new FileInputStream(PATH + "明细表.xls");
    7.   // 1、   创建一个工作簿   将文件流放到工作簿里        使用 excel 能操作的这边也都可以操作
    8.   Workbook workbook = new HSSFWorkbook(fileInputStream);
    9.   // 2、得到表    获取第 1 个表
    10.   Sheet sheetAt = workbook.getSheetAt(0);
    11.   // 获取标题内容
    12.   Row rowTitle = sheetAt.getRow(0);
    13.   if (rowTitle != null) {
    14.     // 读取行的列 数量
    15.     int cellCount = rowTitle.getPhysicalNumberOfCells();
    16.     for (int cellNum = 0; cellNum < cellCount; cellNum++) {
    17.       // 获取单元格里边的数据   根据传入的第几列
    18.       Cell cell = rowTitle.getCell(cellNum);
    19.       if (cell != null) {
    20.         int cellType = cell.getCellType();
    21.  
    22.         // 根据单元格里边的数据类型，把具体的值给读取出来
    23.         String cellValue = cell.getStringCellValue();
    24.         System.out.print(cellValue + "|");
    25.       }
    26.     }
    27.     System.out.println();
    28.   }
    29.  
    30.   // 获取表中的内容      获取表中的所有行 ？
    31.   int rowCount = sheetAt.getPhysicalNumberOfRows();
    32.   for (int rowNum = 1; rowNum < rowCount; rowNum++) {
    33.     // 获取行里边的内容
    34.     Row rowData = sheetAt.getRow(rowNum);
    35.     if (rowData != null) {
    36.       // 读取行中的列
    37.       int cellCount = rowTitle.getPhysicalNumberOfCells();
    38.       for (int cellNum = 0; cellNum < cellCount; cellNum++) {
    39.         System.out.print("[" + (rowNum+1) + "-" +(cellNum+1) + "]");
    40.  
    41.         // 获取单元格里边的数据   根据每列
    42.         Cell cell = rowData.getCell(cellNum);
    43.         // 匹配列的数据类型
    44.         if (cell != null) {
    45.           int cellType = cell.getCellType();
    46.           String cellValue = "";
    47.           switch (cellType){
    48.             case Cell.CELL_TYPE_STRING:    // 字符串
    49.               System.out.print("【String】");
    50.               cellValue = cell.getStringCellValue();
    51.               break;
    52.  
    53.             case Cell.CELL_TYPE_BOOLEAN:    // 布尔类型
    54.               System.out.print("【Boolean】");
    55.               cellValue = String.valueOf(cell.getBooleanCellValue());
    56.               break;
    57.  
    58.             case Cell.CELL_TYPE_BLANK:    // 为空
    59.               System.out.print("【Blank】");
    60.               break;
    61.  
    62.             case Cell.CELL_TYPE_NUMERIC:    // 数字（日期、普通数字）类型
    63.               System.out.print("【Numeric】");
    64.               // 判断当前列是不是时间日期
    65.               if (HSSFDateUtil.isCellDateFormatted(cell)) {
    66.                 System.out.print("【日期】");
    67.                 Date date = cell.getDateCellValue();
    68.                 cellValue = new DateTime(date).toString("yyyy-MM-dd");
    69.               }else {
    70.                 // 不是日期格式，防止数字过长
    71.                 System.out.print("【转换为字符串输出】");
    72.                 cell.setCellType(Cell.CELL_TYPE_STRING);
    73.                 cellValue = cell.toString();
    74.               }
    75.               break;
    76.  
    77.             case Cell.CELL_TYPE_ERROR:    // 布尔类型
    78.               System.out.print("【数据类型错误】");
    79.               cellValue = String.valueOf(cell.getErrorCellValue());
    80.               break;
    81.  
    82.             case Cell.CELL_TYPE_FORMULA:  // 公式类型，代表这个cell存的是一个公式
    83.               System.out.print("【公式】");
    84.               // 6、获取计算公式
    85.               FormulaEvaluator formulaEvaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);
    86.               // 8、得到第 5 行第 1 列       计算公式的内容
    87.               String formula = cell.getCellFormula();
    88.               // formula = SUM(A2:A4)
    89.               System.out.println("formula = " + formula);
    90.  
    91.               // 9、计算得到值  把获取到第 5 行，第 1 列的内容放入到
    92.               CellValue evaluate = formulaEvaluator.evaluate(cell);
    93.               // 10、将的到的内容转化为字符串
    94.               cellValue = evaluate.formatAsString();
    95.               // cellValue = 600.0
    96.               // System.out.println("cellValue = " + cellValue);
    97.               break;
    98.           }
    99.           System.out.println(cellValue);
    100.         }
    101.       }
    102.     }
    103.   }
    104.   fileInputStream.close();
    105. }

    计算公式（了解即可）

    1. // 计算公式
    2. @Test
    3. public void testFormula() throws IOException {
    4.   // 1、获取文件流        通过文件路径 加 文件名
    5.   FileInputStream fileInputStream = new FileInputStream( PATH + "公式表.xls" );
    6.   // 2、创建一个工作簿，并把文件流放入工作簿当中
    7.   Workbook workbook = new HSSFWorkbook(fileInputStream);
    8.   // 3、得到表    获取第一个表
    9.   Sheet sheetAt = workbook.getSheetAt(0);
    10.  
    11.   // 4、获取到第 5 行的内容
    12.   Row row = sheetAt.getRow(4);
    13.   // 5、获取第 5 行，第 1 列的内容
    14.   Cell cell = row.getCell(0);
    15.  
    16.   // 6、获取计算公式
    17.   FormulaEvaluator formulaEvaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);
    18.   // 7、匹配列的数据类型   输出单元格的内容
    19.   int cellType = cell.getCellType();
    20.   switch (cellType){
    21.     case Cell.CELL_TYPE_FORMULA:    // 公式
    22.       // 8、得到第 5 行第 1 列       计算公式的内容
    23.       String formula = cell.getCellFormula();
    24.       // formula = SUM(A2:A4)
    25.       System.out.println("formula = " + formula);
    26.  
    27.       // 9、计算得到值  把获取到第 5 行，第 1 列的内容放入到
    28.       CellValue evaluate = formulaEvaluator.evaluate(cell);
    29.       // 10、将的到的内容转化为字符串
    30.       String cellValue = evaluate.formatAsString();
    31.       // cellValue = 600.0
    32.       System.out.println("cellValue = " + cellValue);
    33.       break;
    34.   }
    35.  
    36. }

    EasyExcel操作

    导入依赖

    2. <dependency>
    3.   <groupId>com.alibabagroupId>
    4.   <artifactId>easyexcelartifactId>
    5.   <version>3.1.1version>
    6. dependency>
    7.  
    8. <dependency>
    9.   <groupId>com.alibabagroupId>
    10.   <artifactId>fastjsonartifactId>
    11.   <version>1.2.79version>
    12. dependency>

    写入测试

    1、DemoData.java

    1. package com.zhang.easyexcelpojo;
    2.  
    3. import com.alibaba.excel.annotation.ExcelIgnore;
    4. import com.alibaba.excel.annotation.ExcelProperty;
    5. import lombok.Data;
    6.  
    7. import java.util.Date;
    8.  
    9. @Data
    10. public class DemoData {
    11.     @ExcelProperty("字符串标题")
    12.     private String string;
    13.     @ExcelProperty("日期标题")
    14.     private Date date;
    15.     @ExcelProperty("数字标题")
    16.     private Double doubleData;
    17.     /**
    18.      * 忽略这个字段
    19.      */
    20.     @ExcelIgnore
    21.     private String ignore;
    22. }
    23.

    2、测试写入数据：

    1. String PATH = "/Users/zhang/Desktop/gitee/excel/";
    2.  
    3. private List data() {
    4.   List list = new ArrayList();
    5.   for (int i = 0; i < 10; i++) {
    6.     DemoData data = new DemoData();
    7.     data.setString("字符串" + i);
    8.     data.setDate(new Date());
    9.     data.setDoubleData(0.56);
    10.     list.add(data);
    11.   }
    12.   return list;
    13. }
    14.  
    15. // 根据 list 写入 excel
    16. @Test
    17. public void simplewrite(){
    18.   String fileName = PATH + "EasyTest.xlsx";
    19.   //这里需要指定写用哪个 class去写，然后写到第一个 sheet，名字为模板然后文件流会自动关闭
    20.   // 如果这里想使用03 则 传入excelType参数即可
    21.   //write(fileName,格式类)
    22.   //sheet（表名）
    23.   //doWrite（数据）,真实的就是从数据库中读取的或前端传过来的
    24.   EasyExcel.write(fileName, DemoData.class).sheet("模板").doWrite(data());
    25. }

    3、最终的结果：

    读取测试

    测试读取：

    1、创建类 DemoDataListener 监听器：

    1. package com.zhang.easyexcelpojo;
    2.  
    3. import com.alibaba.excel.context.AnalysisContext;
    4. import com.alibaba.excel.event.AnalysisEventListener;
    5. import com.alibaba.fastjson.JSON;
    6. import org.slf4j.Logger;
    7. import org.slf4j.LoggerFactory;
    8.  
    9. import java.util.ArrayList;
    10. import java.util.List;
    11.  
    12. // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
    13. public class DemoDataListener extends AnalysisEventListener {
    14.  
    15.     private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    16.  
    17.     /**
    18.      * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
    19.      */
    20.  
    21.     private static final int BATCH_COUNT = 5;
    22.     List list = new ArrayList();
    23.  
    24.     private DemoDAO demoDAO;
    25.     public DemoDataListener() {
    26.         demoDAO = new DemoDAO();
    27.     }
    28.     public DemoDataListener(DemoDAO demoDAO) {
    29.         this.demoDAO = demoDAO;
    30.     }
    31.  
    32.     // 读取数据 会执行 invoke 方法    这个每一条数据解析都会来调用
    33.     // DemoData 类型
    34.     // AnalysisContext 分析上下文
    35.     @Override
    36.     public void invoke(DemoData data, AnalysisContext context) {
    37.         System.out.println(JSON.toJSONString(data));
    38.         list.add(data);
    39.         System.out.println(list);
    40.         // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
    41.         if (list.size() >= BATCH_COUNT) {
    42.             saveData();     //
    43.             // 存储完成清理 list
    44.             list.clear();
    45.         }
    46.     }
    47.  
    48.     // 所有数据解析完成了 都会来调用
    49.     @Override
    50.     public void doAfterAllAnalysed(AnalysisContext context) {
    51.         // 这里也要保存数据，确保最后遗留的数据也存储到数据库
    52.         saveData();
    53.         LOGGER.info("所有数据解析完成！");
    54.     }
    55.  
    56.     // 加上存储数据库
    57.     private void saveData() {
    58.         demoDAO.save(list);
    59.     }
    60. }

    具体操作：

    2、持久层DemoDAO:

    1. package com.zhang.easyexcelpojo;
    2.  
    3. import java.util.List;
    4.  
    5. /**
    6.  * 假设这个是你的DAO存储。当然还要这个类让spring管理，当然你不用需要存储，也不需要这个类。
    7.  **/
    8. public class DemoDAO {
    9.  
    10.     public void save(List list) {
    11.         // 持久化操作
    12.         // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    13.     }
    14.  
    15. }

     3、测试：

    1. // 最简单的读
    2. @Test
    3. public void simpleRead() {
    4.   String fileName = PATH + "EasyTest.xlsx";
    5.   // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
    6.   EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
    7. }

    4、结果： 

    固定套路：

    1、写入、固定类格式进行写入

    2、读取、根据监听器设置的规则进行读取！

    学习方式

    了解，面向对象的思想，学会面向接口编程！

    理解使用测试 API！

    可以把EasyExcel的所有 api 测试一下（2-3小时！）

  • 相关阅读:
    Java文件前后端上传下载工具类
    DEJA_VU3D - Cesium功能集 之 068-空间坐标系之箭头
    机器学习之梯度下降Gradient Descent(李宏毅机器学习)
    一款优秀的盲盒APP源码成品需要具备什么条件
    SpringBoot 的 MVC
    竞赛 基于深度学习的人脸表情识别
    ES6 Promise的使用详解
    MyBatis实现动态SQL更新
    Jenkins+Gitlab自动部署Vue项目到远程服务器
    为什么void CreateListR(LinkNode*&S,String a[],int n)这里有问题
  • 原文地址：https://blog.csdn.net/m0_57508774/article/details/126028848