使用 EasyExcel 框架实现 Excel 文件的读取和写入操作。EasyExcel 是一个基于 Java 的轻量级、高性能的 Excel 处理框架,能够帮助开发者快速、高效地完成 Excel 文件的读写操作。
EasyExcel 是一个由阿里巴巴开源的 Java 解析、生成 Excel 比较有名的框架。与传统的 Apache POI 和 JExcel 相比,EasyExcel 具有以下优点:
EasyExcel 在解析 07 版 Excel 时,内存占用非常小,即使是大文件也不会出现内存溢出的情况。EasyExcel 的读写性能都很高,且性能随文件大小变化不大。EasyExcel 的 API 设计简单易用,可以让开发者快速上手。EasyExcel 支持自定义转换器、监听器等,满足各种业务需求。EasyExcel 依赖。EasyExcel 读取监听器 DefaultExcelListener。EasyExcelUtil 工具类,封装EasyExcel的同步/异步读取和写入操作。EasyExcel 的使用。项目结构:
src
├── main
│ ├── java
│ │ └── com
│ │ └── ruoyi
│ │ ├── easyexcel
│ │ │ ├── DefaultExcelListener.java
│ │ │ └── EasyExcelWriterFactory.java
│ │ └── utils
│ │ └── easyexcel
│ │ └── EasyExcelUtil.java
│ └── resources
└── test
└── java
└── com
└── ruoyi
└── EasyExcelTest.java
JDK 版本为 1.8 或以上。EasyExcel 读取 Excel 文件时,需要根据实际情况设置 sheetNo 和 headRowNum 参数。EasyExcel 写入 Excel 文件时,可以选择使用模板文件或自定义表头。EasyExcelUtil 工具类时,需要根据实际需求选择同步或异步的读取方式。在pom.xml文件中添加EasyExcel的依赖：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>2.1.6</version>
</dependency>
package com.ruoyi.easyexcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.exception.ExcelDataConvertException;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* excel读取监听器
*/
@Slf4j
public class DefaultExcelListener<T> extends AnalysisEventListener<T> {
private final List<T> rows = new ArrayList();
/**
* 读取excel数据前操作(只有不读取表头数据时才会触发此方法)
*/
@Override
public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
log.info("======================================================");
log.info("解析第一行数据:{}"+ JSON.toJSONString(headMap));
log.info("======================================================");
}
/**
* 读取excel数据操作
* @param object
* @param context
*/
@Override
public void invoke(T object, AnalysisContext context) {
rows.add(object);
log.info("list容量"+rows.size()+"---"+object);
}
/**
* 读取完excel数据后的操作
*/
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
log.info("成功读取【"+ rows.size()+"】条数据");
}
/**
* 在读取excel异常 获取其他异常下会调用本接口。抛出异常则停止读取。如果这里不抛出异常则 继续读取下一行。
*/
@Override
public void onException(Exception exception, AnalysisContext context) {
log.error("解析失败，但是继续解析下一行:{}", exception.getMessage());
if (exception instanceof ExcelDataConvertException) {
ExcelDataConvertException excelDataConvertException = (ExcelDataConvertException)exception;
log.error("第{}行，第{}列解析异常，数据为:{}", excelDataConvertException.getRowIndex(),
excelDataConvertException.getColumnIndex(), excelDataConvertException.getCellData());
}
}
/**
* @return 返回读取excel总数据
*/
public List<T> getRows() {
return rows;
}
}
package com.ruoyi.easyexcel;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import java.io.File;
import java.io.OutputStream;
import java.util.List;
public class EasyExcelWriterFactory {
private int sheetNo = 0;
private ExcelWriter excelWriter = null;
public EasyExcelWriterFactory(OutputStream outputStream) {
excelWriter = EasyExcel.write(outputStream).build();
}
public EasyExcelWriterFactory(File file) {
excelWriter = EasyExcel.write(file).build();
}
public EasyExcelWriterFactory(String filePath) {
excelWriter = EasyExcel.write(filePath).build();
}
public EasyExcelWriterFactory writeModel(Class headClazz, List data, String sheetName) {
excelWriter.write(data, EasyExcel.writerSheet(this.sheetNo++, sheetName).head(headClazz).build());
return this;
}
public EasyExcelWriterFactory write(List<List<String>> head, List data, String sheetName) {
excelWriter.write(data, EasyExcel.writerSheet(this.sheetNo++, sheetName).head(head).build());
return this;
}
public void finish() {
excelWriter.finish();
}
}
package com.ruoyi.utils.easyexcel;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.EasyExcelFactory;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.write.handler.WriteHandler;
import com.ruoyi.easyexcel.EasyExcelWriterFactory;
import org.apache.poi.ss.formula.functions.T;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 注：如果方法中无以下参数，则使用默认值
* Integer sheetNo 默认0读取第一张sheet
* Integer headRowNum 默认1不读取首行，从第二行开始读取
* 返回值return：List<Map<Integer,String>>: Integer:列数 String:列数对应的value
*/
public class EasyExcelUtil {
/**
* 同步无模型读（默认读取sheet0,从第2行开始读）
*
* @param filePath excel文件的绝对路径
*/
public static List<Map<Integer, String>> syncRead(String filePath) {
return EasyExcelFactory.read(filePath).sheet().doReadSync();
}
/**
* 同步无模型读（自定义读取sheetX，从第2行开始读）
*
* @param filePath excel文件的绝对路径
* @param sheetNo sheet页号，从0开始
*/
public static List<Map<Integer, String>> syncRead(String filePath, Integer sheetNo) {
return EasyExcelFactory.read(filePath).sheet(sheetNo).doReadSync();
}
/**
* 同步无模型读（指定sheet和表头占的行数）
*
* @param filePath
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<Map<Integer, String>> syncRead(String filePath, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(filePath).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
}
/**
* 同步无模型读（指定sheet和表头占的行数）
*
* @param inputStream
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<Map<Integer, String>> syncRead(InputStream inputStream, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(inputStream).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
}
/**
* 同步无模型读（指定sheet和表头占的行数）
*
* @param file
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<Map<Integer, String>> syncRead(File file, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(file).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
}
//====================================================无JAVA模型读取excel数据===============================================================
//====================================================将excel数据同步到JAVA模型属性里===============================================================
/**
* 同步按模型读（默认读取sheet0,从第2行开始读）
*
* @param filePath
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
*/
public static List<T> syncReadModel(String filePath, Class clazz) {
return EasyExcelFactory.read(filePath).sheet().head(clazz).doReadSync();
}
/**
* 同步按模型读（默认表头占一行，从第2行开始读）
*
* @param filePath
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
*/
public static List<T> syncReadModel(String filePath, Class clazz, Integer sheetNo) {
return EasyExcelFactory.read(filePath).sheet(sheetNo).head(clazz).doReadSync();
}
/**
* 同步按模型读（指定sheet和表头占的行数）
*
* @param inputStream
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<T> syncReadModel(InputStream inputStream, Class clazz, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(inputStream).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
}
/**
* 同步按模型读（指定sheet和表头占的行数）
*
* @param file
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<T> syncReadModel(File file, Class clazz, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(file).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
}
/**
* 同步按模型读（指定sheet和表头占的行数）
*
* @param filePath
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static List<T> syncReadModel(String filePath, Class clazz, Integer sheetNo, Integer headRowNum) {
return EasyExcelFactory.read(filePath).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
}
/**
* 异步无模型读（默认读取sheet0,从第2行开始读）
*
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param filePath 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncRead(String filePath, AnalysisEventListener<T> excelListener) {
EasyExcelFactory.read(filePath, excelListener).sheet().doRead();
}
/**
* 异步无模型读（默认表头占一行，从第2行开始读）
*
* @param filePath 表头占的行数，从0开始（如果要连表头一起读出来则传0）
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param sheetNo sheet页号，从0开始
*/
public static void asyncRead(String filePath, AnalysisEventListener<T> excelListener, Integer sheetNo) {
EasyExcelFactory.read(filePath, excelListener).sheet(sheetNo).doRead();
}
/**
* 异步无模型读（指定sheet和表头占的行数）
*
* @param inputStream
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncRead(InputStream inputStream, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(inputStream, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 异步无模型读（指定sheet和表头占的行数）
*
* @param file
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncRead(File file, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(file, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 异步无模型读（指定sheet和表头占的行数）
*
* @param filePath
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
* @return
*/
public static void asyncRead(String filePath, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(filePath, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 异步按模型读取（默认读取sheet0,从第2行开始读）
*
* @param filePath
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
*/
public static void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz) {
EasyExcelFactory.read(filePath, clazz, excelListener).sheet().doRead();
}
/**
* 异步按模型读取（默认表头占一行，从第2行开始读）
*
* @param filePath
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
*/
public static void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo) {
EasyExcelFactory.read(filePath, clazz, excelListener).sheet(sheetNo).doRead();
}
/**
* 异步按模型读取
*
* @param inputStream
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncReadModel(InputStream inputStream, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(inputStream, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 异步按模型读取
*
* @param file
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncReadModel(File file, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(file, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 异步按模型读取
*
* @param filePath
* @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
* @param clazz 模型的类类型（excel数据会按该类型转换成对象）
* @param sheetNo sheet页号，从0开始
* @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
*/
public static void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
EasyExcelFactory.read(filePath, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
}
/**
* 无模板写文件
*
* @param filePath
* @param head 表头数据
* @param data 表内容数据
*/
public static void write(String filePath, List<List<String>> head, List<List<Object>> data) {
EasyExcel.write(filePath).head(head).sheet().doWrite(data);
}
/**
* 无模板写文件
*
* @param filePath
* @param head 表头数据
* @param data 表内容数据
* @param sheetNo sheet页号，从0开始
* @param sheetName sheet名称
*/
public static void write(String filePath, List<List<String>> head, List<List<Object>> data, Integer sheetNo, String sheetName) {
EasyExcel.write(filePath).head(head).sheet(sheetNo, sheetName).doWrite(data);
}
/**
* 根据excel模板文件写入文件
*
* @param filePath
* @param templateFileName
* @param headClazz
* @param data
*/
public static void writeTemplate(String filePath, String templateFileName, Class headClazz, List data) {
EasyExcel.write(filePath, headClazz).withTemplate(templateFileName).sheet().doWrite(data);
}
/**
* 根据excel模板文件写入文件
*
* @param filePath
* @param templateFileName
* @param data
*/
public static void writeTemplate(String filePath, String templateFileName, List data) {
EasyExcel.write(filePath).withTemplate(templateFileName).sheet().doWrite(data);
}
/**
* 按模板写文件
*
* @param filePath
* @param headClazz 表头模板
* @param data 数据
*/
public static void write(String filePath, Class headClazz, List data) {
EasyExcel.write(filePath, headClazz).sheet().doWrite(data);
}
/**
* 按模板写文件
*
* @param filePath
* @param headClazz 表头模板
* @param data 数据
* @param sheetNo sheet页号，从0开始
* @param sheetName sheet名称
*/
public static void write(String filePath, Class headClazz, List data, Integer sheetNo, String sheetName) {
EasyExcel.write(filePath, headClazz).sheet(sheetNo, sheetName).doWrite(data);
}
/**
* 按模板写文件
*
* @param filePath
* @param headClazz 表头模板
* @param data 数据
* @param writeHandler 自定义的处理器，比如设置table样式，设置超链接、单元格下拉框等等功能都可以通过这个实现（需要注册多个则自己通过链式去调用）
* @param sheetNo sheet页号，从0开始
* @param sheetName sheet名称
*/
public static void write(String filePath, Class headClazz, List data, WriteHandler writeHandler, Integer sheetNo, String sheetName) {
EasyExcel.write(filePath, headClazz).registerWriteHandler(writeHandler).sheet(sheetNo, sheetName).doWrite(data);
}
/**
* 按模板写文件（包含某些字段）
*
* @param filePath
* @param headClazz 表头模板
* @param data 数据
* @param includeCols 包含字段集合，根据字段名称显示
* @param sheetNo sheet页号，从0开始
* @param sheetName sheet名称
*/
public static void writeInclude(String filePath, Class headClazz, List data, Set<String> includeCols, Integer sheetNo, String sheetName) {
EasyExcel.write(filePath, headClazz).includeColumnFiledNames(includeCols).sheet(sheetNo, sheetName).doWrite(data);
}
/**
* 按模板写文件（排除某些字段）
*
* @param filePath
* @param headClazz 表头模板
* @param data 数据
* @param excludeCols 过滤排除的字段，根据字段名称过滤
* @param sheetNo sheet页号，从0开始
* @param sheetName sheet名称
*/
public static void writeExclude(String filePath, Class headClazz, List data, Set<String> excludeCols, Integer sheetNo, String sheetName) {
EasyExcel.write(filePath, headClazz).excludeColumnFiledNames(excludeCols).sheet(sheetNo, sheetName).doWrite(data);
}
/**
* 多个sheet页的数据链式写入
* ExcelUtil.writeWithSheets(outputStream)
* .writeModel(ExcelModel.class, excelModelList, "sheetName1")
* .write(headData, data,"sheetName2")
* .finish();
*
* @param outputStream
*/
public static EasyExcelWriterFactory writeWithSheets(OutputStream outputStream) {
EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(outputStream);
return excelWriter;
}
/**
* 多个sheet页的数据链式写入
* ExcelUtil.writeWithSheets(file)
* .writeModel(ExcelModel.class, excelModelList, "sheetName1")
* .write(headData, data,"sheetName2")
* .finish();
*
* @param file
*/
public static EasyExcelWriterFactory writeWithSheets(File file) {
EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(file);
return excelWriter;
}
/**
* 多个sheet页的数据链式写入
* ExcelUtil.writeWithSheets(filePath)
* .writeModel(ExcelModel.class, excelModelList, "sheetName1")
* .write(headData, data,"sheetName2")
* .finish();
*
* @param filePath
*/
public static EasyExcelWriterFactory writeWithSheets(String filePath) {
EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(filePath);
return excelWriter;
}
/**
* 多个sheet页的数据链式写入（失败了会返回一个有部分数据的Excel）
* ExcelUtil.writeWithSheets(response, exportFileName)
* .writeModel(ExcelModel.class, excelModelList, "sheetName1")
* .write(headData, data,"sheetName2")
* .finish();
*
* @param response
* @param exportFileName 导出的文件名称
*/
public static EasyExcelWriterFactory writeWithSheetsWeb(HttpServletResponse response, String exportFileName) throws IOException {
response.setContentType("application/vnd.ms-excel");
response.setCharacterEncoding("utf-8");
// 这里URLEncoder.encode可以防止中文乱码
String fileName = URLEncoder.encode(exportFileName, "UTF-8");
response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(response.getOutputStream());
return excelWriter;
}
}
import com.ruoyi.sends.alisends.service.IAliSendSmsService;
import com.ruoyi.sends.entity.AliSendSmsEntity;
import com.ruoyi.utils.easyexcel.EasyExcelUtil;
import com.ruoyi.easyexcel.EasyExcelWriterFactory;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.*;
public class EasyExcelTest {
@Autowired
private IAliSendSmsService aliSendSmsService;
@Test
public void test8() {
AliSendSmsEntity entity = new AliSendSmsEntity(2L, "abcdefg", "abcdefg", "asdfasdf", "asdfasdfsaf", new Date(), new Date());
AliSendSmsEntity entity1 = new AliSendSmsEntity(22L, "abcdefg", "abcdefg", "asdfasdf", "asdfasdfsaf", new Date(), new Date());
List<AliSendSmsEntity> list = new ArrayList<>();
list.add(entity);
list.add(entity1);
String path = "C:\\Users\\Administrator\\Desktop\\成绩汇总表.xls"; //导出路径
EasyExcelWriterFactory res = EasyExcelUtil.writeWithSheets(path)
.writeModel(AliSendSmsExcel.class, list, "高一成绩表");
res.finish();
}
@Test
public void test1() {
String filePath = "C:\\Users\\Administrator\\Desktop\\成绩汇总表.xls"; //导出路径
List<Map<Integer, String>> data = EasyExcelUtil.syncRead(filePath, 0, 1);
for (Map<Integer, String> obj : data) {
System.out.println(obj);
}
}
}
Excel文件：在桌面上生成名为“成绩汇总表.xls”的Excel文件，包含“高一成绩表”的Sheet页。Excel文件：从指定路径的Excel文件中读取数据并打印到控制台。通过以上步骤，我们实现了使用EasyExcel进行Excel文件的导入和导出功能。
powered by kaifamiao