java：EasyExcel使用（一）读excel
1 前言
EasyExcel相比于传统使用poi进行excel文件读写，编程使用操作上更加方便快捷，且对于内存溢出进行了优化处理。本文是EasyExcel读excel操作。
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模式，在上层做了模型转换的封装，让使用者更加简单方便。
EasyExcel官方文档：
https://easyexcel.opensource.alibaba.com/
进入maven.org，自动跳转如下进行maven仓库查询：
https://central.sonatype.com/?smo=true
搜索easyexcel：
pom文件添加如下依赖：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>3.3.4</version>
</dependency>
2 使用（Excel读取）
2.1 读Excel
GoodsDto：
package com.xiaoxu.excel.readE;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
/**
* @author xiaoxu
* @date 2024-04-26 22:32
* learn_java:com.xiaoxu.excel.readE.GoodsDto
*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDto {
private String name;
private Date date;
private long count;
private Date produceDate;
private double price;
}
在桌面准备的excel文件，test.xlsx：
excel读取方式一：
TestExcelRead，读取excel（JDK8.0+，不用额外写ReadListener，since: 3.0.0-beta1）：
package com.xiaoxu.excel.readE;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.fastjson.JSON;
import javax.swing.filechooser.FileSystemView;
import java.io.File;
import java.text.SimpleDateFormat;
/**
* @author xiaoxu
* @date 2024-04-27 14:53
* learn_java:com.xiaoxu.excel.readE.TestExcelRead
*/
public class TestExcelRead {
public static void main(String[] args) {
// C:\Users\****\Desktop
File homeDirectory = FileSystemView
.getFileSystemView().getHomeDirectory();
String fileName = "test";
// 读取桌面路径excel文件
String file = homeDirectory.getAbsolutePath()
+ File.separator + fileName + ".xlsx";
EasyExcel.read(file, GoodsDto.class,
new PageReadListener<GoodsDto>(dataList -> {
for (GoodsDto goodsDto : dataList) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(goodsDto));
SimpleDateFormat sdf =
new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss.SSS");
if (null != goodsDto.getDate()) {
System.out.println("日期:" +
sdf.format(goodsDto.getDate()));
}
if (null != goodsDto.getProduceDate()) {
System.out.println("生产日期:" +
sdf.format(goodsDto.getProduceDate()));
}
}
})).sheet().doRead();
}
}
执行excel读取结果如下：
读取到excel数据：
{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":15278342400000}
日期:2024-02-28 13:48:00.000
生产日期:2454-02-25 00:00:00.000
读取到excel数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":15278515200000}
日期:2024-04-20 19:10:00.000
生产日期:2454-02-27 00:00:00.000
读取到excel数据：{"count":0,"name":"菠萝","price":9.9}
日期转换说明，需要按照excel的日期格式来写，
上述结果表明，如果是引用类型，那么excel的cell值为null时，不会为实体类赋值；如果实体类是primitive类型数据，同时excel的cell值为null时，会将null转换成该primitive的默认值，比如实体类的count属性为long时，默认值就是0，所以也会赋值（因为包装类的值为null时，直接转换成primitive类型值时，不可以为其赋值为null，必须转换成其对应的默认值，否则将会抛出异常）。
同时注意，上述的实体类的字段，和excel的每一列是按顺序一一对应定义的。否则可能会抛出ExcelDataConvertException转换异常（Excel的值类型需要和实体类字段类型一一对应）。
excel读取方式二：
TestExcelRead2，读取excel（定义监听器GoodsDtoListener读取excel）：
GoodsDtoListener：
package com.xiaoxu.excel.readE;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.fastjson.JSON;
import java.util.List;
/**
* @author xiaoxu
* @date 2024-04-26 22:42
* learn_java:com.xiaoxu.excel.readE.GoodsDtoListener
*/
public class GoodsDtoListener implements ReadListener<GoodsDto> {
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 100;
/**
* 缓存数据
*/
private List<GoodsDto> cache = ListUtils
.newArrayListWithExpectedSize(BATCH_COUNT);
/**
* 假设这个是一个DAO，
* 当然有业务逻辑这个也可以是一个service。
* 当然如果不用存储这个对象没用。
*/
private GoodsDAO goodsDAO;
public GoodsDtoListener() {
// 这里是demo，所以随便new一个。
// 实际使用如果到了spring,请使用下面的有参构造函数
this.goodsDAO = new GoodsDAO();
}
public GoodsDtoListener(GoodsDAO goodsDAO) {
// 如果使用了spring,请使用这个构造方法。
// 每次创建Listener的时候需要把spring管理的类传进来
this.goodsDAO = goodsDAO;
}
/**
* @param goodsDto one row value.
* Is is same
* as {@link AnalysisContext#readRowHolder()}
* @param analysisContext 这个每一条数据解析都会来调用
*/
@Override
public void invoke(GoodsDto goodsDto, AnalysisContext analysisContext) {
System.out.println(
String.format(
"解析到数据: %s.", JSON.toJSONString(goodsDto)));
cache.add(goodsDto);
// 达到BATCH_COUNT了，需要去存储一次数据库，
// 防止数据几万条数据在内存，容易OOM
if (cache.size() >= BATCH_COUNT) {
saveData();
// cache置为空List，方便gc work
cache = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
}
}
private void saveData() {
System.out.println("开始存储数据数数据：" + cache.size());
goodsDAO.save(cache);
}
/**
* @param analysisContext 所有数据处理完，调用这里
*/
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
// 这里也要保存数据，
// 确保最后遗留的数据也存储到数据库
System.out.println("最终数据存储:");
saveData();
System.out.println("所有数据解析完成!");
}
}
GoodsDAO ：
public class GoodsDAO {
public void save(List<GoodsDto> goodsDtoList) {
// 如果是mybatis,尽量别直接调用多次insert,
// 自己写一个mapper里面新增一个方法batchInsert,
// 所有数据一次性插入
// batchInsert的插入性能更好
System.out.println("存储数据成功~");
}
}
TestExcelRead2：
package com.xiaoxu.excel.readE;
import com.alibaba.excel.EasyExcel;
import javax.swing.filechooser.FileSystemView;
import java.io.File;
/**
* @author xiaoxu
* @date 2024-04-27 16:37
* learn_java:com.xiaoxu.excel.readE.TestExcelRead2
*/
public class TestExcelRead2 {
public static void main(String[] args) {
// C:\Users\****\Desktop
File homeDirectory = FileSystemView
.getFileSystemView().getHomeDirectory();
String fileName = "test";
// 读取桌面路径excel文件
String file = homeDirectory.getAbsolutePath()
+ File.separator + fileName + ".xlsx";
// 有个很重要的点 GoodsDtoListener 不能被spring管理，
// 要每次读取excel都要new,然后里面用到spring可以构造方法传进去
// excel有多个Sheet，可以通过 .sheet("Sheet1")指定sheet名称
// 或者可以通过.sheet(0)指定读取第1个sheet
// 如果sheet名称不存在，那么不会报错，也不会读取到数据
EasyExcel.read(file, GoodsDto.class, new GoodsDtoListener())
.sheet("Sheet1").doRead();
}
}
执行结果如下：
解析到数据: {"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}.
解析到数据: {"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}.
解析到数据: {"count":0,"name":"菠萝","price":9.9}.
最终数据存储:
开始存储数据数数据：3
存储数据成功~
所有数据解析完成!
注意：excel文件有多个sheet时，.sheet()表示读取第1个sheet的内容。若需要指定sheet名称读取，则使用.sheet(“Sheet1”)即可指定名称为Sheet1的sheet进行读取，若不知道sheet名称，那么可以通过.sheet(0)读取第1个sheet，.sheet(1)读取第2个sheet等等的方式来进行读取，下标从0开始。如果sheet的名称不存在，或者sheet的索引下标不存在（比如总共只有3个sheet，但是读取为.sheet(3)第4个sheet）时，不会抛出异常，只是无法读取到对应数据。并且EasyExcel读取sheet的数据时，表头不会进入Listener回调中，而是从第二行的内容数据开始进入回调。
excel读取方式三：
TestExcelRead3，读取excel（通过ExcelReader、ReadSheet读取excel文件）：
package com.xiaoxu.excel.readE;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;
import javax.swing.filechooser.FileSystemView;
import java.io.File;
/**
* @author xiaoxu
* @date 2024-04-27 19:32
* learn_java:com.xiaoxu.excel.readE.TestExcelRead3
*/
public class TestExcelRead3 {
public static void main(String[] args) {
// C:\Users\****\Desktop
File homeDirectory = FileSystemView
.getFileSystemView().getHomeDirectory();
String fileName = "test";
// 读取桌面路径excel文件
String file = homeDirectory.getAbsolutePath()
+ File.separator + fileName + ".xlsx";
// 一个文件一个reader
try (ExcelReader excelReader = EasyExcel
.read(file, GoodsDto.class,
new GoodsDtoListener()).build()) {
// 构建一个sheet 这里可以指定名字或者no
ReadSheet readSheet = EasyExcel.readSheet(0).build();
// 读取一个sheet
excelReader.read(readSheet);
}
}
}
读取结果同读取方式二一致。
2.2 指定列的下标或者列名
前面提到了，实体类的字段必须按照顺序和excel的列一一对应，否则可能出现转换异常或者赋值与实际字段不匹配的情况。但是这种情况也有解决方式，即使用EasyExcel提供的@ExcelProperty注解。
GoodsDtoProperty：
package com.xiaoxu.excel.cols;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
/**
* @author xiaoxu
* @date 2024-04-27 20:36
* learn_java:com.xiaoxu.excel.cols.GoodsDtoPropertty
*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDtoProperty {
// 注解的默认值是value，这里表示excel的表头的列名称
@ExcelProperty("售卖日期")
private Date date;
@ExcelProperty(index = 99)
private long count;
private Date produceDate;
// index表示读取第几列，0表示第一列，1表示第二列...
// 这里price属性是实体类第四个属性，没有 @ExcelProperty表示和第4列对应
// 这里表示和excel的第5列对应
@ExcelProperty(index = 4)
private double price;
@ExcelProperty(value = "名称")
private String name;
}
excel数据如下：
TestExcelReadProp：
package com.xiaoxu.excel.cols;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.listener.PageReadListener;
import com.alibaba.fastjson.JSON;
import javax.swing.filechooser.FileSystemView;
import java.io.File;
import java.text.SimpleDateFormat;
/**
* @author xiaoxu
* @date 2024-04-27 20:46
* learn_java:com.xiaoxu.excel.cols.TestExcelReadProp
*/
public class TestExcelReadProp {
public static void main(String[] args) {
// C:\Users\****\Desktop
File homeDirectory = FileSystemView
.getFileSystemView().getHomeDirectory();
String fileName = "test";
// 读取桌面路径excel文件
String file = homeDirectory.getAbsolutePath()
+ File.separator + fileName + ".xlsx";
EasyExcel.read(file, GoodsDtoProperty.class,
new PageReadListener<GoodsDtoProperty>(dataList -> {
for (GoodsDtoProperty goodsDtoProp : dataList) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(goodsDtoProp));
SimpleDateFormat sdf =
new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss.SSS");
if (null != goodsDtoProp.getDate()) {
System.out.println("日期:" +
sdf.format(goodsDtoProp.getDate()));
}
if (null != goodsDtoProp.getProduceDate()) {
System.out.println("生产日期:" +
sdf.format(goodsDtoProp.getProduceDate()));
}
}
})).sheet().doRead();
}
}
执行结果：
读取到excel数据：{"count":0,"name":"苹果",
"price":1.65,"produceDate":1709099280000}
生产日期:2024-02-28 13:48:00.000
读取到excel数据：{"count":0,"name":"梨子",
"price":2.4,"produceDate":1713611400000}
生产日期:2024-04-20 19:10:00.000
读取到excel数据：{"count":0,"name":"菠萝","price":9.9}
上述表明，如果实体类中使用了@ExcelProperty注解，那么最好是全部属性都加上，这样方便和excel需要的属性列一一对应，否则可能出现部分值胡乱匹配excel列值的情况。同时，如果注解的value值随意填写，即excel的匹配列名不存在，或者index超越索引上限，都不会报错。同时index索引也是从0开始，0表示excel的第1列，1表示excel的第2列，以此类推。
2.3 读多个sheet
2.3.1 读取全部sheet
准备excel文件中存在多个Sheet，文件为test3.xlsx：
Sheet1：
Sheet2：
提取读取桌面文件工具类：
package com.xiaoxu.excel;
import javax.swing.filechooser.FileSystemView;
import java.io.File;
/**
* @author xiaoxu
* @date 2024-04-27 22:00
* learn_java:com.xiaoxu.excel.DeskTool
*/
public class DeskTool {
public static String getPath(String fileName) {
// C:\Users\****\Desktop
File homeDirectory = FileSystemView
.getFileSystemView().getHomeDirectory();
// 读取桌面路径excel文件
return homeDirectory.getAbsolutePath()
+ File.separator + fileName + ".xlsx";
}
}
GoodsDtoNew：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
/**
* @author xiaoxu
* @date 2024-04-27 22:17
* learn_java:com.xiaoxu.excel.multiSht.GoodsDtoNew
*/
@Getter
@Setter
@EqualsAndHashCode
public class GoodsDtoNew {
// 注解的默认值是value，这里表示excel的表头的列名称
@ExcelProperty("日期")
private Date date;
@ExcelProperty("生产日期")
private Date produceDate;
@ExcelProperty("价格")
private double price;
@ExcelProperty("数量")
private long count;
@ExcelProperty(value = "名称")
private String name;
}
GoodsDtoNewListener：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
/**
* @author xiaoxu
* @date 2024-04-27 22:20
* learn_java:com.xiaoxu.excel.multiSht.GoodsDtoNewListener
*/
public class GoodsDtoNewListener implements ReadListener<GoodsDtoNew> {
@Override
public void invoke(GoodsDtoNew goodsDtoNew, AnalysisContext analysisContext) {
System.out.println("扫描数据："
+ JSON.toJSONString(goodsDtoNew));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
System.out.println("所有数据解析完成!");
}
}
TestExcelReadMultiSheetAll：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.EasyExcel;
import com.xiaoxu.excel.DeskTool;
/**
* @author xiaoxu
* @date 2024-04-27 21:57
* learn_java:com.xiaoxu.excel.multiSht.TestExcelReadMultiSheetAll
*/
public class TestExcelReadMultiSheetAll {
public static void main(String[] args) {
String file = DeskTool.getPath("test3");
// 读取全部sheet
// 这里需要注意 GoodsDtoNewListener的doAfterAllAnalysed
// 会在每个sheet读取完毕后调用一次。
// 然后所有sheet都会往同一个GoodsDtoNewListener里面写(或者读)
EasyExcel.read(file,
GoodsDtoNew.class,
new GoodsDtoNewListener())
.doReadAll();
}
}
执行结果：
扫描数据：{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}
扫描数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}
扫描数据：{"count":0,"name":"菠萝","price":9.9}
所有数据解析完成!
扫描数据：{"count":45,"date":1709349480000,
"name":"水蜜桃","price":3.5,"produceDate":1746535536000000}
扫描数据：{"count":13,"date":1713805800000,
"name":"菠萝蜜","price":9.5,"produceDate":1746546508800000}
扫描数据：{"count":88,"date":1714227300000,
"name":"百香果","price":7.8,"produceDate":1746552816000000}
所有数据解析完成!
所有数据解析完成!
上述表明，doReadAll()方法会处理全部的Sheet数据，且全部sheet的数据是同一个listener处理的，并且doAfterAllAnalysed()最终读取完毕的回调方法，3个sheet分别调用了3次（因为上述的excel文件还有一个空的Sheet3）。
2.3.2 读取部分sheet
准备excel文件中存在多个Sheet，多个Sheet结构不同（对应不同监听器），文件为test2.xlsx：
Sheet1：
Sheet2：
MerchantDto：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
/**
* @author xiaoxu
* @date 2024-04-28 8:23
* learn_java:com.xiaoxu.excel.multiSht.MerchantDto
*/
@Getter
@Setter
@EqualsAndHashCode
public class MerchantDto {
@ExcelProperty("商户名称")
private String merchantName;
@ExcelProperty("商户库存")
private long merchantInventory;
}
MerchantDtoListener：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
/**
* @author xiaoxu
* @date 2024-04-28 8:25
* learn_java:com.xiaoxu.excel.multiSht.MerchantDtoListener
*/
public class MerchantDtoListener implements ReadListener<MerchantDto> {
@Override
public void invoke(MerchantDto merchantDto, AnalysisContext analysisContext) {
System.out.println("扫描商户数据："
+ JSON.toJSONString(merchantDto));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
System.out.println("商户所有数据解析完成!");
}
}
TestExcelReadMultiSheet：
package com.xiaoxu.excel.multiSht;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.xiaoxu.excel.DeskTool;
/**
* @author xiaoxu
* @date 2024-04-27 21:56
* learn_java:com.xiaoxu.excel.multiSht.TestExcelReadMultiSheet
*/
public class TestExcelReadMultiSheet {
public static void main(String[] args) {
String file = DeskTool.getPath("test2");
// 一个文件一个reader
try (ExcelReader excelReader = EasyExcel
.read(file).build()) {
// 可以注册同样的head和Listener 自己使用功能使用不同的Listener
// 构建一个sheet 这里可以指定名字或者no
ReadSheet readSheet = EasyExcel.readSheet(0)
.head(GoodsDtoNew.class)
.registerReadListener(new GoodsDtoNewListener())
.build();
ReadSheet readSheet2 = EasyExcel.readSheet(1)
.head(MerchantDto.class)
.registerReadListener(new MerchantDtoListener())
.build();
// 这里注意 一定要把sheet1 sheet2 一起传进去，
// 不然有个问题就是03版的excel 会读取多次，浪费性能
excelReader.read(readSheet, readSheet2);
}
}
}
执行结果：
扫描数据：{"count":45,"date":1709099280000,
"name":"苹果","price":1.65,"produceDate":1746545644800000}
扫描数据：{"count":13,"date":1713611400000,
"name":"梨子","price":2.4,"produceDate":1746563788800000}
扫描数据：{"count":0,"name":"菠萝","price":9.9}
所有数据解析完成!
扫描商户数据：{"merchantInventory":150,"merchantName":"天天水果"}
扫描商户数据：{"merchantInventory":500,"merchantName":"只爱水果"}
商户所有数据解析完成!
2.4 日期、数字或者自定义格式转换
test4.xlsx：
ConverterData：
package com.xiaoxu.excel.format;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.format.DateTimeFormat;
import com.alibaba.excel.annotation.format.NumberFormat;
import lombok.Getter;
import lombok.Setter;
/**
* @author xiaoxu
* @date 2024-04-29 20:01
* learn_java:com.xiaoxu.excel.format.ConverterData
*/
@Setter
@Getter
public class ConverterData {
/**
* 定义 转换器
*/
@ExcelProperty(value = "信息",
converter = CustomStringConverter.class)
private String message;
/**
* 这里用string 去接日期才能格式化。接收年月日格式
*/
@DateTimeFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒")
@ExcelProperty("日期")
private String date;
/**
* 接收百分比的数字
*/
@NumberFormat("#.##%")
@ExcelProperty("价格")
private String price;
}
CustomStringConverter，日期、数字或者自定义格式转换：
package com.xiaoxu.excel.format;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.converters.ReadConverterContext;
import com.alibaba.excel.converters.WriteConverterContext;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.data.WriteCellData;
/**
* @author xiaoxu
* @date 2024-04-29 20:05
* learn_java:com.xiaoxu.excel.format.CustomStringConverter
*/
public class CustomStringConverter implements Converter<String> {
@Override
public Class<?> supportJavaTypeKey() {
return String.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
/**
* @param context
* @return
* @throws Exception 读的时候调用
*/
@Override
public String convertToJavaData(
ReadConverterContext<?> context)
throws Exception {
String str = context.getReadCellData().getStringValue();
char[] chars = str.toCharArray();
int left = 0;
int right = chars.length - 1;
while (left < right) {
char temp = chars[left];
chars[left] = chars[right];
chars[right] = temp;
left++;
right--;
}
return new String(chars);
}
/**
* @param context
* @return
* @throws Exception 写的时候调用，这里不涉及写
*/
@Override
public WriteCellData<?> convertToExcelData(
WriteConverterContext<String> context)
throws Exception {
return new WriteCellData<>(context.getValue());
}
}
TestExcelConverter：
public class TestExcelConverter {
public static void main(String[] args) {
String file = DeskTool.getPath("test4");
EasyExcel.read(file, ConverterData.class,
// 这里注意 我们也可以registerConverter来指定自定义转换器，
// 但是这个转换变成全局了，所有java为string,
// excel为string的都会用这个转换器。
// 如果就想单个字段使用请使用@ExcelProperty 指定converter
// .registerConverter(new CustomStringStringConverter())
new PageReadListener<ConverterData>
((list) -> {
for (ConverterData c : list) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(c));
}
})).sheet().doRead();
}
}
执行结果：
读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}
上述convertToJavaData对String类型数据，进行字符串反转。
上述字符串反转，还可以使用下面的方式，效果一致：
String str = context.getReadCellData().getStringValue();
char[] chars = str.toCharArray();
int left = 0;
int right = chars.length - 1;
while (left < right) {
chars[left] ^= chars[right];
chars[right] ^= chars[left];
chars[left] ^= chars[right];
left++;
right--;
}
return new String(chars);
2.5 多行头
test5.xlsx：
TestMultiHead：
public class TestMultiHead {
public static void main(String[] args) {
String file = DeskTool.getPath("test5");
EasyExcel.read(file, ConverterData.class,
new PageReadListener<ConverterData>
((list) -> {
for (ConverterData c : list) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(c));
}
})).sheet().doRead();
}
}
执行结果：
读取到excel数据：{"date":"日期","message":"息信","price":"价格"}
读取到excel数据：{"date":"日期","message":"息信","price":"价格"}
读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}
默认就是如下的.headRowNumber(1)，表头一般是1行：
String file = DeskTool.getPath("test5");
EasyExcel.read(file, ConverterData.class,
new PageReadListener<ConverterData>
((list) -> {
for (ConverterData c : list) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(c));
}
})).sheet().headRowNumber(1).doRead();
如果上述有3行表头，我们希望都去掉，那么修改如下：
String file = DeskTool.getPath("test5");
EasyExcel.read(file, ConverterData.class,
new PageReadListener<ConverterData>
((list) -> {
for (ConverterData c : list) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(c));
}
})).sheet().headRowNumber(3).doRead();
3行表头场景，希望都去掉表头，使用.headRowNumber(3)即可，执行结果如下：
读取到excel数据：{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取到excel数据：{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}
2.6 同步的返回
test6.xlsx：
PeopleDto：
@Setter
@Getter
public class PeopleDto {
@ExcelProperty("名称")
private String name;
@ExcelProperty("年龄")
private int age;
}
TestSyncRead：
String file = DeskTool.getPath("test6");
// synchronous，同步的返回，不推荐使用，
// 如果数据量大会把数据放到内存里面
List<PeopleDto> peopleDtos = EasyExcel.read(file).head(PeopleDto.class)
.sheet().doReadSync();
for (PeopleDto p : peopleDtos) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(p));
}
// 这里 也可以不指定class，返回一个list，
// 然后读取第一个sheet 同步读取会自动finish
List<Map<Integer, String>> listMap = EasyExcel.read(file).sheet().doReadSync();
for (Map<Integer, String> data : listMap) {
// 返回每条数据的键值对 表示所在的列 和所在列的值
System.out.println("读取到数据:" + JSON.toJSONString(data));
}
执行结果：
读取到excel数据：{"age":66,"name":"小徐"}
读取到excel数据：{"age":22,"name":"小李"}
读取到数据:{0:"小徐",1:"66"}
读取到数据:{0:"小李",1:"22"}
2.7 读取表头数据
监听器重写invokeHeadMap方法即可：
PeopleDtoListener监听器：
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 com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import java.util.List;
import java.util.Map;
/**
* @author xiaoxu
* @date 2024-04-30
* java_demo:com.xiaoxu.test.excel.sync.PeopleDtoListener
*/
public class PeopleDtoListener implements ReadListener<PeopleDto> {
List<PeopleDto> peopleDtos = Lists.newArrayListWithCapacity(2);
@Override
public void invoke(PeopleDto peopleDto, AnalysisContext analysisContext) {
peopleDtos.add(peopleDto);
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
@Override
public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
Map<Integer, String> head = ConverterUtils.convertToStringMap(headMap, context);
System.out.println("读取到表头数据:" + JSON.toJSONString(head));
// 如果想转成成 Map<Integer,String>
// 方案1： 不要implements ReadListener 而是 extends AnalysisEventListener
// 方案2： 调用 ConverterUtils.convertToStringMap(headMap, context) 自动会转换
}
}
excel的head表头数据处理：
String file = DeskTool.getPath("test6");
// synchronous，同步的返回，不推荐使用，
// 如果数据量大会把数据放到内存里面
// 表头数据读取
List<PeopleDto> peopleDtos = EasyExcel.read(file).head(PeopleDto.class)
.registerReadListener(new PeopleDtoListener())
.sheet().doReadSync();
for (PeopleDto p : peopleDtos) {
System.out.println("读取到excel数据：" +
JSON.toJSONString(p));
}
执行结果：
读取到表头数据:{0:"名称",1:"年龄"}
读取到excel数据：{"age":66,"name":"小徐"}
读取到excel数据：{"age":22,"name":"小李"}
2.8 额外信息（批注、超链接、合并单元格信息读取）
since 2.0.0-beta1
对象：
@Getter
@Setter
@EqualsAndHashCode
public class DemoExtraData {
private String row1;
private String row2;
}
监听器：
@Slf4j
public class DemoExtraListener implements ReadListener<DemoExtraData> {
@Override
public void invoke(DemoExtraData data, AnalysisContext context) {}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {}
@Override
public void extra(CellExtra extra, AnalysisContext context) {
log.info("读取到了一条额外信息:{}", JSON.toJSONString(extra));
switch (extra.getType()) {
case COMMENT:
log.info("额外信息是批注,在rowIndex:{},columnIndex;{},内容是:{}", extra.getRowIndex(), extra.getColumnIndex(),
extra.getText());
break;
case HYPERLINK:
if ("Sheet1!A1".equals(extra.getText())) {
log.info("额外信息是超链接,在rowIndex:{},columnIndex;{},内容是:{}", extra.getRowIndex(),
extra.getColumnIndex(), extra.getText());
} else if ("Sheet2!A1".equals(extra.getText())) {
log.info(
"额外信息是超链接,而且覆盖了一个区间,在firstRowIndex:{},firstColumnIndex;{},lastRowIndex:{},lastColumnIndex:{},"
+ "内容是:{}",
extra.getFirstRowIndex(), extra.getFirstColumnIndex(), extra.getLastRowIndex(),
extra.getLastColumnIndex(), extra.getText());
} else {
Assert.fail("Unknown hyperlink!");
}
break;
case MERGE:
log.info(
"额外信息是超链接,而且覆盖了一个区间,在firstRowIndex:{},firstColumnIndex;{},lastRowIndex:{},lastColumnIndex:{}",
extra.getFirstRowIndex(), extra.getFirstColumnIndex(), extra.getLastRowIndex(),
extra.getLastColumnIndex());
break;
default:
}
}
}
/**
* 额外信息（批注、超链接、合并单元格信息读取）
* <p>
* 由于是流式读取，没法在读取到单元格数据的时候直接读取到额外信息，所以只能最后通知哪些单元格有哪些额外信息
*
* <p>
* 1. 创建excel对应的实体对象 参照{@link DemoExtraData}
* <p>
* 2. 由于默认异步读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoExtraListener}
* <p>
* 3. 直接读即可
*
* @since 2.2.0-beat1
*/
@Test
public void extraRead() {
String fileName = TestFileUtil.getPath() + "demo" + File.separator + "extra.xlsx";
// 这里 需要指定读用哪个class去读，然后读取第一个sheet
EasyExcel.read(fileName, DemoExtraData.class, new DemoExtraListener())
// 需要读取批注 默认不读取
.extraRead(CellExtraTypeEnum.COMMENT)
// 需要读取超链接 默认不读取
.extraRead(CellExtraTypeEnum.HYPERLINK)
// 需要读取合并单元格信息 默认不读取
.extraRead(CellExtraTypeEnum.MERGE).sheet().doRead();
}
test7.xlsx：
ConverterData：
@Setter
@Getter
public class ConverterData {
/**
* 定义 转换器
*/
@ExcelProperty(value = "信息",
converter = CustomStringConverter.class)
private String message;
/**
* 这里用string 去接日期才能格式化。接收年月日格式
*/
@DateTimeFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒")
@ExcelProperty("日期")
private String date;
/**
* 接收百分比的数字
*/
@NumberFormat("#.##%")
@ExcelProperty("价格")
private String price;
}
MergeDataListener：
package com.xiaoxu.excel.merge;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.metadata.CellExtra;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
import com.xiaoxu.excel.format.ConverterData;
import java.text.MessageFormat;
/**
* @author xiaoxu
* @date 2024-04-30 22:13
* learn_java:com.xiaoxu.excel.merge.MergeDataListener
*/
public class MergeDataListener implements ReadListener<ConverterData> {
@Override
public void invoke(ConverterData converterData, AnalysisContext analysisContext) {
System.out.println("读取正常数据:" +
JSON.toJSONString(converterData));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
@Override
public void extra(CellExtra extra, AnalysisContext context) {
System.out.println("读取额外数据:" +
JSON.toJSONString(extra));
switch (extra.getType()) {
case MERGE:
System.out.println(MessageFormat
.format("额外信息是合并单元格," +
"覆盖区间:firstRowIndex:{0}," +
"firstColumnIndex:{1}," +
"lastRowIndex:{2},lastColumnIndex:{3}.",
extra.getFirstRowIndex(),
extra.getFirstColumnIndex(),
extra.getLastRowIndex(),
extra.getLastColumnIndex()));
}
}
}
TestMerge：
// 这种写法只会输出正常读取的数据，而不会输出合并的单元格等数据
// 批注、超链接、合并单元格默认不读取
// EasyExcel.read(file).head(ConverterData.class)
// .registerReadListener(new MergeDataListener())
// .sheet().headRowNumber(1).doRead();
EasyExcel.read(file).head(ConverterData.class)
.registerReadListener(new MergeDataListener())
.extraRead(CellExtraTypeEnum.MERGE)
.sheet().headRowNumber(1).doRead();
执行结果：
读取正常数据:{"date":"2024年02月28日13时48分00秒000毫秒",
"message":"ebab好你","price":"980%"}
读取正常数据:{"date":"2024年04月08日11时20分00秒000毫秒",
"message":"EBABEFAC","price":"570%"}
读取额外数据:{"columnIndex":0,"firstColumnIndex":0,
"firstRowIndex":2,"lastColumnIndex":0,
"lastRowIndex":3,"rowIndex":2,"type":"MERGE"}
额外信息是合并单元格,覆盖区间:firstRowIndex:2,firstColumnIndex:0,
lastRowIndex:3,lastColumnIndex:0.
2.9 读取公式和单元格类型
test8.xlsx：
其中金额是公式生成的，是单价*数量计算出来的。
公式操作如下，在第一列数据的金额列下，输入=号，然后选中苹果的单价列，输入*表示乘，再选中苹果的数量列，按下enter即公式配置成功，下拉苹果列的金额，即可自动填充后续列的公式：
CellDataReadData：
package com.xiaoxu.excel.formula;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.metadata.data.CellData;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
/**
* @author xiaoxu
* @date 2024-05-01 10:22
* learn_java:com.xiaoxu.excel.formula.CellDataReadData
*/
@Getter
@Setter
@EqualsAndHashCode
public class CellDataReadData {
@ExcelProperty("品名")
private CellData<String> name;
@ExcelProperty("单价")
private CellData<Long> price;
@ExcelProperty("数量")
private CellData<Long> number;
@ExcelProperty("金额")
private CellData<Long> money;
@ExcelProperty("日期")
private CellData<Date> date;
}
CellDataListener：
public class CellDataListener implements ReadListener<CellDataReadData> {
@Override
public void invoke(CellDataReadData cellDataReadData, AnalysisContext analysisContext) {
System.out.println("读取正常数据:" +
JSON.toJSONString(cellDataReadData, true));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
}
TestCellData：
String file = DeskTool.getPath("test8");
EasyExcel.read(file).head(CellDataReadData.class)
.registerReadListener(new CellDataListener())
.extraRead(CellExtraTypeEnum.MERGE)
.sheet().headRowNumber(1).doRead();
执行结果：
读取正常数据:{
"date":{
"data":1709099280000,
"dataFormatData":{
"format":"yyyy-m-d h:mm",
"index":22
},
"numberValue":45350.575,
"originalNumberValue":45350.575,
"type":"NUMBER"
},
"money":{
"data":24,
"dataFormatData":{
"format":"General",
"index":0
},
"formulaData":{
"formulaValue":"B2*C2"
},
"numberValue":24,
"originalNumberValue":24,
"type":"NUMBER"
},
"name":{
"data":"苹果",
"dataFormatData":{
"format":"General",
"index":0
},
"stringValue":"苹果",
"type":"STRING"
},
"number":{
"data":12,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":12,
"originalNumberValue":12,
"type":"NUMBER"
},
"price":{
"data":2,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":2,
"originalNumberValue":2,
"type":"NUMBER"
}
}
读取正常数据:{
"date":{
"data":1712546400000,
"dataFormatData":{
"format":"yyyy-m-d h:mm",
"index":22
},
"numberValue":45390.4722222222,
"originalNumberValue":45390.4722222222,
"type":"NUMBER"
},
"money":{
"data":57,
"dataFormatData":{
"format":"General",
"index":0
},
"formulaData":{
"formulaValue":"B3*C3"
},
"numberValue":57,
"originalNumberValue":57,
"type":"NUMBER"
},
"name":{
"data":"西瓜",
"dataFormatData":{
"format":"General",
"index":0
},
"stringValue":"西瓜",
"type":"STRING"
},
"number":{
"data":19,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":19,
"originalNumberValue":19,
"type":"NUMBER"
},
"price":{
"data":3,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":3,
"originalNumberValue":3,
"type":"NUMBER"
}
}
读取正常数据:{
"date":{
"data":1714533600000,
"dataFormatData":{
"format":"yyyy-m-d h:mm",
"index":22
},
"numberValue":45413.4722222222,
"originalNumberValue":45413.4722222222,
"type":"NUMBER"
},
"money":{
"data":84,
"dataFormatData":{
"format":"General",
"index":0
},
"formulaData":{
"formulaValue":"B4*C4"
},
"numberValue":84,
"originalNumberValue":84,
"type":"NUMBER"
},
"name":{
"data":"土豆",
"dataFormatData":{
"format":"General",
"index":0
},
"stringValue":"土豆",
"type":"STRING"
},
"number":{
"data":21,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":21,
"originalNumberValue":21,
"type":"NUMBER"
},
"price":{
"data":4,
"dataFormatData":{
"format":"General",
"index":0
},
"numberValue":4,
"originalNumberValue":4,
"type":"NUMBER"
}
}
2.10 数据转换等异常处理
test9.xlsx：
数据转换等异常处理，在监听器中重写onException方法即可：
ErrorListener，在转换异常 获取其他异常下会调用本接口，抛出异常则停止读取，如果这里不抛出异常则继续读取下一行：
package com.xiaoxu.excel.exp;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.exception.ExcelDataConvertException;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
/**
* @author xiaoxu
* @date 2024-05-01 11:07
* learn_java:com.xiaoxu.excel.exp.ErrorListener
*/
public class ErrorListener implements ReadListener<ErrorObj> {
@Override
public void onException(Exception exception, AnalysisContext context) throws Exception {
System.out.println("解析失败,继续下一行数据解析:"
+ exception.getMessage());
if (exception instanceof ExcelDataConvertException) {
ExcelDataConvertException exp
= (ExcelDataConvertException) exception;
System.out.println(String.format("格式转换异常," +
"第%s行,第%s列解析异常,数据为:%s.",
exp.getRowIndex(), exp.getColumnIndex(),
exp.getCellData().getStringValue()));
}
}
@Override
public void invoke(ErrorObj errorObj, AnalysisContext analysisContext) {
System.out.println("读取数据:" +
JSON.toJSONString(errorObj, true));
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
}
ErrorObj：
@Setter
@Getter
public class ErrorObj {
@ExcelProperty("数目")
private long count;
}
TestErrorObj：
String file = DeskTool.getPath("test9");
EasyExcel.read(file).head(ErrorObj.class)
.registerReadListener(new ErrorListener())
.sheet().headRowNumber(1).doRead();
执行结果：
解析失败,继续下一行数据解析:
Convert data com.alibaba.excel.metadata.data.ReadCellData@dc8f2848 to long error
格式转换异常,第1行,第0列解析异常,数据为:苹果.
读取数据:{
"count":120
}
2.11 不创建对象的读
不创建对象的场景下读取数据，可以使用Map<Integer, String>来存储读取的数据：
@Slf4j
public class NoModelDataListener extends AnalysisEventListener<Map<Integer, String>> {
/**
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5;
private List<Map<Integer, String>> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
@Override
public void invoke(Map<Integer, String> data, AnalysisContext context) {
log.info("解析到一条数据:{}", JSON.toJSONString(data));
cachedDataList.add(data);
if (cachedDataList.size() >= BATCH_COUNT) {
saveData();
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
saveData();
log.info("所有数据解析完成！");
}
/**
* 加上存储数据库
*/
private void saveData() {
log.info("{}条数据，开始存储数据库！", cachedDataList.size());
log.info("存储数据库成功！");
}
}
不创建对象读取：
/**
* 不创建对象的读
*/
@Test
public void noModelRead() {
String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
// 这里 只要，然后读取第一个sheet 同步读取会自动finish
EasyExcel.read(fileName, new NoModelDataListener()).sheet().doRead();
}
2.12 web中的读
参考EasyExcel的读取文件方法，可以传入InputStream进行读取，那么可以结合Spring的web读取excel数据：
public static ExcelReaderBuilder read(InputStream inputStream, Class head, ReadListener readListener) {
ExcelReaderBuilder excelReaderBuilder = new ExcelReaderBuilder();
excelReaderBuilder.file(inputStream);
if (head != null) {
excelReaderBuilder.head(head);
}
if (readListener != null) {
excelReaderBuilder.registerReadListener(readListener);
}
return excelReaderBuilder;
}
web读取如下：
/**
* 文件上传
* <p>
* 1. 创建excel对应的实体对象 参照{@link UploadData}
* <p>
* 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
* <p>
* 3. 直接读即可
*/
@PostMapping("upload")
@ResponseBody
public String upload(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), UploadData.class, new UploadDataListener(uploadDAO)).sheet().doRead();
return "success";
}
