详细解析POI 和 EasyExcel

在数据量需要被批量导入、导出的时候，就可以使用POI和easyExcel

常用场景：
1、将用户信息导出为excel表格(导出数据…)

2、将Excel表中的信息录入到网站数据库（习题上传…）大大减轻网站录入量!开发中经常会设计到excel的处理，如导出Excel，导入Excel到数据库中!

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

Apache POI
官网：https://poi.apache.org/
在这里插入图片描述
EasyExcel
easyExcel官网：GitHub - alibaba/easyexcel: 快速、简单避免OOM的java处理Excel工具

官方文档地址：https://www.yuque.com/easyexcel/doc/easyexcel
github地址:https://github.com/alibaba/easyexcel

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

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

内存问题:POl = 100w先加载到内存OOM。。再写入文件es= 1
在这里插入图片描述
POI-Excel操作：
1.导入依赖

<!-- xls 03 -->
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi</artifactId>
  <version>3.9</version>
</dependency>
<!-- xlsx 07 -->
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>3.9</version>
</dependency>
<!-- 日期格式化工具 -->
<dependency>
  <groupId>joda-time</groupId>
  <artifactId>joda-time</artifactId>
  <version>2.10.10</version>
</dependency>
 
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <scope>test</scope>
</dependency>
  1. 对于03版依赖和07版依赖的区别：
    03版最多只能到65530行，而07版没有限制，.xls格式文件对应03版，.xlsx格式文件对应07版；

3.Excel中的对象
2.1 工作簿 2.2 工作表 2.3 行 2.4 单元格

这些对象，就是我们在Java中需要操作的对象，把这个好好理解下，有助于后面的学习。
在这里插入图片描述
4.写操作
4.1 工作簿（WorkBook）的继承和实现关系：
在这里插入图片描述

HSSFWorkbook：03版工作簿

XSSFWorkbook：07版工作簿

SXSSFWorkbook：07版工作簿增强版

4.2 基础操作：

package com.ggz.poi;
 
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.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.junit.Test;
 
import java.io.FileOutputStream;
import java.io.IOException;
 
public class ExcelWriteTest {
    String path = "C:\\Users\\Administrator\\IdeaProjects\\code2\\pioeasyexcel\\poi";
    @Test
    public void testExcelWrite03Version() throws IOException {
 
        // 1.创建一个工作簿
        Workbook workbook = new HSSFWorkbook();
        // 2.创建工作表
        Sheet sheet1 = workbook.createSheet("表名1"); // 表名默认是sheet0
        // 3.创建第一行
        Row row1 = sheet1.createRow(0);
        // 4.创建单元格（1，1）
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("第一次使用poi");
        // （1，2）
        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("好激动啊");
        // 创建第二行
        Row row2 = sheet1.createRow(1);
        //  (2,1)
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue("现在时间是：");
        // （2，2）
        Cell cell22 = row2.createCell(1);
        cell22.setCellValue(new DateTime().toString("yyyy年MM月dd日 HH:mm:ss"));
 
        // 生成文件
        FileOutputStream fileOutputStream = new FileOutputStream(path + "\\poi03hss.xls");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        System.out.println("生成完毕");
    }
 
    @Test
    public void testExcelWrite07VersionXss() throws IOException {
 
        // 1.创建一个工作簿
        Workbook workbook = new XSSFWorkbook();
        // 2.创建工作表
        Sheet sheet1 = workbook.createSheet("表名2"); // 表名默认是sheet0
        // 3.创建第一行
        Row row1 = sheet1.createRow(0);
        // 4.创建单元格（1，1）
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("第一次使用poi");
        // （1，2）
        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("好激动啊");
        // 创建第二行
        Row row2 = sheet1.createRow(1);
        //  (2,1)
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue("现在时间是：");
        // （2，2）
        Cell cell22 = row2.createCell(1);
        cell22.setCellValue(new DateTime().toString("yyyy年MM月dd日 HH:mm:ss"));
 
        // 生成文件
        FileOutputStream fileOutputStream = new FileOutputStream(path + "\\poi07xss.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        System.out.println("生成完毕");
    }
 
    @Test
    public void testExcelWrite07VersionSxss() throws IOException {
 
        // 1.创建一个工作簿
        Workbook workbook = new SXSSFWorkbook();
        // 2.创建工作表
        Sheet sheet1 = workbook.createSheet("表名2"); // 表名默认是sheet0
        // 3.创建第一行
        Row row1 = sheet1.createRow(0);
        // 4.创建单元格（1，1）
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("第一次使用poi");
        // （1，2）
        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("好激动啊");
        // 创建第二行
        Row row2 = sheet1.createRow(1);
        //  (2,1)
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue("现在时间是：");
        // （2，2）
        Cell cell22 = row2.createCell(1);
        cell22.setCellValue(new DateTime().toString("yyyy年MM月dd日 HH:mm:ss"));
 
        // 生成文件
        FileOutputStream fileOutputStream = new FileOutputStream(path + "\\poi07sxss.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        System.out.println("生成完毕");
    }
 
 
}

4.3 BigData
4.3.1 HSSFWorkbook：03版工作簿 （大文件写）

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

优点 : 过程中写入缓存，不操作磁盘，最后一次性写入磁盘，速度快
在这里插入图片描述

@Test
public void testBigDataWrite03VersionHss() throws IOException {
    long start = System.currentTimeMillis();
    // 1.创建一个工作簿
    Workbook workbook = new HSSFWorkbook();
    // 2.创建工作表
    Sheet sheet1 = workbook.createSheet("表名2"); // 表名默认是sheet0
    // 循环创建行
    for (int rowNum = 0; rowNum < 65536; rowNum++) {
        Row row = sheet1.createRow(rowNum);
        // 循环创建单元格
        for (int cellNum = 0; cellNum < 10; cellNum++) {
            Cell cell = row.createCell(cellNum);
            cell.setCellValue(new DateTime().toString("HH:mm:ss"));
        }
    }
    System.out.println("HSS创建完毕！");
 
    // 生成文件
    FileOutputStream fileOutputStream = new FileOutputStream(path + "\\BigDataPoi03.xls");
    workbook.write(fileOutputStream);
    fileOutputStream.close();
    System.out.println("SSH生成完毕");
 
    long end = System.currentTimeMillis();
    System.out.println((double) (end - start) / 1000);
}

运行结果：
在这里插入图片描述
4.3.2 XSSFWorkbook：07版工作簿

@Test
public void testBigDataWrite07VersionXss() throws IOException {
    long start = System.currentTimeMillis();
    // 1.创建一个工作簿
    Workbook workbook = new XSSFWorkbook();
    // 2.创建工作表
    Sheet sheet1 = workbook.createSheet("表名2"); // 表名默认是sheet0
    // 循环创建行
    for (int rowNum = 0; rowNum < 65536; rowNum++) {
        Row row = sheet1.createRow(rowNum);
        // 循环创建单元格
        for (int cellNum = 0; cellNum < 10; cellNum++) {
            Cell cell = row.createCell(cellNum);
            cell.setCellValue(new DateTime().toString("HH:mm:ss"));
        }
    }
    System.out.println("XSS创建完毕！");
 
    // 生成文件
    FileOutputStream fileOutputStream = new FileOutputStream(path + "\\BigDataPoi07Xss.xls");
    workbook.write(fileOutputStream);
    fileOutputStream.close();
    System.out.println("XSS生成完毕");
 
    long end = System.currentTimeMillis();
    System.out.println((double) (end - start) / 1000);
}

运行结果：
在这里插入图片描述
4.3.2 SXSSFWorkbook：07版工作簿增强版

@Test
public void testBigDataWrite07VersionSxss() throws IOException {
    long start = System.currentTimeMillis();
    // 1.创建一个工作簿
    Workbook workbook = new SXSSFWorkbook();
    // 2.创建工作表
    Sheet sheet1 = workbook.createSheet("表名2"); // 表名默认是sheet0
    // 循环创建行
    for (int rowNum = 0; rowNum < 65536; rowNum++) {
        Row row = sheet1.createRow(rowNum);
        // 循环创建单元格
        for (int cellNum = 0; cellNum < 10; cellNum++) {
            Cell cell = row.createCell(cellNum);
            cell.setCellValue(new DateTime().toString("HH:mm:ss"));
        }
    }
    System.out.println("SXSS创建完毕！");
 
    // 生成文件
    FileOutputStream fileOutputStream = new FileOutputStream(path + "\\BigDataPoi07SXss.xls");
    workbook.write(fileOutputStream);
    fileOutputStream.close();
 
    // 清除临时文件
    ((SXSSFWorkbook)workbook).dispose();
 
    System.out.println("SXSS生成完毕");
 
    long end = System.currentTimeMillis();
    System.out.println((double) (end - start) / 1000);
}

执行结果：
在这里插入图片描述
5. POI-Excel读操作：
5.1基础操作：

package com.ggz.poi;
 
import org.apache.poi.hssf.usermodel.HSSFCell;
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.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;
 
import java.io.FileInputStream;
import java.io.IOException;
 
public class ExcelReadTest {
    String path = "C:\\Users\\Administrator\\IdeaProjects\\code2\\pioeasyexcel\\poi";
    @Test
    public void testReadHss() throws IOException {
        // 获取文件流
        FileInputStream fileInputStream = new FileInputStream(path + "\\会员消费商品明细表.xls");
        // 创建一个工作簿， Excel里面的操作，这边都有
        HSSFWorkbook workbook = new HSSFWorkbook(fileInputStream);
        // 创建工作表
        HSSFSheet sheet = workbook.getSheetAt(0);
        // 获取一行
        HSSFRow row = sheet.getRow(0);
        // 获取一个单元格（1，1）
        HSSFCell cell = row.getCell(0);
 
        System.out.println(cell.getStringCellValue());
				fileInputStream.close();
    }
 
    @Test
    public void testReadXss() throws IOException {
        // 获取文件流
        FileInputStream fileInputStream = new FileInputStream(path + "\\BigDataPoi07SXss.xls");
        // 创建一个工作簿， Excel里面的操作，这边都有
        XSSFWorkbook workbook = new XSSFWorkbook(fileInputStream);
        // 创建工作表
        XSSFSheet sheet = workbook.getSheetAt(0);
        // 获取一行
        XSSFRow row = sheet.getRow(0);
        // 获取一个单元格（1，1）
        XSSFCell cell = row.getCell(0);
 
        System.out.println(cell.getStringCellValue());
				fileInputStream.close();
    }
 
}

5.2 复杂数据类型读取：
主要是注意数据类型转换问题！看起来很复杂，其实就是双重循环和判断，不过这对我来说没什么。

package com.ggz.poi;
 
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.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.joda.time.DateTime;
import org.junit.Test;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Date;
 
public class EasyExcel {
    private final String PATH = "C:\\Users\\Administrator\\IdeaProjects\\code2\\pioeasyexcel\\poi";
    @Test
    public void testReadHSS() throws IOException {
        // 通过流获取工作簿、工作表等对象
        FileInputStream fileInputStream = new FileInputStream(PATH + "\\会员消费商品明细表.xls");
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        Sheet sheet = workbook.getSheetAt(0);
 
        // 获取标题内容
        Row rowTitle = sheet.getRow(0);
        if(rowTitle != null){
            int cellTotal = rowTitle.getPhysicalNumberOfCells();
            for (int cellNum = 0; cellNum < cellTotal; cellNum++) {
                Cell cell = rowTitle.getCell(cellNum);
                if (cell != null){
                    int cellType = cell.getCellType();
                    String stringCellValue = cell.getStringCellValue();
                    System.out.print(stringCellValue + " | ");
                }
            }
            System.out.println();
        }
 
        // 获取内容
        int rowTotal = sheet.getPhysicalNumberOfRows();
        for (int rowNum = 1; rowNum < rowTotal; rowNum++) {
            Row row = sheet.getRow(rowNum);
            if(row != null){
                int cellTotal = row.getPhysicalNumberOfCells();
                for (int cellNum = 0; cellNum < cellTotal; cellNum++) {
                    Cell cell = row.getCell(cellNum);
                    int cellType = cell.getCellType();
                    // 判断内容类型
                    switch (cellType){
                        case HSSFCell.CELL_TYPE_STRING:     // String类型
                            String stringCellValue = cell.getStringCellValue();
                            System.out.print(stringCellValue + " | ");
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC:    // 数字类型（日期、普通数字）
                            if (HSSFDateUtil.isCellDateFormatted(cell)){ // 日期类型
                                Date dateCellValue = cell.getDateCellValue();
                                String time = new DateTime(dateCellValue).toString("yyyy-MM-dd");
                                System.out.print(time + " | ");
                            } else {    // 普通数字
                                double numericCellValue = cell.getNumericCellValue();
                                System.out.print(numericCellValue + " | ");
                            }
                            break;
                        case HSSFCell.CELL_TYPE_BLANK:      // 空白
                            System.out.print("   | ");
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN:    // 布尔值
                            boolean booleanCellValue = cell.getBooleanCellValue();
                            System.out.print(booleanCellValue + " | ");
                            break;
                        case HSSFCell.CELL_TYPE_ERROR:      // 错误类型
                            System.out.print("数据类型错误");
                            break;
                    }
                }
                System.out.println();
            }
        }
        fileInputStream.close();
    }
 
}

5.3 计算公式

@Test
public void testFormula() throws Exception{
    FileInputStream fileInputStream = new FileInputStream(PATH + "\\计算公式.xls");
    Workbook workbook = new HSSFWorkbook(fileInputStream);
    Sheet sheetAt = workbook.getSheetAt(0);
 
    // 获取表中的计算公式
    FormulaEvaluator evaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);
 
    int physicalNumberOfRows = sheetAt.getPhysicalNumberOfRows();
    for (int rowNum = 0; rowNum < physicalNumberOfRows; rowNum++) {
        Row row = sheetAt.getRow(rowNum);
        if (row != null){
            int physicalNumberOfCells = row.getPhysicalNumberOfCells();
            for (int cellNum = 0; cellNum < physicalNumberOfCells; cellNum++) {
                Cell cell = row.getCell(cellNum);
                if (cell != null){
                    int cellType = cell.getCellType();
                    // 判断内容类型
                    switch (cellType){
 
                        case HSSFCell.CELL_TYPE_FORMULA:    // 公式
                            // 计算公式
                            String formula = cell.getCellFormula();
                            CellValue evaluate = evaluator.evaluate(cell);
                            String e = evaluate.formatAsString();
                            System.out.print(e + " | ");
                            break;
 
                        case HSSFCell.CELL_TYPE_STRING:     // String类型
                            String stringCellValue = cell.getStringCellValue();
                            System.out.print(stringCellValue + " | ");
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC:    // 数字类型（日期、普通数字）
                            if (HSSFDateUtil.isCellDateFormatted(cell)){ // 日期类型
                                Date dateCellValue = cell.getDateCellValue();
                                String time = new DateTime(dateCellValue).toString("yyyy-MM-dd");
                                System.out.print(time + " | ");
                            } else {    // 普通数字
                                double numericCellValue = cell.getNumericCellValue();
                                System.out.print(numericCellValue + " | ");
                            }
                            break;
                        case HSSFCell.CELL_TYPE_BLANK:      // 空白
                            System.out.print("   | ");
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN:    // 布尔值
                            boolean booleanCellValue = cell.getBooleanCellValue();
                            System.out.print(booleanCellValue + " | ");
                            break;
                        case HSSFCell.CELL_TYPE_ERROR:      // 错误类型
                            System.out.print("数据类型错误");
                            break;
                    }
                }
 
            }
            System.out.println();
        }
    }
}

EasyExcel操作：
按照我的流程，结合官方文档给出的代码去写，妥妥的没问题。
1.导入依赖:
注意：easyExcel依赖本身就依赖了 poi 和 poi-ooxml 两个包，注意避免冲突。

亲测：当我们排除 easyExcel 中的poi 和 poi-ooxml 两个包，会导致版本的冲突，找不到一些方法，这可能是依赖版本升级以后，有些方法被弃用导致的。最稳妥的做法就是将我们自己导入的 poi 那两个依赖去掉。

         <!-- slf4j -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <scope>compile</scope>
        </dependency>
        <!--fastJson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
        <!-- easyExcel-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.2.0-beta2</version>
        </dependency>
        <!-- xls 03 -->
       <!-- <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.9</version>
        </dependency>-->
        <!-- xlsx 07 -->
        <!--<dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>-->

2.写入测试
demo：最简单的写
在这里插入图片描述
2.1 创建实体：
官方文档代码中有@Data注解，其实就是 lombok 这个依赖的注解，可以在程序启动时，自动帮我们生成 get、set 方法。有兴趣的小伙伴自行研究，字段较少，我使用的原始的方法，自己写的get、set、构造方法等，就不贴出来了。

ps：Lombok很强大，可以只使用注解就能实现在程序启动时自动生成 get、set、toString、hash、构造方法等，用于简化代码，允许链式编程等等，不过也有弊端，就等可爱的你，自己去发现了。

package com.ggz.poi.entity;
 
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
 
import java.util.Date;
 
// @Data
public class DemoData {
    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;
    /**
     * 忽略这个字段
     */
    @ExcelIgnore
    private String ignore;

2.2 生成数据：
如果是在日常开发中，数据的来源往往是来自数据库、缓存等。


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;
}

2.3 写入文件：
easyExcel 官方文档中给出了3种写入的操作方式，我这里选用的是最简单的。

@Test
public void testEasyExcelWrite(){
    // 写法2
    String fileName = PATH + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
    // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
    // 如果这里想使用03 则 传入excelType参数即可
    // fileName 文件写出的目录和工作簿名称
    // DemoData.class 写出对象的字节码文件
    // sheet("模板") 工作表名称
    // data() 写入到工作表的数据
    EasyExcel.write(fileName, DemoData.class).sheet("模板").doWrite(data());
}

2.4 生成结果：
在这里插入图片描述
3.读取测试
demo：最简单的读
在这里插入图片描述
3.1 创建实体：
可以继续使用刚刚写入时的 DemoData 实体。

3.2 配置监听：

package com.ggz.poi.listener;
 
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.ggz.poi.entity.DemoData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.ArrayList;
import java.util.List;
 
// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener<DemoData> {
    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 3000;
    /**
     * 缓存的数据
     */
    private List<DemoData> list = new ArrayList<>(BATCH_COUNT);
    /**
     * 假设这个是一个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 data    one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            list = new ArrayList<>(BATCH_COUNT);
        }
    }
 
    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        LOGGER.info("所有数据解析完成！");
    }
 
    /**
     * 加上存储数据库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        // demoDAO.save(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).toString());
        }
        LOGGER.info("存储数据库成功！");
    }
 
}

3.3 读取文件：

private static final Logger LOGGER = LoggerFactory.getLogger(EasyExcelTest.class);
/**
     * 最简单的读
     * <p>
     * 1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>
     * 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>
     * 3. 直接读即可
     */
@Test
public void testSimpleRead(){
    // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
    // 写法3：
    String fileName = PATH + "simpleWrite1632457706893.xlsx";
    // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
    EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
}

3.4 执行结果：
我这里 slf 日志没有打印，原因是 slf4j 依赖有问题，导个依赖就好了，前面补上了。如果是复制的我贴出来的依赖，是没有问题的。
在这里插入图片描述
固定套路:

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/259508.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Unity中Shader平移变换

Unity中Shader平移变换

文章目录 前言方式一&#xff1a;对顶点本地空间下的坐标进行相加平移1、在属性面板定义一个四维变量记录在 xyz 上平移多少。2、在常量缓冲区进行申明3、在顶点着色器中&#xff0c;在进行其他坐标转化之前&#xff0c;对模型顶点本地空间下的坐标进行转化4、我们来看看效果 方…
阅读更多...
卷积层里的多输入与多输出通道(channel)

卷积层里的多输入与多输出通道(channel)

目录 一、多输入输出通道 1、多输入通道 2、多输出通道 3、11卷积层 4、二维卷积层的计算复杂度 5、总结 二、代码实现 1、多输入通道 2、多输出通道 3、11卷积层 4、总结 一、多输入输出通道 1、多输入通道 下图是多输入通道、单输出通道的情况&#xff1a;每个通道…
阅读更多...
.NET 药厂业务系统 CPU爆高分析

.NET 药厂业务系统 CPU爆高分析

Windbg 分析 1. CPU 真的爆高吗 还是老规矩&#xff0c;要想找到这个答案&#xff0c;可以使用 !tp 命令。 0:044> !tp logStart: 1 logSize: 200 CPU utilization: 88 % Worker Thread: Total: 8 Running: 4 Idle: 4 MaxLimit: 1023 MinLimit: 4 Work Request in Queue: …
阅读更多...
翻译: 负责任的人工智能 Responsible AI

翻译: 负责任的人工智能 Responsible AI

负责任的人工智能指的是以道德、值得信赖和社会负责任的方式开发和使用人工智能。许多开发者、企业和政府都关心这一点&#xff0c;并且一直在进行对话&#xff0c;也在努力确保人工智能的构建和使用是负责任的。由于对负责任的人工智能的所有这些关注和努力&#xff0c;我们在…
阅读更多...
网线制作，集线器、交换机、路由器的介绍以及路由器的设置

网线制作，集线器、交换机、路由器的介绍以及路由器的设置

目录 一. 网线制作 1.1 制作材料 1.2 网线标准 1.3 网线做法 二. 集线器、交换机、路由器介绍 前言 简介 简单来说 三. 路由器的设置 设置1 设置2 设置3 设置4 无线设置 一. 网线制作 1.1 制作材料 网线 …
阅读更多...
【进阶篇】YOLOv8实现K折交叉验证——解决数据集样本稀少和类别不平衡的难题，让你的模型评估更加稳健

【进阶篇】YOLOv8实现K折交叉验证——解决数据集样本稀少和类别不平衡的难题，让你的模型评估更加稳健

YOLOv8专栏导航&#xff1a;点击此处跳转 K折交叉验证 K折交叉验证&#xff08;K-Fold Cross-Validation&#xff09;是一种常用的机器学习模型评估方法&#xff0c;可以帮助我们评估模型的性能&#xff0c;特别适用于数据集相对较小的情况。 在K折交叉验证中&#xff0c;将原…
阅读更多...
CUMT--Java--JDBC编程

CUMT--Java--JDBC编程

目录 一、JDBC简介 二、数据库访问 1、加载数据库驱动 2、建立数据连接 3、创建Statement对象 4、执行SQL语句 5、访问结果集 三、MetaData接口 1、DatabaseMetaData接口 2、ResultSetMetaData接口 四、事务 1、JDBC中的事务 2、保存点 3、批量更新 一、JDBC简…
阅读更多...
若依(ruoyi)管理系统标题和logo修改

若依(ruoyi)管理系统标题和logo修改

1、网页上的logo 2、页面中的logo 进入ruoyi-ui --> src --> assets --> logo --> logo.png&#xff0c;把这个图片换成你自己的logo 3、网页标题 进入ruoyi-ui --> src --> layout --> components --> Sidebar --> Logo.vue&#xff0c;将里面的…
阅读更多...
第二周：AI产品经理全局学习

第二周：AI产品经理全局学习

一、AI产品架构全景 二、 AI产品岗位分析和了解 三、 AI产品能力模型 四、AI产品经理工作流 五、AI产品经理学习路径和规划 六、本周市场动态
阅读更多...
VM安装Sonoma【笔记】

VM安装Sonoma【笔记】

VMware Workstation安装MacOS Sonoma 1、配置虚拟机&#xff0c;根据系统性能调整参数&#xff1b; 2、先不焦急启动虚拟机&#xff0c;打开虚拟机存储目录&#xff0c;以文本方式打开.vmx文件&#xff08;这里以Sonoma.vmx为例&#xff09;&#xff1b; 这里只针对Inter CP…
阅读更多...
select和poll

select和poll

slelect实现客户端 #include <myhead.h> #define PORT 8888 #define PORT1 9999 #define IP "192.168.125.147" int main(int argc, const char *argv[]) {int cfd-1;if((cfdsocket(AF_INET,SOCK_STREAM,0))-1){perror("socket error");return -1…
阅读更多...
Go语言字符串综合指南：函数、方法和最佳实践

Go语言字符串综合指南：函数、方法和最佳实践

Go语言字符串综合指南&#xff1a;函数、方法和最佳实践 引言Go语言字符串基础声明和初始化不可变性字符串长度 字符串操作函数常用字符串操作转换与解析示例连接分割包含关系替换大小写转换整数与字符串的转换字符串到整数的转换格式化与解析 字符串与字符切片字符串和字符切片…
阅读更多...
WINDOWS(WIN11)通过IP添加网络打印机

WINDOWS(WIN11)通过IP添加网络打印机

点击添加设备 点击手动添加 使用IP地址或主机名添加打印机 选择TCP/IP设备&#xff0c;输入打印机地址 如果有正确驱动就安装&#xff0c;没有就取消。 通过手动设置添加本地打印机或网络打印机 使用现有的端口 根据打印机IP&#xff0c;选择标准端口。 成功&#xff01; 到…
阅读更多...
【LeetCode刷题笔记（12-1）】【Python】【有效的字母异位词】【排序/字符统计】【简单】

【LeetCode刷题笔记（12-1）】【Python】【有效的字母异位词】【排序/字符统计】【简单】

文章目录 引言有效的字母异位词题目描述提示 解决方案1&#xff1a;【排序】解决方案2&#xff1a;【字符统计】结束语 有效的字母异位词 引言 编写通过所有测试案例的代码并不简单&#xff0c;通常需要深思熟虑和理性分析。虽然这些代码能够通过所有的测试案例&#xff0c;但…
阅读更多...
贪吃蛇（三）绘制蛇身

贪吃蛇（三）绘制蛇身

绘制蛇身的逻辑不难&#xff0c;存储上面使用结构体。 第一行和第十九行绘制--其它行&#xff0c;绘制|&#xff0c;分别在头尾处。 (1) 扫描蛇身&#xff0c;如果扫描到则绘制[]。 (2) 扫描蛇身&#xff0c;如果扫描不到则绘制空白。 #include"curses.h"struct Sn…
阅读更多...
cpulimit设计理念及其思考

cpulimit设计理念及其思考

背景 前几天&#xff0c;同事咨询了我一个问题&#xff1a;IO占用能和cpu使用率那样&#xff0c;有方法来控制吗&#xff1f;这个问题的背景是因为客户提了两个需求&#xff0c;如下&#xff1a; 说实话&#xff0c;针对这两点需求&#xff0c;我的第一反应是有一点思路&#…
阅读更多...
第二节TypeScript 基础语法

第二节TypeScript 基础语法

1、typescript程序由以下几个部分组成&#xff1a; 模块函数变量语句和表达式注释 2、开始第一个typescript程序 创建一个typescript程序&#xff0c;使之输出“hello typescript”&#xff1a; 代码&#xff1a; var message:string "hello typescript" cons…
阅读更多...
MaBatis使用`ResultMap`标签手动映射详解使用

MaBatis使用`ResultMap`标签手动映射详解使用

文章目录 MaBatis使用ResultMap标签手动映射详解使用1、MyBatis只能自动维护库表”列名“与”属性名“相同时的对应关系&#xff0c;二者不同时无法自动ORM&#xff0c;如下&#xff1a;2、在SQL中使用 as 为查询字段添加列别名&#xff0c;以匹配属性名&#xff1a;但是如果我…
阅读更多...
（7）Linux GDB以及gcc和g++

（7）Linux GDB以及gcc和g++

&#x1f4ad; 前言 本章我们将带着大家高雅的学一学令众多习惯图形化页面的朋友难受的 gdb 调试&#xff0c;这部分知识可以选择性学习学习&#xff0c;以后倘若遇到一些问题时能在 Linux 内简单调试&#xff0c;还是很香的。然后在讲讲 gcc 和 g&#xff0c;系统讲解程序运行…
阅读更多...
基于STC89C51单片机实现的森林防火系统源码+仿真+原理图+设计报告，含视频讲解

基于STC89C51单片机实现的森林防火系统源码+仿真+原理图+设计报告，含视频讲解

森林防火 摘要 森林防火是非常必要的,火灾对森林的破坏是具有毁灭性的,有着很大的危害,在春秋季节森林火灾高发期,若发生火灾,对人民生活带来极大危害,不仅危害人们生产生活,而且对地球环境产生影响.本课题研究的内容是以单片机STC89C51为控制核心&#xff0c;以MQ-2型半导体电…
阅读更多...
最新文章

Copyright @ 2022~2023