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 中承担了不同的角色，协作完成了 Excel 文件的读取和写入操作。开发者可以根据具体的需求和场景，使用这些类来实现 Excel 文件的各种操作。
Alibaba EasyExcel的核心入口类是EasyExcel类，就想我们平时封装的Util类一样，通过它对excel数据读取或者导出。
以下代码源码点击这里
单线程逐行解析： 使用单个线程顺序地逐行读取 Excel 文件
解析线程单条数据逐条插入：使用解析线程，每读取到一条数据，就立即执行单条插入操作
优点：实现简单，容易调试和维护；适合小数据量的场景。
缺点：效率极低，因为每次插入都要进行一次网络请求和磁盘I/O操作，且没有利用到批量操作的优势。在大量数据的情况下非常耗时。
//方案一，方案二，方案四：单线程逐条解析
public void importExcel(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
}
EasyExcel解析完之后，都会回调ReadListener方法
@Override
@Transactional(rollbackFor = Exception.class)
public void invoke(Salaries data, AnalysisContext context) {
//方案一：单线程逐行插入
saveOne(data);
}
public void saveOne(Salaries data) {
save(data);
logger.info("第" + count.getAndAdd(1) + "次插入1条数据");
}
优点：实现相对简单。比单条插入效率高，减少了网络请求和磁盘I/O的次数
缺点：受限于单线程的处理能力，效率不如多线程，并且在解析过程中可能会消耗大量内存，因为需要先将数据读入内存再进行批量插入。
//方案一，方案二，方案四：单线程逐条解析
public void importExcel(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void invoke(Salaries data, AnalysisContext context) {
salariesList.get().add(data);
if (salariesList.get().size() >= batchSize) {
saveData();
}
}
public void saveData() {
if (!salariesList.get().isEmpty()) {
saveBatch(salariesList.get(), salariesList.get().size());
logger.info("第" + count.getAndAdd(1) + "次插入" + salariesList.get().size() + "条数据");
salariesList.get().clear();
}
}
优点：多线程解析可以充分利用多核CPU的优势，提高解析速度；批量插入可以减少数据库的事务开销和I/O操作。
缺点：需要考虑多线程之间的数据传输和同步的问题，设计和实现较复杂。可能在解析和插入之间存在性能瓶颈。例如，若插入较快，则需要等待解析完成才可进行插入，因此可用异步线程的方式
//方案三，方案四：多线程解析，一个sheet对应一个线程
public void importExcelAsync(MultipartFile file) {
// 开20个线程分别处理20个sheet
List > tasks = new ArrayList ();
for (int i = 0; i {
EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener)
.sheet(num)
.doRead();
return null;
});
}
try {
executorService.invokeAll(tasks);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void invoke(Salaries data, AnalysisContext context) {
//方案二、三、四、五
salariesList.get().add(data);
if (salariesList.get().size() >= batchSize) {
saveData();
}
}
优点：解析和插入操作分离，可以在解析的同时进行插入，提高效率。
缺点：受限于单线程解析速度，而且需要管理异步操作
//方案一，方案二，方案四：单线程逐条解析
public void importExcel(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void invoke(Salaries data, AnalysisContext context) {
salariesList.get().add(data);
if (salariesList.get().size() >= batchSize) {
asyncSaveData1();//异步线程批量插入
}
}
优点：结合了多线程解析和多线程异步插入的优势，可以最大化利用系统资源，提高数据导入速度。
缺点：实现较为复杂。需要小心处理数据库的并发连接和事务管理，防止引入死锁和性能瓶颈。
//方案三，方案四：多线程解析，一个sheet对应一个线程
public void importExcelAsync(MultipartFile file) {
// 开20个线程分别处理20个sheet
List > tasks = new ArrayList ();
for (int i = 0; i {
EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener)
.sheet(num)
.doRead();
return null;
});
}
try {
executorService.invokeAll(tasks);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void invoke(Salaries data, AnalysisContext context) {
salariesList.get().add(data);
if (salariesList.get().size() >= batchSize) {
asyncSaveData();//多线程批量插入
}
}
public void asyncSaveData() {
if (!salariesList.get().isEmpty()) {
ArrayList salaries = (ArrayList ) salariesList.get().clone();
executorService.execute(new SaveTask(salaries, salariesListener));
salariesList.get().clear();
}
}
在选择方案4时，需要特别注意以下几点：
总之，方案4可能在数据量较大时更有优势，因为它可以更有效地利用系统资源，但在数据量不大时，这种优势可能不明显，反而增加了实现的复杂性和维护成本。因此，在选择方案时，需要根据实际的数据量、系统资源和性能需求来做出决策。但若是数据量较大，并且只有一个sheet，只能逐行解析时，较推荐使用方案4。
在选择方案5时，需要特别注意以下几点：
ExecutorService 来管理解析和插入线程，防止线程过多导致资源耗尽。综合考虑性能和实现复杂性，方案5 是处理百万级数据导入的最佳选择，前提是能合理管理多线程和数据库连接。
优点：实现简单，逻辑清晰；适用于数据量小的情况。
缺点：
public void exportExcel1(HttpServletResponse response) throws IOException {
setExportHeader(response);
//查出所有数据
List salaries = salariesMapper.selectList(null);
EasyExcel.write(response.getOutputStream(), Salaries.class)
.sheet() //写到一个sheet
.doWrite(salaries);
}
优点：解决了单个 sheet 的行数限制问题。
缺点：
public void exportExcel2(HttpServletResponse response) throws IOException {
setExportHeader(response);
//查出所有数据
List salaries = salariesMapper.selectList(null);
try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
//创建3个sheet
WriteSheet writeSheet1 = EasyExcel.writerSheet(1, "模板1").build();
WriteSheet writeSheet2 = EasyExcel.writerSheet(2, "模板2").build();
WriteSheet writeSheet3 = EasyExcel.writerSheet(3, "模板3").build();
//将查出的数据进行分割
List data1 = salaries.subList(0, salaries.size() / 3);
List data2 = salaries.subList(salaries.size() / 3, salaries.size() * 2 / 3);
List data3 = salaries.subList(salaries.size() * 2 / 3, salaries.size());
//写入3个sheet
excelWriter.write(data1, writeSheet1);
excelWriter.write(data2, writeSheet2);
excelWriter.write(data3, writeSheet3);
}
}
解释：
优点：
缺点：
public void exportExcel3(HttpServletResponse response) throws IOException {
setExportHeader(response);
try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
//查询表数据条数
Long count = salariesMapper.selectCount(null);
Integer pages = 10; //定义分成10页数据
Long size = count / pages; //每页条数
for (int i = 0; i page = new Page ();
page.setCurrent(i + 1);
page.setSize(size);
Page selectPage = salariesMapper.selectPage(page, null);
excelWriter.write(selectPage.getRecords(), writeSheet);
}
}
}
优点：
缺点：
额外说一点：easyexcel 是不支持并发写入多个sheet，只能一个sheet一个sheet的写。因此尽管是多线程分页查询了，也只能单线程写入同一个excel
public void exportExcel4(HttpServletResponse response) throws IOException, InterruptedException {
setExportHeader(response);
//查询表数据条数
Long count = salariesMapper.selectCount(null);
Integer pages = 20; //定义分成10页数据
Long size = count / pages; //每页条数
//创建pages个线程
ExecutorService executorService = Executors.newFixedThreadPool(pages);
CountDownLatch countDownLatch = new CountDownLatch(pages);
Map > pageMap = new HashMap ();
for (int i = 0; i page = new Page ();
page.setCurrent(finalI + 1);
page.setSize(size);
Page selectPage = salariesMapper.selectPage(page, null);
pageMap.put(finalI, selectPage);
countDownLatch.countDown();
}
});
}
countDownLatch.await();
try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
//easyexcel不支持并发写入多个sheet，只能一个sheet一个sheet的写
for (Map.Entry > entry: pageMap.entrySet()) {
Integer num = entry.getKey();
Page salariesPage = entry.getValue();
WriteSheet writeSheet = EasyExcel.writerSheet(num, "模板" + num).build();
//写入多个sheet
excelWriter.write(salariesPage.getRecords(), writeSheet);
}
}
// https://github.com/alibaba/easyexcel/issues/1040
}
对于百万级数据的导出，建议选择方案 3 或方案 4：
综上所述，方案 3 是一个兼顾实现复杂度和性能的选择，而方案 4 可以在资源充足（同样是全表放入内存中）且需要高性能的情况下使用。根据具体需求和系统资源，选择最合适的方案。
需要注意的是，分布式环境下，可能存在的问题：
以上问题可以通过 分布式锁来实现
看 官方文档 上读取Excel挺简单的，只需要一行代码
/**
* 指定列的下标或者列名
*
* 1. 创建excel对应的实体对象,并使用{@link ExcelProperty}注解. 参照{@link IndexOrNameData}
*
2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link IndexOrNameDataListener}
*
3. 直接读即可
*/
@Test
public void indexOrNameRead() {
String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
// 这里默认读取第一个sheet
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
}
EasyExcel.read 整体流程图如下：
但仔细看，其实这里还需要创建一个回调监听器 DemoDataListener，也就是针对每个DemoData 即每个Excel 都需要创建一个单独的回调监听器类。
// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
@Slf4j
public class DemoDataListener implements ReadListener {
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 100;
/**
* 缓存的数据
*/
private List cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
/**
* 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
*/
private DemoDataDAO demoDAO;
public DemoDataListener() {
// 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
demoDAO = new DemoDAO();
}
/**
* 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
*
* @param demoDAO
*/
public DemoDataListener(DemoDataDAO 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) {
log.info("解析到一条数据:{}", JSON.toJSONString(data));
cachedDataList.add(data);
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
if (cachedDataList.size() >= BATCH_COUNT) {
saveData();
// 存储完成清理 list
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
}
}
/**
* 所有数据解析完成了 都会来调用
*
* @param context
*/
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
// 这里也要保存数据，确保最后遗留的数据也存储到数据库
saveData();
log.info("所有数据解析完成！");
}
/**
* 加上存储数据库
*/
private void saveData() {
log.info("{}条数据，开始存储数据库！", cachedDataList.size());
demoDAO.save(cachedDataList);
log.info("存储数据库成功！");
}
}
在使用EasyExcel读取Excel时就在想能够如何简化读取方式，而不是读取每个Excel都创建一个XXDataListener 的监听器类
首先，可以把DataListener加上泛型，共用一个DataListener
看上面代码，只需要在new的时候再去new DataListener即可
但是，如果要传递Dao 和 并且每个Dao如何保存数据，而且保存数据前可能还需要对数据进行校验，也就存在以下问题：
那么该如何处理呢？
最后想到了可以用Function(数据校验) + Consumer(数据存储) + 模板方法设计模式，创建一个共用的EasyExcel读取监听器，从而不在监听器中对数据进行处理，把处理都前置。
EasyExcel 的监听器类 Listener 已经定义了每一步会做什么，如通过 invokeHead 方法一行一行读取表头数据，通过invoke 方法一行一行读取真实数据。
也就是说，我们已经知道了 Listener 类所需的关键步骤，即一行一行读取数据，而且确定了这些步骤的执行顺序，但表头数据的校验和处理，真实数据的校验和处理还无法确定；并且这些是由导入的具体数据决定的，不同的表会有不同的校验 和 处理方式。基于此，我们就可以想到用 模板方法模式！
代码详情如下：
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.ConverterUtils;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
@Slf4j
public class EasyExcelListener implements ReadListener {
private static final int defaultBatchSize = 5000;
private final int batchSize;
private List EasyExcel读取封装后的使用示例：
//构建 EasyExcelListener
EasyExcelListener taskImportDTOEasyExcelListener =
new EasyExcelListener (
4, //表头行数
(map) - > { //表头数据校验
return checkMap(map, startTime, taskMainDOList);
}, headList - > {
//表头数据处理
saveHeadData(headList);
}, (data) - > {
//真实数据校验
return checkImportData(data);
}, realDataList - > {
//真实数据处理
saveRealData(realDataList);
}
);
//读取数据
EasyExcelUtil.read(inputStream, TaskImportDTO.class, taskImportDTOEasyExcelListener)
.headRowNumber(4) //表头行数
.sheet()
.doRead();
上面的 checkMap ，saveHeadData，checkImportData，saveRealData皆为针对本次导入数据自定义的校验和处理方法。
若还有其它导入需求，只需new EasyExcelListener 方法，并自定义自己的校验和处理逻辑即可，从而完成代码复用！
有个好消息就是，EasyExcel的作者创建了新项目：FastExcel。
开源地址：https://github.com/CodePhiliaX/fastexcel
作者选择为它起名为 FastExcel，以突出这个框架在处理 Excel 文件时的高性能表现，而不仅仅是简单易用。
FastExcel 将始终坚持免费开源，并采用最开放的 MIT 协议，使其适用于任何商业化场景。这为开发者和企业提供了极大的自由度和灵活性。FastExcel 的一些显著特点包括：
他们计划在未来推出更多新特性，以不断提升用户体验和工具实用性。FastExcel 致力于成为处理 Excel 文件的最佳选择。
主要特性：
当前 FastExcel 底层使用 poi 作为基础包，如果项目中已经有 poi 相关组件，需要手动排除 poi 的相关 jar 包。
如果使用 Maven 进行项目构建，请在 pom.xml 文件中引入以下配置：
cn.idev.excel
fastexcel
1.0.0
EasyExcel 与 FastExcel 的区别：
将 EasyExcel 的依赖替换为 FastExcel 的依赖，如下：
com.alibaba
easyexcel
xxxx
依赖替换为
cn.idev.excel
fastexcel
1.0.0
将 EasyExcel 的包名替换为 FastExcel 的包名，如下：
import com.alibaba.excel.**;
替换为
import cn.idev.excel.**;
如果由于种种原因不想修改代码，可以直接依赖 FastExcel ，然后在 pom.xml 文件中直接依赖 FastExcel。EasyExcel 与 FastExcel 可以共存，但是长期建议替换为 FastExcel。
为了兼容性考虑保留了 EasyExcel 类，但是建议以后使用 FastExcel 类，FastExcel 类是FastExcel 的入口类，功能包含了 EasyExcel 类的所有功能，以后新特性仅在 FastExcel 类中添加。
简单示例：读取 Excel 文件 下面是读取 Excel 文档的例子：
// 实现 ReadListener 接口，设置读取数据的操作
public class DemoDataListener implements ReadListener {
@Override
public void invoke(DemoData data, AnalysisContext context) {
System.out.println("解析到一条数据" + JSON.toJSONString(data));
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
System.out.println("所有数据解析完成！");
}
}
public static void main(String[] args) {
String fileName = "demo.xlsx";
// 读取 Excel 文件
FastExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
}
简单示例：创建 Excel 文件 下面是一个创建 Excel 文档的简单例子：
// 示例数据类
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 Java面试题专栏已上线，欢迎访问。
那么可以私信我，我会尽我所能帮助你。
本文来自在线网站：seven的菜鸟成长之路，作者：seven，转载请注明原文链接：www.seven97.top
登录查看全部
参与评论
手机查看
返回顶部