《SpringBoot》EasyExcel实现百万数据的导入导出

24年11月6日消息，阿里巴巴旗下的Java Excel工具库EasyExcel近日宣布，将停止更新，未来将逐步进入维护模式，将继续修复Bug，但不再主动新增功能。
EasyExcel 是一款着名的 Java Excel 工具库，由阿里巴巴开源，作者是玉箫，在 GitHub 上有 30k+ stars、7.5k forks。  据相识，EasyExcel作者玉箫去年已经从阿里离职，开始创业，也是开源数据库客户端 Chat2DB 的作者。
尽管 EasyExcel 已经不再维护，但其也不失为一个强大且优秀的工具框架，这里我们就一起看一下怎样使用 EasyExcel实现百万数据的导入导出。
简介

在一样平常的开发工作中，Excel 文件的读取和写入是非经常见的需求，特殊是在背景管理系统中更为频繁，基于传统的方式操作excel通常比较繁琐，EasyExcel 库的出现为我们带来了更简单、更高效的办理方案。本文将介绍 EasyExcel 库的基本用法和一些常见应用场景，帮助开发者更好地使用 EasyExcel 提高工作效率。
代码地点：https://github.com/alibaba/easyexcel
官网地点：Easy Excel 官网 (alibaba.com)
青出于蓝而胜于蓝

Java解析、天生Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以肯定程度的办理一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。
easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出；03版依赖POI的sax模式，在上层做了模型转换的封装，让使用者更加简单方便
16M内存23秒读取75M(46W行25列)的Excel（3.2.1+版本）
固然还有极速模式能更快，但是内存占用会在100M多一点 !

EasyExcel 核心类

EasyExcel 的核心类重要包括以下几个：

• ExcelReader： 用于读取 Excel 文件的核心类。通过 ExcelReader 类可以读取 Excel 文件中的数据，并举行相应的处理和操作。
  
• ExcelWriter： 用于写入 Excel 文件的核心类。通过 ExcelWriter 类可以将数据写入到 Excel 文件中，并举行样式设置、标题添加等操作。
  
• AnalysisEventListener： 变乱监听器接口，用于处理 Excel 文件读取过程中的变乱，如读取到每一行数据时的操作。
  
• AnalysisContext： 读取 Excel 文件时的上下文信息，包括当前行号、sheet 名称等。通过 AnalysisContext 可以获取到读取过程中的一些关键信息。
  
• WriteHandler： 写入 Excel 文件时的处理器接口，用于处理 Excel 文件的样式设置、标题添加等操作。
  
• WriteSheet： 写入 Excel 文件时的 Sheet 设置类，用于指定写入数据的 Sheet 名称、样式等信息。
  

这些核心类在 EasyExcel 中负担了差别的脚色，协作完成了 Excel 文件的读取和写入操作。开发者可以根据具体的需求和场景，使用这些类来实现 Excel 文件的各种操作。
Alibaba EasyExcel的核心入口类是EasyExcel类，就想我们平时封装的Util类一样，通过它对excel数据读取或者导出。
技能方案

百万数据导入

以下代码源码点击这里

方案一

• 单线程逐行解析： 使用单个线程顺序地逐行读取  Excel  文件
  
• 解析线程单条数据逐条插入：使用解析线程，每读取到一条数据，就立刻实行单条插入操作
  

优点：实现简单，容易调试和维护；得当小数据量的场景。
缺点：效率极低，由于每次插入都要举行一次网络请求和磁盘I/O操作，且没有使用到批量操作的优势。在大量数据的环境下非常耗时。

1. //方案一，方案二，方案四：单线程逐条解析
2. public void importExcel(MultipartFile file) throws IOException {
3.     EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
4. }

复制代码

EasyExcel解析完之后，都会回调ReadListener方法

1. @Override
2. @Transactional(rollbackFor = Exception.class)
3. public void invoke(Salaries data, AnalysisContext context) {
4.     //方案一：单线程逐行插入
5.     saveOne(data);
6. }
8. public void saveOne(Salaries data) {
9.     save(data);
10.     logger.info("第" + count.getAndAdd(1) + "次插入1条数据");
11. }

复制代码

方案二（保举）

• 单线程逐行解析：使用一个线程逐行读取 Excel 文件的数据。
  
• 解析线程批量插入：使用解析线程，将读取到的数据积累到肯定数量后，实行批量插入操作
  

优点：实现相对简单。比单条插入效率高，减少了网络请求和磁盘I/O的次数
缺点：受限于单线程的处理本领，效率不如多线程，并且在解析过程中可能会消耗大量内存，由于需要先将数据读入内存再举行批量插入。

1. //方案一，方案二，方案四：单线程逐条解析
2. public void importExcel(MultipartFile file) throws IOException {
3.     EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
4. }

复制代码

1. @Override
2. @Transactional(rollbackFor = Exception.class)
3. public void invoke(Salaries data, AnalysisContext context) {
4.     salariesList.get().add(data);
5.     if (salariesList.get().size() >= batchSize) {
6.                 saveData();
7.     }
8. }
10. public void saveData() {
11.     if (!salariesList.get().isEmpty()) {
12.         saveBatch(salariesList.get(), salariesList.get().size());
13.         logger.info("第" + count.getAndAdd(1) + "次插入" + salariesList.get().size() + "条数据");
14.         salariesList.get().clear();
15.     }
16. }

复制代码

方案三

• 多线程解析：每个Sheet对应一个线程举行解析，多个线程并行解析差别的Sheet。
  
• 解析线程批量插入：使用解析的线程，将读取到的数据积累到肯定数量后，实行批量插入操作。
  

优点：多线程解析可以充分使用多核CPU的优势，提高解析速度；批量插入可以减少数据库的变乱开销和I/O操作。
缺点：需要考虑多线程之间的数据传输和同步的问题，设计和实现较复杂。可能在解析和插入之间存在性能瓶颈。比方，若插入较快，则需要等待解析完成才可举行插入，因此可用异步线程的方式

1. //方案三，方案四：多线程解析，一个sheet对应一个线程
2. public void importExcelAsync(MultipartFile file) {
3.     // 开20个线程分别处理20个sheet
4.     List < Callable < Object >> tasks = new ArrayList < > ();
5.     for (int i = 0; i < 20; i++) {
6.         int num = i;
7.         tasks.add(() - > {
8.             EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener)
9.                 .sheet(num)
10.                 .doRead();
11.             return null;
12.         });
13.     }
15.     try {
16.         executorService.invokeAll(tasks);
17.     } catch (InterruptedException e) {
18.         throw new RuntimeException(e);
19.     }
20. }

复制代码

1. @Override
2. @Transactional(rollbackFor = Exception.class)
3. public void invoke(Salaries data, AnalysisContext context) {
4.     //方案二、三、四、五
5.     salariesList.get().add(data);
6.     if (salariesList.get().size() >= batchSize) {
7.                 saveData();
8.     }
9. }

复制代码

方案四（较保举）

• 单线程逐行解析：使用一个线程逐行读取 Excel 文件的数据。
  
• 异步线程批量插入：另开一个线程将数据批量插入到数据库，解析线程可以继续实行后续的解析操作。（可以只使用一个线程，防止多线程插入导致锁竞争的问题）
  

优点：解析和插入操作分离，可以在解析的同时举行插入，提高效率。
缺点：受限于单线程解析速度，而且需要管理异步操作

1. //方案一，方案二，方案四：单线程逐条解析
2. public void importExcel(MultipartFile file) throws IOException {
3.     EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
4. }

复制代码

1. @Override
2. @Transactional(rollbackFor = Exception.class)
3. public void invoke(Salaries data, AnalysisContext context) {
4.     salariesList.get().add(data);
5.     if (salariesList.get().size() >= batchSize) {
6.                 asyncSaveData1();//异步线程批量插入
7.     }
8. }

复制代码

方案五（保举）

• 多线程解析：每个Sheet对应一个线程举行解析，多个线程并行解析差别的Sheet。
  
• 多线程批量插入：另开多个线程将数据批量插入到数据库。
  

优点：联合了多线程解析和多线程异步插入的优势，可以最大化使用系统资源，提高数据导入速度。
缺点：实现较为复杂。需要小心处理数据库的并发毗连和变乱管理，防止引入死锁和性能瓶颈。

1. //方案三，方案四：多线程解析，一个sheet对应一个线程
2. public void importExcelAsync(MultipartFile file) {
3.     // 开20个线程分别处理20个sheet
4.     List < Callable < Object >> tasks = new ArrayList < > ();
5.     for (int i = 0; i < 20; i++) {
6.         int num = i;
7.         tasks.add(() - > {
8.             EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener)
9.                 .sheet(num)
10.                 .doRead();
11.             return null;
12.         });
13.     }
15.     try {
16.         executorService.invokeAll(tasks);
17.     } catch (InterruptedException e) {
18.         throw new RuntimeException(e);
19.     }
20. }

复制代码

1. @Override
2. @Transactional(rollbackFor = Exception.class)
3. public void invoke(Salaries data, AnalysisContext context) {
4.     salariesList.get().add(data);
5.     if (salariesList.get().size() >= batchSize) {
6.                 asyncSaveData();//多线程批量插入
7.     }
8. }
10. public void asyncSaveData() {
11.     if (!salariesList.get().isEmpty()) {
12.         ArrayList < Salaries > salaries = (ArrayList < Salaries > ) salariesList.get().clone();
13.         executorService.execute(new SaveTask(salaries, salariesListener));
14.         salariesList.get().clear();
15.     }
16. }

复制代码

方案选择

• 数据量较小（如几万条或更少的数据）：可以选择方案2（单线程逐行解析；单线程批量插入）或方案4（单线程逐行解析；异步线程批量插入），实现简单且性能足够。
  
• 数据量较大（如几十万到百万条数据）：保举方案5（多线程解析，每个sheet对应一个线程；异步线程批量插入）。尽管实现复杂，但它能够充分使用系统资源，极大地提拔导入效率。
  

在选择方案4时，需要特殊注意以下几点：

• 复杂性增加：方案4引入了异步操作，这意味着需要管理异步线程的生命周期，处理线程同步和可能的并发问题。对于小数据量，这种额外的复杂性可能不值得。
  
• 性能开销：异步操作可能会带来额外的性能开销，尤其是在线程创建、上下文切换和管理异步队列等方面。如果数据量不大，这些开销可能超过其带来的性能提拔。
  
• 资源使用：对于小数据量，单线程的解析和批量插入可能已经足够快，且能够有效使用系统资源。引入异步操作可能会导致资源管理变得更加复杂，而不肯定能带来明显的性能改进。当Excel中只有一个sheet时，只能逐行解析，但是以下几点可以考虑：
  
• 单线程足够：如果数据量不大，单线程逐行解析共同批量插入已经能够提供足够快的导入速度。
  
• 简化实现：单线程方案（如方案2）实现起来更简单，更容易调试和维护。
  
• 性能测试：在没有举行性能测试之前，可能无法确定异步操作是否真的带来了性能上的提拔。有时间，简单的同步方案就足够满足需求。
  

总之，方案4可能在数据量较大时更有优势，由于它可以更有效地使用系统资源，但在数据量不大时，这种优势可能不明显，反而增加了实现的复杂性和维护成本。因此，在选择方案时，需要根据实际的数据量、系统资源和性能需求来做出决策。但如果数据量较大，并且只有一个sheet，只能逐行解析时，较保举使用方案4。
在选择方案5时，需要特殊注意以下几点：

• 线程池管理：使用Java的 ExecutorService 来管明白析和插入线程，防止线程过多导致资源耗尽。
  
• 批量插入大小：适当的批量大小可以提高性能，一般建议每次批量插入500到1000条数据。
  
• 数据库毗连池：设置合理的数据库毗连池（如HikariCP），以支持高并发的数据库操作。
  
• 错误处理和变乱管理：确保对于每批数据操作有适当的错误处理和变乱管理，以包管数据一致性。
  

综合考虑性能和实现复杂性，方案5 是处理百万级数据导入的最佳选择，条件是能合理管理多线程和数据库毗连。
百万数据导出

方案一

• 查全表：一次性查询出整个表的数据。
  
• 写入一个sheet：将所有查询结果写入同一个 Excel sheet 中。
  

优点：实现简单，逻辑清晰；适用于数据量小的环境。
缺点：

• 性能瓶颈：一次性查询大量数据会占用大量内存。
  
• Excel 单个 sheet 限定：Excel 对单个 sheet 有行数限定（通常是 1048576 行），超过这个限定会导致问题。
  

1. public void exportExcel1(HttpServletResponse response) throws IOException {
2.     setExportHeader(response);
4.     //查出所有数据
5.     List < Salaries > salaries = salariesMapper.selectList(null);
6.     EasyExcel.write(response.getOutputStream(), Salaries.class)
7.         .sheet() //写到一个sheet
8.         .doWrite(salaries);
9. }

复制代码

方案二

• 查全表：一次性查询出整个表的数据。
  
• 写入多个sheet：根据行数限定，将数据分批写入多个 sheet 中。
  

优点：办理了单个 sheet 的行数限定问题。
缺点：

• 一次性查询大量数据仍然会占用大量内存。
  
• 需要在逻辑上处理怎样分配数据到差别的 sheet 中，大大增加了实现的复杂度。
  

1. public void exportExcel2(HttpServletResponse response) throws IOException {
2.     setExportHeader(response);
3.     //查出所有数据
4.     List < Salaries > salaries = salariesMapper.selectList(null);
6.     try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
7.         //创建3个sheet
8.         WriteSheet writeSheet1 = EasyExcel.writerSheet(1, "模板1").build();
9.         WriteSheet writeSheet2 = EasyExcel.writerSheet(2, "模板2").build();
10.         WriteSheet writeSheet3 = EasyExcel.writerSheet(3, "模板3").build();
12.         //将查出的数据进行分割
13.         List < Salaries > data1 = salaries.subList(0, salaries.size() / 3);
14.         List < Salaries > data2 = salaries.subList(salaries.size() / 3, salaries.size() * 2 / 3);
15.         List < Salaries > data3 = salaries.subList(salaries.size() * 2 / 3, salaries.size());
17.         //写入3个sheet
18.         excelWriter.write(data1, writeSheet1);
19.         excelWriter.write(data2, writeSheet2);
20.         excelWriter.write(data3, writeSheet3);
21.     }
22. }

复制代码

方案三（保举）

表明：

• 分页查询：将数据分页查询，每次查询一页数据。
  
• 每页数据写入每个sheet：每页数据写入差别的 sheet。
  

优点：

• 内存占用更均衡，不会一次性查询大量数据。
  
• 适用于大数据量，可以逐页处理，不会超过单个 sheet 的行数限定。
  

缺点：

• 实现稍复杂，需要处理分页逻辑和 sheet 切换。
  
• 写入多个 sheet 可能会增加文件大小和处理时间。
  

1. public void exportExcel3(HttpServletResponse response) throws IOException {
3.     setExportHeader(response);
5.     try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
6.         //查询表数据条数
7.         Long count = salariesMapper.selectCount(null);
8.         Integer pages = 10; //定义分成10页数据
9.         Long size = count / pages; //每页条数
11.         for (int i = 0; i < pages; i++) {
12.             //pages 页条数据，就创建pages页个 sheet
13.             WriteSheet writeSheet = EasyExcel.writerSheet(i, "模板" + i).build();
15.             Page < Salaries > page = new Page < > ();
16.             page.setCurrent(i + 1);
17.             page.setSize(size);
18.             Page < Salaries > selectPage = salariesMapper.selectPage(page, null);
20.             excelWriter.write(selectPage.getRecords(), writeSheet);
21.         }
22.     }
23. }

复制代码

方案四（保举）

• 多线程分页查询：使用多线程并行举行分页查询，每个线程处理一部分数据。
  
• 每页数据写入每个sheet：每个线程处理的数据写入差别的 sheet。
  

优点：

• 并行处理，极大提高查询速度。
  
• 内存使用更加高效，由于每个线程只处理自己的一部分数据。
  
• 有助于充分使用多核 CPU 的本领。
  

缺点：

• 需要合理管理线程池，避免资源竞争导致性能瓶颈。
  
• 可能引入并发访问数据库的问题，需要小心处理数据库毗连和变乱。
  

额外说一点：easyexcel 是不支持并发写入多个sheet，只能一个sheet一个sheet的写。因此尽管是多线程分页查询了，也只能单线程写入同一个excel

1. public void exportExcel4(HttpServletResponse response) throws IOException, InterruptedException {
3.     setExportHeader(response);
4.     //查询表数据条数
5.     Long count = salariesMapper.selectCount(null);
7.     Integer pages = 20; //定义分成10页数据
8.     Long size = count / pages; //每页条数
10.     //创建pages个线程
11.     ExecutorService executorService = Executors.newFixedThreadPool(pages);
12.     CountDownLatch countDownLatch = new CountDownLatch(pages);
14.     Map < Integer, Page < Salaries >> pageMap = new HashMap < > ();
15.     for (int i = 0; i < pages; i++) {
16.         int finalI = i;
17.         executorService.submit(new Runnable() {@
18.             Override
19.             public void run() {
20.                 //多线程分页查询
21.                 Page < Salaries > page = new Page < > ();
22.                 page.setCurrent(finalI + 1);
23.                 page.setSize(size);
24.                 Page < Salaries > selectPage = salariesMapper.selectPage(page, null);
26.                 pageMap.put(finalI, selectPage);
27.                 countDownLatch.countDown();
28.             }
29.         });
30.     }
32.     countDownLatch.await();
34.     try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
35.         //easyexcel不支持并发写入多个sheet，只能一个sheet一个sheet的写
36.         for (Map.Entry < Integer, Page < Salaries >> entry: pageMap.entrySet()) {
37.             Integer num = entry.getKey();
38.             Page < Salaries > salariesPage = entry.getValue();
39.             WriteSheet writeSheet = EasyExcel.writerSheet(num, "模板" + num).build();
40.             //写入多个sheet
41.             excelWriter.write(salariesPage.getRecords(), writeSheet);
42.         }
43.     }
45.     // https://github.com/alibaba/easyexcel/issues/1040
46. }

复制代码

方案选择

对于百万级数据的导出，建议选择方案 3 或方案 4：

• 方案 3（分页查询，每页数据写入每个sheet）：这个方案在实现上适中，能够有效办理单个 sheet 的行数限定问题，并且在内存使用上较为均衡。固然实现稍复杂，但性能和资源使用率较好，得当大多数场景。
  
• 方案 4（多线程分页查询；每页数据写入每个sheet）：这个方案适用于需要极高性能和速度的场景。通过多线程并行处理，可以极大提高导出效率，但实现复杂度较高，需要处理好线程同步和资源共享问题。如果系统资源（如 CPU 和内存）充足，并且能够合理管理多线程，这是性能最优的选择。
  

综上所述，方案 3 是一个兼顾实现复杂度和性能的选择，而方案 4 可以在资源充足（同样是全表放入内存中）且需要高性能的环境下使用。根据具体需求和系统资源，选择最符合的方案。
注意点

需要注意的是，分布式环境下，可能存在的问题：

• 同一个接口同时导入数据 的并发问题
  
• 正在导入数据时，不能在此时实行导出操作
  

以上问题可以通过 分布式锁来实现
模板方法设计模式简化EasyExcel的读取

看 官方文档 上读取Excel挺简单的，只需要一行代码

1. /**
2. * 指定列的下标或者列名
3. *
4. * <p>1. 创建excel对应的实体对象,并使用{@link ExcelProperty}注解. 参照{@link IndexOrNameData}
5. * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link IndexOrNameDataListener}
6. * <p>3. 直接读即可
7. */
8. @Test
9. public void indexOrNameRead() {
10.     String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
11.     // 这里默认读取第一个sheet
12.     EasyExcel.read(fileName, DemoData.class, new  DemoDataListener()).sheet().doRead();
13. }

复制代码

EasyExcel.read 团体流程图如下：

但仔细看，其实这里还需要创建一个回调监听器 DemoDataListener，也就是针对每个DemoData 即每个Excel 都需要创建一个单独的回调监听器类。

1. // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
2. @Slf4j
3. public class DemoDataListener implements ReadListener<DemoData> {
5.     /**
6.      * 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
7.      */
8.     private static final int BATCH_COUNT = 100;
9.     /**
10.      * 缓存的数据
11.      */
12.     private List<DemoData> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
13.     /**
14.      * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
15.      */
16.     private DemoDataDAO demoDAO;
18.     public DemoDataListener() {
19.         // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
20.         demoDAO = new DemoDAO();
21.     }
23.     /**
24.      * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
25.      *
26.      * @param demoDAO
27.      */
28.     public DemoDataListener(DemoDataDAO demoDAO) {
29.         this.demoDAO = demoDAO;
30.     }
32.     /**
33.      * 这个每一条数据解析都会来调用
34.      *
35.      * @param data    one row value. Is is same as {@link AnalysisContext#readRowHolder()}
36.      * @param context
37.      */
38.     @Override
39.     public void invoke(DemoData data, AnalysisContext context) {
40.         log.info("解析到一条数据:{}", JSON.toJSONString(data));
41.         cachedDataList.add(data);
42.         // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
43.         if (cachedDataList.size() >= BATCH_COUNT) {
44.             saveData();
45.             // 存储完成清理 list
46.             cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
47.         }
48.     }
50.     /**
51.      * 所有数据解析完成了 都会来调用
52.      *
53.      * @param context
54.      */
55.     @Override
56.     public void doAfterAllAnalysed(AnalysisContext context) {
57.         // 这里也要保存数据，确保最后遗留的数据也存储到数据库
58.         saveData();
59.         log.info("所有数据解析完成！");
60.     }
62.     /**
63.      * 加上存储数据库
64.      */
65.     private void saveData() {
66.         log.info("{}条数据，开始存储数据库！", cachedDataList.size());
67.         demoDAO.save(cachedDataList);
68.         log.info("存储数据库成功！");
69.     }
70. }

复制代码

在使用EasyExcel读取Excel时就在想能够怎样简化读取方式，而不是读取每个Excel都创建一个XXDataListener 的监听器类
首先，可以把DataListener加上泛型，共用一个DataListener
看上面代码，只需要在new的时间再去new DataListener即可
但是，如果要通报Dao 和 并且每个Dao怎样保存数据，而且保存数据前可能还需要对数据举行校验，也就存在以下问题：

• 怎样校验表头？
  
• 怎样处理表头数据？
  
• 怎样校验真实数据？
  
• 怎样处理真实数据？
  

那么该怎样处理呢？
末了想到了可以用Function(数据校验) + Consumer(数据存储) + 模板方法设计模式，创建一个共用的EasyExcel读取监听器，从而不在监听器中对数据举行处理，把处理都前置。

EasyExcel 的监听器类 Listener 已经定义了每一步会做什么，如通过 invokeHead 方法一行一行读取表头数据，通过invoke 方法一行一行读取真实数据。
也就是说，我们已经知道了 Listener 类所需的关键步调，即一行一行读取数据，而且确定了这些步调的实行顺序，但表头数据的校验和处理，真实数据的校验和处理还无法确定；并且这些是由导入的具体数据决定的，差别的表会有差别的校验 和 处理方式。基于此，我们就可以想到用 模板方法模式！

代码详情如下：

1. import cn.hutool.core.util.StrUtil;
2. import com.alibaba.excel.context.AnalysisContext;
3. import com.alibaba.excel.metadata.data.ReadCellData;
4. import com.alibaba.excel.read.listener.ReadListener;
5. import com.alibaba.excel.util.ConverterUtils;
6. import lombok.extern.slf4j.Slf4j;
8. import java.util.ArrayList;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.function.Consumer;
12. import java.util.function.Function;
14. @Slf4j
15. public class EasyExcelListener<T> implements ReadListener<T> {
17.     private static final int defaultBatchSize = 5000;
19.     private final int batchSize;
21.     private List<Map<Integer, String>> headData;
23.     private List<T> realData;
25.     private final int headRowCount;
27.     private Function<Map<Integer, String>, String> headDataCheck;
29.     private final Consumer<List<Map<Integer, String>>> headDataConsumer;
31.     private Function<T, String> realDataCheck;
33.     private final Consumer<List<T>> realDataConsumer;
35.     private final List<String> errorList;
37.     /**
38.      * 构造函数
39.      *
40.      * @param headRowCount     表头行数
41.      * @param headDataCheck    表头数据校验
42.      * @param headDataConsumer 表头数据处理
43.      * @param realDataCheck    真实数据校验
44.      * @param realDataConsumer 真实数据处理
45.      */
46.     public EasyExcelListener(int headRowCount, Function<Map<Integer, String>, String> headDataCheck, Consumer<List<Map<Integer, String>>> headDataConsumer
47.             , Function<T, String> realDataCheck, Consumer<List<T>> realDataConsumer) {
49.         this.headRowCount = headRowCount;
50.         this.batchSize = defaultBatchSize;
51.         this.headDataCheck = headDataCheck;
52.         this.headDataConsumer = headDataConsumer;
53.         this.realDataCheck = realDataCheck;
54.         this.realDataConsumer = realDataConsumer;
55.         headData = new ArrayList<>(headRowCount);
56.         realData = new ArrayList<>(batchSize);
57.         errorList = new ArrayList<>();
58.     }
60.     public EasyExcelListener(int headRowCount, int batchSize, Function<Map<Integer, String>, String> headDataCheck, Consumer<List<Map<Integer, String>>> headDataConsumer
61.             , Function<T, String> realDataCheck, Consumer<List<T>> realDataConsumer) {
63.         this.headRowCount = headRowCount;
64.         this.batchSize = batchSize;
65.         this.headDataCheck = headDataCheck;
66.         this.headDataConsumer = headDataConsumer;
67.         this.realDataCheck = realDataCheck;
68.         this.realDataConsumer = realDataConsumer;
69.         headData = new ArrayList<>(headRowCount);
70.         realData = new ArrayList<>(batchSize);
71.         errorList = new ArrayList<>();
72.     }
74.     @Override
75.     public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
76.         //获取表头数据
77.         Map<Integer, String> map = ConverterUtils.convertToStringMap(headMap, context);
79.         //校验表头数据
80.         String checkRes = headDataCheck.apply(map);
81.         if (StrUtil.isNotBlank(checkRes)) {
82.             int rowIndex = context.readRowHolder().getRowIndex() + 1;
83.             errorList.add("行号为:" + rowIndex + checkRes);
84.             return;
85.         }
87.         if (!errorList.isEmpty()) {
88.             //有错误信息，就不会再处理，只做校验
89.             return;
90.         }
91.          
92.         //没有问题的数据添加进list中
93.         headData.add(map);
94.         if (context.readRowHolder().getRowIndex() == headRowCount - 1) {
95.             //全部读取完表头数据后，处理表头数据
96.             headDataConsumer.accept(headData);
97.         }
98.     }
100.     @Override
101.     public void invoke(T data, AnalysisContext context) {
102.         //判断真实数据是否符合要求
103.         String checkRes = realDataCheck.apply(data);
104.         if (StrUtil.isNotBlank(checkRes)) {
105.             int rowIndex = context.readRowHolder().getRowIndex() + 1;
106.             errorList.add("行号为:" + rowIndex + checkRes);
107.             return;
108.         }
110.         //没有报错的数据添加进list
111.         realData.add(data);
112.         if (realData.size() >= batchSize) {
113.             //处理真实数据
114.             realDataConsumer.accept(realData);
115.             //清空realData
116.             realData = new ArrayList<>(batchSize);
117.         }
118.     }
120.     @Override
121.     public void doAfterAllAnalysed(AnalysisContext context) {
122.         // 解析完所有excel行, 剩余的数据还需要进行处理
123.         realDataConsumer.accept(realData);
124.     }
126.     public List<Map<Integer, String>> getHeadData() {
127.         return headData;
128.     }
130.     public List<T> getRealData() {
131.         return realData;
132.     }
134.     public List<String> getErrorList() {
135.         return errorList;
136.     }
137. }

复制代码

EasyExcel读取封装后的使用示例：

1. //构建 EasyExcelListener
2. EasyExcelListener < TaskImportDTO > taskImportDTOEasyExcelListener =
3.     new EasyExcelListener < > (
4.         4, //表头行数
5.         (map) - > { //表头数据校验
6.             return checkMap(map, startTime, taskMainDOList);
7.         }, headList - > {
8.             //表头数据处理   
9.             saveHeadData(headList);
10.         }, (data) - > {
11.             //真实数据校验
12.             return checkImportData(data);
13.         }, realDataList - > {
14.             //真实数据处理
15.             saveRealData(realDataList);
16.         }
17.     );
19. //读取数据
20. EasyExcelUtil.read(inputStream, TaskImportDTO.class, taskImportDTOEasyExcelListener)
21.     .headRowNumber(4) //表头行数
22.     .sheet()
23.     .doRead();

复制代码

上面的 checkMap ，saveHeadData，checkImportData，saveRealData皆为针对本次导入数据自定义的校验和处理方法。
若还有别的导入需求，只需new EasyExcelListener 方法，并自定义自己的校验和处理逻辑即可，从而完成代码复用！
替换产物

有个好消息就是，EasyExcel的作者创建了新项目：FastExcel。
开源地点：https://github.com/CodePhiliaX/fastexcel
作者选择为它起名为 FastExcel，以突出这个框架在处理 Excel 文件时的高性能表现，而不仅仅是简单易用。
FastExcel 将始终坚持免费开源，并采用最开放的 MIT 协议，使其适用于任何商业化场景。这为开发者和企业提供了极大的自由度和灵活性。FastExcel 的一些明显特点包括：

• 完全兼容原 EasyExcel 的所有功能和特性，这使得用户可以无缝过渡。
  
• 从 EasyExcel 迁移到 FastExcel 只需简单地更换包名和 Maven 依赖即可完成升级。
  
• 在功能上，比 EasyExcel 提供更多创新和改进。
  
• FastExcel 1.0.0 版本新增了读取 Excel 指定行数和将 Excel 转换为 PDF 的功能。
  

他们计划在未来推出更多新特性，以不绝提拔用户体验和工具实用性。FastExcel 致力于成为处理 Excel 文件的最佳选择。
重要特性：

• 高性能读写： FastExcel 专注于性能优化，能够高效处理大规模的 Excel 数据。相比一些传统的 Excel 处理库，它能明显降低内存占用。
  
• 简单易用： 该库提供了简洁直观的 API，使得开发者可以轻松集成到项目中，无论是简单的 Excel 操作还是复杂的数据处理都能快速上手。
  
• 流式操作： FastExcel 支持流式读取，将一次性加载大量数据的问题降到最低。这种设计方式在处理数十万甚至上百万行的数据时尤为重要。
  

当前 FastExcel 底层使用 poi 作为基础包，如果项目中已经有 poi 相关组件，需要手动排除 poi 的相关 jar 包。
如果使用 Maven 举行项目构建，请在 pom.xml 文件中引入以下设置：

1. <dependency>    
2.         <groupId>cn.idev.excel</groupId>    
3.         <artifactId>fastexcel</artifactId>    
4.         <version>1.0.0</version>
5. </dependency>

复制代码

EasyExcel 与 FastExcel 的区别：

• FastExcel 支持所有 EasyExcel 的功能，但是 FastExcel 的性能更好，更稳固。
  
• FastExcel 与 EasyExcel 的 API 完全一致，可以无缝切换。
  
• FastExcel 会一连的更新，修复 bug，优化性能，增加新功能。EasyExcel 怎样升级到 FastExcel
  

修改依赖

将 EasyExcel 的依赖替换为 FastExcel 的依赖，如下：

1. <dependency>    
2.         <groupId>com.alibaba</groupId>    
3.         <artifactId>easyexcel</artifactId>    
4.         <version>xxxx</version>
5. </dependency>

复制代码

依赖替换为

1. <dependency>    
2.         <groupId>cn.idev.excel</groupId>    
3.         <artifactId>fastexcel</artifactId>    
4.         <version>1.0.0</version>
5. </dependency>

复制代码

修改代码

将 EasyExcel 的包名替换为 FastExcel 的包名，如下：

1. import com.alibaba.excel.**;

复制代码

替换为

1. import cn.idev.excel.**;

复制代码

不修改代码直接依赖 FastExcel

如果由于种种原因不想修改代码，可以直接依赖 FastExcel ，然后在 pom.xml 文件中直接依赖 FastExcel。EasyExcel 与 FastExcel 可以共存，但是长期建议替换为 FastExcel。
建议以后使用 FastExcel 类

为了兼容性考虑保存了 EasyExcel 类，但是建议以后使用 FastExcel 类，FastExcel 类是FastExcel 的入口类，功能包含了 EasyExcel 类的所有功能，以后新特性仅在 FastExcel 类中添加。
简单示例：读取 Excel 文件 下面是读取 Excel 文档的例子：

1. // 实现 ReadListener 接口，设置读取数据的操作  
2. public class DemoDataListener implements ReadListener<DemoData> {  
3.     @Override  
4.     public void invoke(DemoData data, AnalysisContext context) {  
5.         System.out.println("解析到一条数据" + JSON.toJSONString(data));  
6.     }  
7.   
8.     @Override  
9.     public void doAfterAllAnalysed(AnalysisContext context) {  
10.         System.out.println("所有数据解析完成！");  
11.     }  
12. }  
13.   
14. public static void main(String[] args) {  
15.     String fileName = "demo.xlsx";  
16.     // 读取 Excel 文件  
17.     FastExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();  
18. }

复制代码

简单示例：创建 Excel 文件 下面是一个创建 Excel 文档的简单例子：
[code]// 示例数据类  public class DemoData {      @ExcelProperty("字符串标题")      private String string;      @ExcelProperty("日期标题")      private Date date;      @ExcelProperty("数字标题")      private Double doubleData;      @ExcelIgnore      private String ignore;  }    // 填充要写入的数据  private static List data() {      List list = new ArrayList();      for (int i = 0; i