Excel导入导出POI和EasyExcel两种工具的使用方法

POI和easyExcel

组件工具实现excel提高开发效率

简介

常用场景

• 将用户信息导出为excel表格(导出数据)
• 将Excel表中的信息录入到网站数据库(习题上传) 大大减轻网站录入量，节省工作时间！
• 开发经常会设计到excel的处理，如导出Excel，导入Excel到数据库中！
• 操作Excel目前比较流行的就是Apache POI和阿里巴巴的easyExcel

---

Apache POI

ApachePOI官网：https://poi.apache.org/

EasyExcel

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

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

内存问题：POI=100W数据先加载到内存，然后再写入文件，如果内存不够，这个就会有OOM问题。

easyExcel是一行行读取

官方文档：https://www.yuque.com/easyexcel/doc/easyexcel

1、POI-Excel使用

POI-Excel写

创建项目

1. 建立一个空项目Excel，创建普通的Maven的Moudle can-poi

1. 引入pom依赖

 
        <dependency>
            <groupId>org.apache.poigroupId>
            <artifactId>poiartifactId>
            <version>3.9version>
        dependency>
        
        <dependency>
            <groupId>org.apache.poigroupId>
            <artifactId>poi-ooxmlartifactId>
            <version>3.9version>
        dependency>
        
        <dependency>
            <groupId>joda-timegroupId>
            <artifactId>joda-timeartifactId>
            <version>2.10.5version>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>

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

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

1、工作簿：Workbook workbook = new HSSFWorkbook();

2、工作表：Sheet sheet = workbook.createSheet(“CanPOI练习表03”);

3、行：Row row_1 = sheet.createRow(0); //0代表第一行

4、列：Cell cell_1_1 = row_1.createCell(0);//0代表第一列

03和07版本可以通过 另存为 来改变类型

xls是03版 xlsx是07版

03版本

package com.can;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * HSSF 03版
 * XSSF 07版
 * SXSS 07版升级
 */
public class ExcelWriteTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";

    /**
     * 03版本
     */
    @Test
    public void testWrite03(){
        //1、创建一个工作簿
        Workbook workbook = new HSSFWorkbook();
        //2、创建一个工作表
        Sheet sheet = workbook.createSheet("CanPOI练习表03");
        //3、创建一个行  (1,1)
        Row row_1 = sheet.createRow(0); //0代表第一行
        //4、创建一个单元格
        Cell cell_1_1 = row_1.createCell(0);//0代表第一列
        cell_1_1.setCellValue("大家加油呀"); //第一行第一列插入数据
        Cell cell_1_2 = row_1.createCell(1);//1代表第二列
        cell_1_2.setCellValue(666);//第一行的第二列插入数据

        //第二行
        Row row_2 = sheet.createRow(1); //创建第二行
        //(2,1)
        Cell cell_2_1 = row_2.createCell(0); //创建第二行第一列
        cell_2_1.setCellValue("第二行第一列");
        Cell cell_2_2 = row_2.createCell(1); //第二行第二列
        String date = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell_2_2.setCellValue(date);

        //生产一张表(IO流)
        //03版本就是使用 xls结尾！
        try(FileOutputStream fileOutputStream = new FileOutputStream(PATH + "CanPOI练习表03版本.xls");) {
            //输出
            workbook.write(fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("CanPOI练习表03版本.xls 生产完毕！");
    }

07版本

package com.can;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * HSSF 03版
 * XSSF 07版
 * SXSS 07版升级
 */
public class ExcelWriteTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";

    /**
     * 07版本
     */
    @Test
    public void testWrite07(){
        //1、创建一个工作簿 07
        Workbook workbook = new XSSFWorkbook();
        //2、创建一个工作表
        Sheet sheet = workbook.createSheet("CanPOI练习表07");
        //3、创建一个行  (1,1)
        Row row_1 = sheet.createRow(0); //0代表第一行
        //4、创建一个单元格
        Cell cell_1_1 = row_1.createCell(0);//0代表第一列
        cell_1_1.setCellValue("大家加油呀"); //第一行第一列插入数据
        Cell cell_1_2 = row_1.createCell(1);//1代表第二列
        cell_1_2.setCellValue(666);//第一行的第二列插入数据

        //第二行
        Row row_2 = sheet.createRow(1); //创建第二行
        //(2,1)
        Cell cell_2_1 = row_2.createCell(0); //创建第二行第一列
        cell_2_1.setCellValue("第二行第一列");
        Cell cell_2_2 = row_2.createCell(1); //第二行第二列
        String date = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell_2_2.setCellValue(date);

        //生产一张表(IO流)
        //07版本就是使用 xlsx结尾！
        try(FileOutputStream fileOutputStream = new FileOutputStream(PATH + "CanPOI练习表07版本.xlsx");) {
            //输出
            workbook.write(fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("CanPOI练习表03版本.xlsx 生产完毕！");
    }
}

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

---

数据批量导入！

大文件写HSSF(03版)

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

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

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

/**
     * 03版本 大数据量
     */
    @Test
    public void HSSFWrite03BigData(){
        //开始时间
        long begin = System.currentTimeMillis();

        //创建一个工作簿
        Workbook workbook = new HSSFWorkbook();
        //创建表
        Sheet sheet = workbook.createSheet("HSSF 03版大数据量");
        //写入数据
        for (int rowNum = 0; rowNum < 65536; rowNum++) { //超过65536 会有异常 java.lang.IllegalArgumentException: Invalid row number (65536) outside allowable range (0..65535)
            Row row = sheet.createRow(rowNum);
            for (int cellNum = 0; cellNum < 10; cellNum++) {
                Cell cell = row.createCell(cellNum);
                cell.setCellValue(cellNum);
            }
        }

        System.out.println("over");

        //1.7新特性 自动关闭流 try(流)
        try(FileOutputStream fileOutputStream = new FileOutputStream(PATH + "HSSF-03版大数据量.xls");
        ) {
            workbook.write(fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //结束时间
        long end = System.currentTimeMillis();
        System.out.println( (double) (end-begin)/1000); //1.922
    }

大文件写XSSF(07版)

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

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

/**
     * 07版本 大数据量
     * 耗时较长！优化，缓存
     */
    @Test
    public void XSSFWrite07BigData(){
        //开始时间
        long begin = System.currentTimeMillis();

        //创建一个工作簿
        Workbook workbook = new XSSFWorkbook();
        //创建表
        Sheet sheet = workbook.createSheet("XSSF 07版大数据量");
        //写入数据
        for (int rowNum = 0; rowNum < 65537; rowNum++) { //07版本 没有 65536行限制
            Row row = sheet.createRow(rowNum);
            for (int cellNum = 0; cellNum < 10; cellNum++) {
                Cell cell = row.createCell(cellNum);
                cell.setCellValue(cellNum);
            }
        }

        System.out.println("over");

        //1.7新特性 自动关闭流 try(流)
        try(FileOutputStream fileOutputStream = new FileOutputStream(PATH + "XSSF-07版大数据量.xlsx");
        ) {
            workbook.write(fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //结束时间
        long end = System.currentTimeMillis();
        //耗时较长
        System.out.println( (double) (end-begin)/1000); //8.305
    }

大写文件SXSSF(07版升级版)

优点：

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

注意：

• 过程中会产生临时文件，需要清理临时文件
• 默认由100条记录被保存在内存中，如果超过这数量，则最前面的数据被写入临时文件
• 如果想自定义内存中的数据的数量，可以使用new SXSSFWrokbook(数量)

/**
     * 07 升级版本 大数据量
     */
    @Test
    public void SXSSFWrite07BigData(){
        //开始时间
        long begin = System.currentTimeMillis();

        //创建一个工作簿
        Workbook workbook = new SXSSFWorkbook();
        //创建表
        Sheet sheet = workbook.createSheet("XSSF 07版大数据量");
        //写入数据
        for (int rowNum = 0; rowNum < 65537; rowNum++) { //07版本 没有 65536行限制
            Row row = sheet.createRow(rowNum);
            for (int cellNum = 0; cellNum < 10; cellNum++) {
                Cell cell = row.createCell(cellNum);
                cell.setCellValue(cellNum);
            }
        }

        System.out.println("over");

        //1.7新特性 自动关闭流 try(流)
        try(FileOutputStream fileOutputStream = new FileOutputStream(PATH + "SXSSF-07版大数据量.xlsx");
        ) {
            workbook.write(fileOutputStream);

            //清除临时文件！
            ((SXSSFWorkbook) workbook).dispose();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //结束时间
        long end = System.currentTimeMillis();
        //耗时较长
        System.out.println( (double) (end-begin)/1000); //2.592
    }

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

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

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

---

POI-Excel读

03版本

package com.can;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.IOException;

public class ExcelReadTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";

    /**
     * 03版本
     */
    @Test
    public void HSSFRead03() throws IOException {
        //1、获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "CanPOI练习表03版本.xls");
        //2、创建一个工作簿。使用excel能操作的这边都可以操作
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        //3、得到表
        Sheet sheetAt = workbook.getSheetAt(0); // 下标获取第1个工作表
        //4、得到行
        Row row = sheetAt.getRow(0); //拿到第1行
        //5、得到列
        Cell cell = row.getCell(1);//拿到第一列
        //6、得到第一行第一列的数据
        //读取值得时候，一定需要注意类型！
        //getStringCellValue获取字符串类型
//        String CellValue = cell.getStringCellValue();
        double CellValue = cell.getNumericCellValue();
        System.out.println(CellValue);
        fileInputStream.close();
    }

07版本

package com.can;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.IOException;

public class ExcelReadTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";


    /**
     * 07版本
     */
    @Test
    public void XSSFRead07() throws IOException {
        //1、获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "CanPOI练习表07版本.xlsx");
        //2、创建一个工作簿。使用excel能操作的这边都可以操作
        Workbook workbook = new XSSFWorkbook(fileInputStream);
        //3、得到表
        Sheet sheetAt = workbook.getSheetAt(0); // 下标获取第1个工作表
        //4、得到行
        Row row = sheetAt.getRow(0); //拿到第1行
        //5、得到列
        Cell cell = row.getCell(1);//拿到第一列
        //6、得到第一行第一列的数据
        //读取值得时候，一定需要注意类型！
        //getStringCellValue获取字符串类型
//        String CellValue = cell.getStringCellValue();
        double CellValue = cell.getNumericCellValue();
        System.out.println(CellValue);
        fileInputStream.close();
    }
}

注意获取值得类型即可

读取不同类型的数据类型(最麻烦的地方)

package com.can;

        import org.apache.poi.hssf.usermodel.HSSFCell;
        import org.apache.poi.hssf.usermodel.HSSFDateUtil;
        import org.apache.poi.hssf.usermodel.HSSFWorkbook;
        import org.apache.poi.ss.usermodel.*;
        import org.apache.poi.xssf.usermodel.XSSFCell;
        import org.apache.poi.xssf.usermodel.XSSFWorkbook;
        import org.joda.time.DateTime;
        import org.junit.Test;

        import java.io.FileInputStream;
        import java.io.FileNotFoundException;
        import java.io.IOException;
        import java.math.BigDecimal;
        import java.text.DecimalFormat;
        import java.text.NumberFormat;
        import java.text.ParseException;
        import java.util.Date;

public class ExcelReadTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";

    /**
    *类型转换问题
    */
    @Test
    public void testCellType() throws IOException {
        //1、获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "测试类型07版本.xlsx");
        //2、创建一个工作簿。使用excel能操作的这边都可以操作
        Workbook workbook = new XSSFWorkbook(fileInputStream);
        //3、获取表
        Sheet sheet = workbook.getSheetAt(0);
        //3、获取标题内容
        Row rowTitle = sheet.getRow(0);
        if(rowTitle!=null){
            int cellCount = rowTitle.getPhysicalNumberOfCells();//读取总列数
            for (int cellNum = 0; cellNum < cellCount; cellNum++) {
                Cell cell = rowTitle.getCell(cellNum);//得到每一列
                if(cell!=null){
                    int cellType = cell.getCellType();
                    String cellValue = cell.getStringCellValue();
                    System.out.print(cellValue+"|");
                }
            }
            //换行
            System.out.println();
        }
        //获取内容
        int rowCount = sheet.getPhysicalNumberOfRows(); //读取总行数
        for (int rowNum = 1; rowNum < rowCount; rowNum++) {
            Row rowData = sheet.getRow(rowNum); //读取除了第一行外的每一行
            if(rowData!=null){
                //读取列
                int cellCount = rowData.getPhysicalNumberOfCells();//读取行的总列数
                for (int cellNum = 0; cellNum < cellCount; cellNum++) {
                    Cell cell = rowData.getCell(cellNum);
                    //匹配列的数据类型
                    if(cell!=null){
                        int cellType = cell.getCellType();
                        String cellTValue = "";
                        switch (cellType){
                            case XSSFCell.CELL_TYPE_STRING: //字符串
                                System.out.print("【STRING】");
                                cellTValue = cell.getStringCellValue();
                                break;
                            case XSSFCell.CELL_TYPE_BOOLEAN: //布尔值
                                System.out.print("【BOOLEAN】");
                                cellTValue = String.valueOf(cell.getBooleanCellValue());
                                break;
                            case XSSFCell.CELL_TYPE_BLANK: //空
                                System.out.print("【BLANK】");
                                break;
                            case XSSFCell.CELL_TYPE_NUMERIC: //数字（日期、普通数字）
                                System.out.print("【NUMERIC】");
                                if(DateUtil.isCellDateFormatted(cell)){ //日期
                                    System.out.print("【日期】");
                                    Date date = cell.getDateCellValue();
                                    cellTValue = new DateTime(date).toString("yyyy-MM-dd HH:ss:dd");
                                }else{  //普通数字
                                    //如果不是日期格式，防止数字过长！
                                    System.out.print("【普通数字】");
//                                    cell.setCellType(XSSFCell.CELL_TYPE_STRING);//普通数字就转化成字符串输出
//                                    cellTValue = cell.toString();

                                    //解决科学计数法输出问题
                                    DecimalFormat df = new DecimalFormat("0");
                                    BigDecimal bd = new BigDecimal(cellTValue);
                                    cellTValue = bd.toPlainString().toString();

                                }
                                break;
                            case XSSFCell.CELL_TYPE_ERROR: //数据类型错误
                                System.out.print("【数据类型错误】");
                                break;
                            default:
                                System.out.print("【未知类型】");
                                break;
                        }
                        System.out.println(cellTValue);
                    }
                }
            }
        }
        //关闭流
        fileInputStream.close();
    }
}

计算公式

package com.can;

import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFFormulaEvaluator;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.Date;

public class ExcelReadTest {

    //路径注意设置成自己的
    String PATH ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\can-poi\\";


    /**
     * 计算公式
     */
    @Test
    public void testFormula() throws IOException {
        //1、获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "计算公式练习.xls");
        //2、创建一个工作簿。使用excel能操作的这边都可以操作
        HSSFWorkbook workbook = new HSSFWorkbook(fileInputStream);
        //3、获取表
        HSSFSheet sheet = workbook.getSheetAt(0);

        Row row_4 = sheet.getRow(4);
        Cell cell_4_1 = row_4.getCell(0);
        //拿到计算公式 eval
       FormulaEvaluator formulaEvaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);

       //输出单元格内容
        int cellType = cell_4_1.getCellType();
        switch (cellType){
            case Cell.CELL_TYPE_FORMULA: //公式
                String formula = cell_4_1.getCellFormula();
                System.out.println(formula); // SUM(A1:A4)

                //计算
                CellValue evaluate = formulaEvaluator.evaluate(cell_4_1);
                String cellValue = evaluate.formatAsString();
                System.out.println(cellValue); //结果 1600.0
                break;
        }
    }
}

2、EasyExcel使用

快速、简单避免OOM的java处理Excel工具

1. 导入依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>easyexcelartifactId>
    <version>2.2.0-beta2version>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.12version>
dependency>
 
<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.62version>
dependency>

2.建一个实体类

package com.can;

import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

import java.util.Date;

@Data
public class DemoData {

    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;

    /**
     * 忽略这个字段
     */
    @ExcelIgnore
    private String ignore;
}

3.测试写入

package com.can;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.alibaba.excel.write.metadata.WriteSheet;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class EasyWriteTest {

    private List<DemoData> data(){
        List<DemoData> list = new ArrayList<DemoData>();
        for (int i = 0; i < 10; i++) {
            DemoData data = new DemoData();
            data.setString("字符串"+i);
            data.setDate(new Date());
            data.setDoubleData(0.56);
            list.add(data);
        }
        return list;
    }

    /**
     * write(fileName,格式类)
     * sheet(表名)
     * doWrite(数据)
     */
    //根据list 写入Excel
    @Test
    public void simpleWrite(){
        String fileName = "EasyExcel写法1.xlsx";
        String path ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\EasyExcel\\";
        //写法1
        //这里 需要指定写用哪个 class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        //如果这里想使用03版 则传入excelType参数即可.
        EasyExcel.write(fileName,DemoData.class).excelType(ExcelTypeEnum.XLSX).sheet("工作表名称").doWrite(data());

        //写法2
        ExcelWriter excelWriter = EasyExcel.write(fileName,DemoData.class).build();
        WriteSheet writeSheet = EasyExcel.writerSheet("工作表名称").build();
        excelWriter.write(data(),writeSheet);
        //千万别忘记finish 会帮忙关闭流
        excelWriter.finish();
    }

测试读取

读取要需要一个监听器类

package com.can;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

public class DemoDataListener extends AnalysisEventListener<DemoData> {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);

    /**
     * 每隔5条存储数据库，实际使用中可以 3000条，然后清理List，方便内存回收
     */
    private static final int BATCH_COUNT = 5;
    List<DemoData> list = new ArrayList<>();

    /**
     * 假设这是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDao;
    public DemoDataListener(){
        //这里是demo，所以随便new一个。实际使用如果到了spring，请使用下面的有参构造函数
        demoDao = new DemoDAO();
    }

    /**
     * 如果使用了spring，请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     * @param demoDao
     */
    public DemoDataListener(DemoDAO demoDao){
        this.demoDao = demoDao;
    }

    /**
     * 这个每一条数据解析都会来调用
     * @param demoData
     * @param analysisContext
     */
    @Override
    //读取数据会执行 invoke 方法
    //DemoData 类型
    //AnalysisContext 分析上文
    public void invoke(DemoData demoData, AnalysisContext analysisContext) {
        System.out.println(JSON.toJSONString(demoData));
        LOGGER.info("解析到了一条数据{}", JSON.toJSONString(demoData));
        list.add(demoData);
        //达到了BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if(list.size() >= BATCH_COUNT){
            saveData(); //持久化逻辑！
            //存储完成清理 list
            list.clear();
        }
    }

    /**
     * 所有数据解析完成了 都会来调用
     * @param analysisContext
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
        //这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        LOGGER.info("所有数据解析完成");
    }

    /**
     * 加上存储数据库
     */
    private void saveData(){
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        demoDao.save(list);
        LOGGER.info("存储数据库成功");
    }
}

测试读取

package com.can;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.alibaba.excel.write.metadata.WriteSheet;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class EasyWriteTest {

    private List<DemoData> data(){
        List<DemoData> list = new ArrayList<DemoData>();
        for (int i = 0; i < 10; i++) {
            DemoData data = new DemoData();
            data.setString("字符串"+i);
            data.setDate(new Date());
            data.setDoubleData(0.56);
            list.add(data);
        }
        return list;
    }

    /**
     * 读取操作
     */
    @Test
    public void simpleRead(){
        String fileName = "EasyExcel写法1.xlsx";
        String path ="D:\\练习项目idea(不可删)\\练习学习项目\\Excel\\EasyExcel\\";
        //写法1
        //这里 需要指定写用哪个 class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        //如果这里想使用03版 则传入excelType参数即可.
        EasyExcel.read(fileName,DemoData.class,new DemoDataListener()).sheet().doRead();

//写法2
        ExcelReader excelReader = EasyExcel.read(fileName,DemoData.class,new DemoDataListener()).build();
        ReadSheet readSheet =  EasyExcel.readSheet(0).build();
        excelReader.read(readSheet);
        //千万别忘记finish 会帮忙关闭流
        excelReader.finish();
    }
}

固定套路：

1. 写入，固定类格式进行写入。
2. 读取，根据监听器设置的规则进行读取！

写入官方文档：https://www.yuque.com/easyexcel/doc/write

读取官方文档：https://www.yuque.com/easyexcel/doc/read