EasyExcel全面教程快速上手

转载 于 2020-01-14 10:04:23 发布 · 1.7k 阅读 · 4 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/sinat_32366329/article/details/103109058

本文深入讲解Alibaba开源的EasyExcel技术，针对ApachePOI进行优化，解决内存消耗问题，提供高效API，实现轻松读写Excel。涵盖快速入门、详解读写操作、自定义格式转换、合并单元格等高级功能，附带示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

EasyExcel教程
本文使用的技术是Alibaba集团开源的EasyExcel技术，该技术是针对Apache POI技术的封装和优化，主要解决了POI技术的耗内存问题，并且提供了较好的API使用。不需要大量的代码就可以实现excel的操作功能。

文章目录
EasyExcel教程
一、简介
二、传统解析的弊端
三、快速感受
四、详解读取Excel
简单读取
指定列的下标或名称
读取多个sheet
自定义格式转换
多行头
读取表头数据
异常处理
web读取
五、详解写入Excel
简单写入
导出指定的列
指定写入的列
复杂头写入
自定义格式转换
图片导出
列宽、行高
合并单元格
动态表头
web数据写出
六、详解填充样板写入
简单的填充
复杂的填充
七、API
详细参数介绍
关于常见类解析
读
注解
参数
通用参数
ReadWorkbook（理解成excel对象）参数
ReadSheet（就是excel的一个Sheet）参数
写
注解
参数
通用参数
WriteWorkbook（理解成excel对象）参数
WriteSheet（就是excel的一个Sheet）参数
WriteTable（就把excel的一个Sheet,一块区域看一个table）参数
一、简介
EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel。

二、传统解析的弊端
Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。easyexcel重写了poi对07版Excel的解析，能够原本一个3M的excel用POI sax依然需要100M左右内存降低到几M，并且再大的excel不会出现内存溢出，03版依赖POI的sax模式。在上层做了模型转换的封装，让使用者更加简单方便。

三、快速感受
excel内容

字符串标题 日期标题 数值标题
字符串10 2019/1/1 10
字符串20 2019/2/1 21
字符串30 2019/3/1 32
字符串40 2019/4/1 43
字符串50 2019/5/1 54
读Excel

/**
简单的读取excel文件
*/
@Test
public void read() {
String fileName = “demo.xlsx”;
// 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
// 参数一：读取的excel文件路径
// 参数二：读取sheet的一行，将参数封装在DemoData实体类中
// 参数三：读取每一行的时候会执行DemoDataListener监听器
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
}
1
2
3
4
5
6
7
8
9
10
11
12
写Excel

/**
简单的写入数据到excel
*/
@Test
public void simpleWrite() {
String fileName = “demo.xlsx”;
// 这里 需要指定写用哪个class去读，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
// 参数一：写入excel文件路径
// 参数二：写入的数据类型是DemoData
// data()方法是写入的数据，结果是List集合
EasyExcel.write(fileName, DemoData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
Web上传与下载

/**
excel文件的下载
*/
@GetMapping(“download”)
public void download(HttpServletResponse response) throws IOException {
response.setContentType(“application/vnd.ms-excel”);
response.setCharacterEncoding(“utf-8”);
response.setHeader(“Content-disposition”, “attachment;filename=demo.xlsx”);
EasyExcel.write(response.getOutputStream(), DownloadData.class).sheet(“模板”).doWrite(data());
}

/**
excel文件的上传
*/
@PostMapping(“upload”)
@ResponseBody
public String upload(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), DemoData.class, new DemoDataListener()).sheet().doRead();
return “success”;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
四、详解读取Excel
简单读取
对象

// 如果没有特殊说明，下面的案例将默认使用这个实体类
public class DemoData {
private String string;
private Date date;
private Double doubleData;
// getting setting
}
1
2
3
4
5
6
7
监听器

// 如果没有特殊说明，下面的案例将默认使用这个监听器
public class DemoDataListener extends AnalysisEventListener {

List<DemoData> list = new ArrayList<DemoData>();

/**
 * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
 */
public DemoDataListener() {}

/**
 * 这个每一条数据解析都会来调用
 *
 * @param data
 * @param context
 */
@Override
public void invoke(DemoData data, AnalysisContext context) {
    System.out.println("解析到一条数据:{}", JSON.toJSONString(data));
    list.add(data);
}

/**
 * 所有数据解析完成了 都会来调用
 *
 * @param context
 */
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
    System.out.println(JSON.toJSONString(list));
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
代码

@Test
public void simpleRead() {
// 写法1：
String fileName = “demo.xlsx”;
// 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();

// 写法2：
fileName = "demo.xlsx";
ExcelReader excelReader = EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).build();
ReadSheet readSheet = EasyExcel.readSheet(0).build();
excelReader.read(readSheet);
// 这里千万别忘记关闭，读的时候会创建临时文件，到时磁盘会崩的
excelReader.finish();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
指定列的下标或名称
对象

public class DemoData {
/**
* 强制读取第三个 这里不建议 index 和 name 同时用，要么一个对象只用index，要么一个对象只用name去匹配
/
@ExcelProperty(index = 2)
private Double doubleData;
/*
* 用名字去匹配，这里需要注意，如果名字重复，会导致只有一个字段读取到数据
*/
@ExcelProperty(“字符串标题”)
private String string;
@ExcelProperty(“日期标题”)
private Date date;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
代码

@Test
public void indexOrNameRead() {
String fileName = “demo.xlsx”;
// 这里默认读取第一个sheet
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
}
1
2
3
4
5
6
读取多个sheet
代码

@Test
public void repeatedRead() {
String fileName = “demo.xlsx”;
// 读取全部sheet
// 这里需要注意 DemoDataListener的doAfterAllAnalysed 会在每个sheet读取完毕后调用一次。然后所有sheet都会往同一个DemoDataListener里面写
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).doReadAll();

// 读取部分sheet
fileName = "demo.xlsx";
ExcelReader excelReader = EasyExcel.read(fileName).build();
// 这里为了简单 所以注册了 同样的head 和Listener 自己使用功能必须不同的Listener
// readSheet参数设置读取sheet的序号
ReadSheet readSheet1 =
    EasyExcel.readSheet(0).head(DemoData.class).registerReadListener(new DemoDataListener()).build();
ReadSheet readSheet2 =
    EasyExcel.readSheet(1).head(DemoData.class).registerReadListener(new DemoDataListener()).build();
// 这里注意 一定要把sheet1 sheet2 一起传进去，不然有个问题就是03版的excel 会读取多次，浪费性能
excelReader.read(readSheet1, readSheet2);
// 这里千万别忘记关闭，读的时候会创建临时文件，到时磁盘会崩的
excelReader.finish();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
自定义格式转换
对象

@Data
public class ConverterData {
/**
* converter属性定义自己的字符串转换器
/
@ExcelProperty(converter = CustomStringConverter.class)
private String string;
/*
* 这里用string 去接日期才能格式化
/
@DateTimeFormat(“yyyy年MM月dd日 HH时mm分ss秒”)
private String date;
/*
* 我想接收百分比的数字
*/
@NumberFormat("#.##%")
private String doubleData;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
自定义转换器

public class CustomStringStringConverter implements Converter {
@Override
public Class supportJavaTypeKey() {
return String.class;
}

@Override
public CellDataTypeEnum supportExcelTypeKey() {
    return CellDataTypeEnum.STRING;
}

/**
 * 这里读的时候会调用
 *
 * @param cellData
 *            NotNull
 * @param contentProperty
 *            Nullable
 * @param globalConfiguration
 *            NotNull
 * @return
 */
@Override
public String convertToJavaData(CellData cellData, ExcelContentProperty contentProperty,
    GlobalConfiguration globalConfiguration) {
    return "自定义：" + cellData.getStringValue();
}

/**
 * 这里是写的时候会调用 不用管
 *
 * @param value
 *            NotNull
 * @param contentProperty
 *            Nullable
 * @param globalConfiguration
 *            NotNull
 * @return
 */
@Override
public CellData convertToExcelData(String value, ExcelContentProperty contentProperty,
    GlobalConfiguration globalConfiguration) {
    return new CellData(value);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
代码

@Test
public void converterRead() {
String fileName = “demo.xlsx”;
// 这里 需要指定读用哪个class去读，然后读取第一个sheet
EasyExcel.read(fileName, ConverterData.class, new ConverterDataListener())
// 这里注意 我们也可以registerConverter来指定自定义转换器， 但是这个转换变成全局了， 所有java为string,excel为string的都会用这个转换器。
// 如果就想单个字段使用请使用@ExcelProperty 指定converter
// .registerConverter(new CustomStringStringConverter())
// 读取sheet
.sheet().doRead();
}
1
2
3
4
5
6
7
8
9
10
11
多行头
代码

@Test
public void complexHeaderRead() {
String fileName = “demo.xlsx”;
// 这里 需要指定读用哪个class去读，然后读取第一个sheet
EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet()
// 这里可以设置1，因为头就是一行。如果多行头，可以设置其他值。不传入默认1行
.headRowNumber(1).doRead();
}
1
2
3
4
5
6
7
8
读取表头数据
监听器

/**

  • 这里会一行行的返回头
  • 监听器只需要重写这个方法就可以读取到头信息
  • @param headMap
  • @param context
    */
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
    LOGGER.info(“解析到一条头数据:{}”, JSON.toJSONString(headMap));
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    代码

@Test
public void headerRead() {
String fileName = “demo.xlsx”;
// 这里 需要指定读用哪个class去读，然后读取第一个sheet
EasyExcel.read(fileName, DemoData.class, new ReadDataListener()).sheet().doRead();
}
1
2
3
4
5
6
异常处理
监听器

/**

  • 监听器实现这个方法就可以在读取数据的时候获取到异常信息
    */
    @Override
    public void onException(Exception exception, AnalysisContext context) {
    LOGGER.error(“解析失败，但是继续解析下一行:{}”, exception.getMessage());
    // 如果是某一个单元格的转换异常 能获取到具体行号
    // 如果要获取头的信息 配合invokeHeadMap使用
    if (exception instanceof ExcelDataConvertException) {
    ExcelDataConvertException excelDataConvertException = (ExcelDataConvertException)exception;
    LOGGER.error(“第{}行，第{}列解析异常”, excelDataConvertException.getRowIndex(),
    excelDataConvertException.getColumnIndex());
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    web读取
    代码

@PostMapping(“upload”)
@ResponseBody
public String upload(MultipartFile file) throws IOException {
EasyExcel.read(file.getInputStream(), UploadData.class, new UploadDataListener(uploadDAO)).sheet().doRead();
return “SUCCESS”;
}
1
2
3
4
5
6
五、详解写入Excel
数据写入公用方法

private List data() {
List list = new ArrayList();
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;
}
1
2
3
4
5
6
7
8
9
10
11
简单写入
对象

public class DemoData {
@ExcelProperty(“字符串标题”)
private String string;
@ExcelProperty(“日期标题”)
private Date date;
@ExcelProperty(“数字标题”)
private Double doubleData;
// getting setting
}
1
2
3
4
5
6
7
8
9
代码

@Test
public void simpleWrite() {
// 写法1
String System.currentTimeMillis() + “.xlsx”;
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
// 如果这里想使用03 则 传入excelType参数即可
EasyExcel.write(fileName, DemoData.class).sheet(“写入方法一”).doWrite(data());

// 写法2，方法二需要手动关闭流
fileName = System.currentTimeMillis() + ".xlsx";
// 这里 需要指定写用哪个class去写
ExcelWriter excelWriter = EasyExcel.write(fileName, DemoData.class).build();
WriteSheet writeSheet = EasyExcel.writerSheet("写入方法二").build();
excelWriter.write(data(), writeSheet);
/// 千万别忘记finish 会帮忙关闭流
excelWriter.finish();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
导出指定的列
代码

@Test
public void excludeOrIncludeWrite() {
String fileName = “excludeOrIncludeWrite” + System.currentTimeMillis() + “.xlsx”;

// 忽略 date 不导出
Set<String> excludeColumnFiledNames = new HashSet<String>();
excludeColumnFiledNames.add("date");
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, DemoData.class).excludeColumnFiledNames(excludeColumnFiledNames).sheet("忽略date")
    .doWrite(data());

fileName = "excludeOrIncludeWrite" + System.currentTimeMillis() + ".xlsx";
// 根据用户传入字段 假设我们只要导出 date
Set<String> includeColumnFiledNames = new HashSet<String>();
includeColumnFiledNames.add("date");
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, DemoData.class).includeColumnFiledNames(includeColumnFiledNames).sheet("导出date")
    .doWrite(data());

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
指定写入的列
对象

public class IndexData {
/**
* 导出的excel第二列和第四列将空置
*/
@ExcelProperty(value = “字符串标题”, index = 0)
private String string;
@ExcelProperty(value = “日期标题”, index = 2)
private Date date;
@ExcelProperty(value = “数字标题”, index = 4)
private Double doubleData;
}
1
2
3
4
5
6
7
8
9
10
11
代码

@Test
public void indexWrite() {
String fileName = “indexWrite” + System.currentTimeMillis() + “.xlsx”;
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, IndexData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
复杂头写入
对象

public class ComplexHeadData {
/**
* 主标题 将整合为一个单元格效果如下：
* —————————————————————————
* | 主标题 |
* —————————————————————————
* |字符串标题|日期标题|数字标题|
* —————————————————————————
*/
@ExcelProperty({“主标题”, “字符串标题”})
private String string;
@ExcelProperty({“主标题”, “日期标题”})
private Date date;
@ExcelProperty({“主标题”, “数字标题”})
private Double doubleData;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
代码

@Test
public void complexHeadWrite() {
String fileName = “complexHeadWrite” + System.currentTimeMillis() + “.xlsx”;
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, ComplexHeadData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
自定义格式转换
public class ConverterData {
/**
* 自定义的转换
/
@ExcelProperty(value = “字符串标题”, converter = CustomStringConverter.class)
private String string;
/*
* 我想写到excel 用年月日的格式
/
@DateTimeFormat(“yyyy年MM月dd日 HH时mm分ss秒”)
@ExcelProperty(“日期标题”)
private Date date;
/*
* 我想写到excel 用百分比表示
*/
@NumberFormat("#.##%")
@ExcelProperty(value = “数字标题”)
private Double doubleData;
// getting setting
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
代码

@Test
public void converterWrite() {
String “converterWrite” + System.currentTimeMillis() + “.xlsx”;
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, ConverterData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
图片导出
对象

@Data
@ContentRowHeight(200)
@ColumnWidth(200 / 8)
public class ImageData {
// 图片导出方式有5种
private File file;
private InputStream inputStream;
/**
* 如果string类型 必须指定转换器，string默认转换成string，该转换器是官方支持的
/
@ExcelProperty(converter = StringImageConverter.class)
private String string;
private byte[] byteArray;
/*
* 根据url导出 版本2.1.1才支持该种模式
*/
private URL url;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
代码

@Test
public void imageWrite() throws Exception {
String fileName = “imageWrite” + System.currentTimeMillis() + “.xlsx”;
// 如果使用流 记得关闭
InputStream inputStream = null;
try {
List list = new ArrayList();
ImageData imageData = new ImageData();
list.add(imageData);
String imagePath = “converter” + File.separator + “img.jpg”;
// 放入五种类型的图片 根据实际使用只要选一种即可
imageData.setByteArray(FileUtils.readFileToByteArray(new File(imagePath)));
imageData.setFile(new File(imagePath));
imageData.setString(imagePath);
inputStream = FileUtils.openInputStream(new File(imagePath));
imageData.setInputStream(inputStream);
imageData.setUrl(new URL(
“https://raw.githubusercontent.com/alibaba/easyexcel/master/src/test/resources/converter/img.jpg”));
EasyExcel.write(fileName, ImageData.class).sheet().doWrite(list);
} finally {
if (inputStream != null) {
inputStream.close();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
列宽、行高
对象

@Data
@ContentRowHeight(10)
@HeadRowHeight(20)
@ColumnWidth(25)
public class WidthAndHeightData {
@ExcelProperty(“字符串标题”)
private String string;
@ExcelProperty(“日期标题”)
private Date date;
/**
* 宽度为50,覆盖上面的宽度25
*/
@ColumnWidth(50)
@ExcelProperty(“数字标题”)
private Double doubleData;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
代码

@Test
public void widthAndHeightWrite() {
String fileName = “widthAndHeightWrite” + System.currentTimeMillis() + “.xlsx”;
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, WidthAndHeightData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
合并单元格
代码

@Test
public void mergeWrite() {
String fileName = “mergeWrite” + System.currentTimeMillis() + “.xlsx”;
// 每隔2行会合并 把eachColumn 设置成 3 也就是我们数据的长度，所以就第一列会合并。当然其他合并策略也可以自己写
LoopMergeStrategy loopMergeStrategy = new LoopMergeStrategy(2, 0);
// 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
EasyExcel.write(fileName, DemoData.class).registerWriteHandler(loopMergeStrategy).sheet(“合并单元格”)
.doWrite(data());
}
1
2
3
4
5
6
7
8
9
动态表头
代码

@Test
public void dynamicHeadWrite() {
String fileName = “dynamicHeadWrite” + System.currentTimeMillis() + “.xlsx”;
EasyExcel.write(fileName)
// 这里放入动态头
.head(head()).sheet(“模板”)
// 当然这里数据也可以用 List<List> 去传入
.doWrite(data());
}

// 动态表头的数据格式List<List>
private List<List> head() {
List<List> list = new ArrayList<List>();
List head0 = new ArrayList();
head0.add(“字符串” + System.currentTimeMillis());
List head1 = new ArrayList();
head1.add(“数字” + System.currentTimeMillis());
List head2 = new ArrayList();
head2.add(“日期” + System.currentTimeMillis());
list.add(head0);
list.add(head1);
list.add(head2);
return list;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
web数据写出
代码

@GetMapping(“download”)
public void download(HttpServletResponse response) throws IOException {
response.setContentType(“application/vnd.ms-excel”);
response.setCharacterEncoding(“utf-8”);
// 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
String fileName = URLEncoder.encode(“数据写出”, “UTF-8”);
response.setHeader(“Content-disposition”, “attachment;filename=” + fileName + “.xlsx”);
EasyExcel.write(response.getOutputStream(), DownloadData.class).sheet(“模板”).doWrite(data());
}
1
2
3
4
5
6
7
8
9
六、详解填充样板写入
这里的案例填充都是模板向下，如果需要横向填充只需要模板设置好就可以。

简单的填充
Excel模板

A B C
姓名 数字 复杂
｛ｎａｍｅ｝ ｛ｎｕｍｂｅｒ｝ ｛ｎａｍｅ｝今年｛ｎｕｍｂｅｒ｝岁
Excel最终效果

A B C
姓名 数字 复杂
知春秋 25 知春秋今年25岁
对象

public class FillData {
private String name;
private double number;
// getting setting
}
1
2
3
4
5
代码

@Test
public void simpleFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"{","}"代替
String templateFileName = “simple.xlsx”;

// 方案1 根据对象填充
String fileName = System.currentTimeMillis() + ".xlsx";
// 这里 会填充到第一个sheet， 然后文件流会自动关闭
FillData fillData = new FillData();
fillData.setName("知春秋");
fillData.setNumber(25);
EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(fillData);

// 方案2 根据Map填充
fileName = System.currentTimeMillis() + ".xlsx";
// 这里 会填充到第一个sheet， 然后文件流会自动关闭
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", "知春秋");
map.put("number", 25);
EasyExcel.write(fileName).withTemplate(templateFileName).sheet().doFill(map);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
复杂的填充
使用List集合的方法批量写入数据，点表示该参数是集合

Excel模板

A B C
姓名 数字 复杂
｛.ｎａｍｅ｝ ｛.ｎｕｍｂｅｒ｝ ｛.ｎａｍｅ｝今年｛.ｎｕｍｂｅｒ｝岁
Excel最终效果

A B C
姓名 数字 复杂
知春秋 25 知春秋今年25岁
知春秋 25 知春秋今年25岁
知春秋 25 知春秋今年25岁
知春秋 25 知春秋今年25岁
知春秋 25 知春秋今年25岁
知春秋 25 知春秋今年25岁
代码

@Test
public void complexFill() {
// 模板注意 用{} 来表示你要用的变量 如果本来就有"{","}" 特殊字符 用"{","}"代替
// {} 代表普通变量 {.} 代表是list的变量
String templateFileName = “complex.xlsx”;

String fileName = System.currentTimeMillis() + ".xlsx";
ExcelWriter excelWriter = EasyExcel.write(fileName).withTemplate(templateFileName).build();
WriteSheet writeSheet = EasyExcel.writerSheet().build();
// 这里注意 入参用了forceNewRow 代表在写入list的时候不管list下面有没有空行 都会创建一行，然后下面的数据往后移动。默认 是false，会直接使用下一行，如果没有则创建。
// forceNewRow 如果设置了true,有个缺点 就是他会把所有的数据都放到内存了，所以慎用
// 简单的说 如果你的模板有list,且list不是最后一行，下面还有数据需要填充 就必须设置 forceNewRow=true 但是这个就会把所有数据放到内存 会很耗内存
// 如果数据量大 list不是最后一行 参照下一个
FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
excelWriter.fill(data(), fillConfig, writeSheet);
excelWriter.fill(data(), fillConfig, writeSheet);
// 其他参数可以使用Map封装
Map<String, Object> map = new HashMap<String, Object>();
excelWriter.fill(map, writeSheet);
excelWriter.finish();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
七、API
详细参数介绍
关于常见类解析
Ø EasyExcel 入口类，用于构建开始各种操作

Ø ExcelReaderBuilder ExcelWriterBuilder 构建出一个 ReadWorkbook WriteWorkbook，可以理解成一个excel对象，一个excel只要构建一个

Ø ExcelReaderSheetBuilder ExcelWriterSheetBuilder 构建出一个 ReadSheet WriteSheet对象，可以理解成excel里面的一页,每一页都要构建一个

Ø ReadListener 在每一行读取完毕后都会调用ReadListener来处理数据

Ø WriteHandler 在每一个操作包括创建单元格、创建表格等都会调用WriteHandler来处理数据

Ø 所有配置都是继承的，Workbook的配置会被Sheet继承，所以在用EasyExcel设置参数的时候，在EasyExcel…sheet()方法之前作用域是整个sheet,之后针对单个sheet

读
注解
Ø ExcelProperty 指定当前字段对应excel中的那一列。可以根据名字或者Index去匹配。当然也可以不写，默认第一个字段就是index=0，以此类推。千万注意，要么全部不写，要么全部用index，要么全部用名字去匹配。千万别三个混着用，除非你非常了解源代码中三个混着用怎么去排序的。

Ø ExcelIgnore 默认所有字段都会和excel去匹配，加了这个注解会忽略该字段

Ø DateTimeFormat 日期转换，用String去接收excel日期格式的数据会调用这个注解。里面的value参照java.text.SimpleDateFormat

Ø NumberFormat 数字转换，用String去接收excel数字格式的数据会调用这个注解。里面的value参照java.text.DecimalFormat

Ø ExcelIgnoreUnannotated 默认不加ExcelProperty 的注解的都会参与读写，加了不会参与

参数
通用参数
Ø ReadWorkbook,ReadSheet 都会有的参数，如果为空，默认使用上级。

Ø converter 转换器，默认加载了很多转换器。也可以自定义。

Ø readListener 监听器，在读取数据的过程中会不断的调用监听器。

Ø headRowNumber 需要读的表格有几行头数据。默认有一行头，也就是认为第二行开始起为数据。

Ø head 与clazz二选一。读取文件头对应的列表，会根据列表匹配数据，建议使用class。

Ø clazz 与head二选一。读取文件的头对应的class，也可以使用注解。如果两个都不指定，则会读取全部数据。

Ø autoTrim 字符串、表头等数据自动trim

Ø password 读的时候是否需要使用密码

ReadWorkbook（理解成excel对象）参数
Ø excelType 当前excel的类型 默认会自动判断

Ø inputStream 与file二选一。读取文件的流，如果接收到的是流就只用，不用流建议使用file参数。因为使用了inputStream easyexcel会帮忙创建临时文件，最终还是file

Ø file 与inputStream二选一。读取文件的文件。

Ø autoCloseStream 自动关闭流。

Ø readCache 默认小于5M用 内存，超过5M会使用 EhCache,这里不建议使用这个参数。

ReadSheet（就是excel的一个Sheet）参数
Ø sheetNo 需要读取Sheet的编码，建议使用这个来指定读取哪个Sheet

Ø sheetName 根据名字去匹配Sheet,excel 2003不支持根据名字去匹配

写
注解
Ø ExcelProperty index 指定写到第几列，默认根据成员变量排序。value指定写入的名称，默认成员变量的名字，多个value可以参照快速开始中的复杂头

Ø ExcelIgnore 默认所有字段都会写入excel，这个注解会忽略这个字段

Ø DateTimeFormat 日期转换，将Date写到excel会调用这个注解。里面的value参照java.text.SimpleDateFormat

Ø NumberFormat 数字转换，用Number写excel会调用这个注解。里面的value参照java.text.DecimalFormat

Ø ExcelIgnoreUnannotated 默认不加ExcelProperty 的注解的都会参与读写，加了不会参与

参数
通用参数
Ø WriteWorkbook,WriteSheet ,WriteTable都会有的参数，如果为空，默认使用上级。

Ø converter 转换器，默认加载了很多转换器。也可以自定义。

Ø writeHandler 写的处理器。可以实现WorkbookWriteHandler,SheetWriteHandler,RowWriteHandler,CellWriteHandler，在写入excel的不同阶段会调用

Ø relativeHeadRowIndex 距离多少行后开始。也就是开头空几行

Ø needHead 是否导出头

Ø head 与clazz二选一。写入文件的头列表，建议使用class。

Ø clazz 与head二选一。写入文件的头对应的class，也可以使用注解。

Ø autoTrim 字符串、表头等数据自动trim

WriteWorkbook（理解成excel对象）参数
Ø excelType 当前excel的类型 默认xlsx

Ø outputStream 与file二选一。写入文件的流

Ø file 与outputStream二选一。写入的文件

Ø templateInputStream 模板的文件流

Ø templateFile 模板文件

Ø autoCloseStream 自动关闭流。

Ø password 写的时候是否需要使用密码

Ø useDefaultStyle 写的时候是否是使用默认头

WriteSheet（就是excel的一个Sheet）参数
Ø sheetNo 需要写入的编码。默认0

Ø sheetName 需要些的Sheet名称，默认同sheetNo

WriteTable（就把excel的一个Sheet,一块区域看一个table）参数
Ø tableNo 需要写入的编码。默认0

转载

99学商
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值