Excel和读写和文件的读写没有本质的区别,都是属于IO *** 作,我们使用原生的IO就能解决Excel的导入和导出,当然 *** 作起来比较麻烦,性能也不高,这次我们就学习poi和easyExcel(它们都属于第三方工具)的方式去基于Java和Mysql数据库导入导出我们的Excel的数据
poi:Apache
easyExcel:阿里巴巴开源的工具
2 使用常用场景1 将大量的数据导入为excel表格
2 将excel表中的信息录入到数据库(比如习题上传)(也叫批量插入),大大减轻我们人工乃至网站的录入量
开发中经常会涉及到对Excel的处理,如导入Excel,导出Excel到数据库
目前 *** 作excel比较流行的就是Apache POI和阿里巴巴的easyExcel
3 Apache POI官网: https://poi.apache.org
Apache给我们提供的POI不仅可以 *** 作excel格式,对于word,ppt,visio都是提供支持的,而且语法大概类似
HSSF是处理普通的excel的
XSSF是处理OOXML格式的excel的
值得注意点是,虽然HSSF和XSSF都可以处理excel,但是还是有差距
比如excel主要有两个版本 03版和07版,其中03版的行数最多只能存65535行,07版的是没有限制的
如果想要 *** 作Word,那么使用HWPF
如果想要 *** 作PPT,那么使用HSLF
如果想要 *** 作Visio,那么使用HDGF
原生的POI使用起来比较麻烦,而且量大的时候会报OOM异常(out of memory的简称，称之为内存溢出)，但是现在很多市面上的工具底层也是会使用封装POI的
官网:https://github.com/alibaba/easyexcel
官方文档:https://www.yuque.com/easyexcel/doc/easyexcel
easyExcel是阿里巴巴开源的一个对于excel处理工具(框架)以使用简单,节省内存著称
easyExcel能大大减少内存占用的主要原因是在解析excel中没有将文件数据一次性全部加载到内存中,而是从磁盘上一行一行的读取,逐个解析
由于POI比较原生比较复杂,我们后研发出新的(工具)框架easyExcel,它是阿里巴巴退出的对于POI的后续产品,并且对POI做了升级和优化，不会因为excel数据量过大引起oom异常(内存溢出),使我们用起来更加的方便(读写Excel只需要一行代码！)
主要在于内存和 *** 作过程
比如我们现在excel表有100W数据
1 poi是先把数据加载到内存,如果我们内存比较小，Java是会直接报OOM内存溢出异常,这时候就会有问题,但是easyExcel它就比较简单只能,就算读写100W行数据,会一行一行的读写,不会直接全部解析
2poi会一次性全部读取和返回execl表格的数据,但是easyExcel不会这样,它没有将文件数据一次性全部加载到内存中,而是从磁盘上一行一行的读取,逐个解析
poi和easyExcel的本质上就是时间和空间的转换,根据我们的需求自行选择即可
1 创建Java项目
2 pom引入依赖
org.apache.poi poi3.9 org.apache.poi poi-ooxml3.9 joda-time joda-time2.10.1 junit junit4.12
3 本地创建两个excel 分别是03版和07版
首先03版,它最多有65536行
但是07版的,是没有限制的
他们对应的后缀也是不一样的,03版本的xls,07版本的是xslx,这意味着 *** 作它们的工具类也不相同.03版本用的是poi,07版用的则是poi-ooxml
4 Java的宗旨就是万物皆对象,我们也要把excel当成我们的一个对象去处理
1 工作薄
首先我们打开的excel就是一个大对象,也叫工作簿,它包括以下内容
2 工作表
每一个sheet也是我们excel对象的属性,也叫工作表,我们肯定是现有工作簿才会有工作表,而且会默认自带sheet,也可以根据我们的需要自行添加sheet工作表
3 行
excel中有很多行,每一行也是我们excel对象的属性(横的叫行,竖的叫列)
4 列
excel中有很多列,每一列也是我们excel对象的属性(横的叫行,竖的叫列)
5 单元格
一行一列有很多个单元格,每一个单元格也是我们excel对象的属性
创建我们的测试类,创建Workbook对象,按着ctrl点进去发现它是一个接口
点击箭头可以看到它的三个实现类
定义工作簿,工作表,行列,单元格,和我们手动创建excel是一样的 *** 作,只不过是用代码来实现
03版本excel IO *** 作写的全部代码如下
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.joda.time.DateTime;
import org.junit.Test;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Date;
public class ExcelWrite03 {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void ExcelWrite03() throws Exception {
//1创建一个工作簿
Workbook workbook=new HSSFWorkbook();
//2创建一个工作表 工作簿里面包含工作表,所以创建工作表要通过工作簿创建
//默认的工作表是没有名字的,需要我们手动赋值,和我们在excel中更改sheet工作表的名称是一样的 *** 作
Sheet sheet=workbook.createSheet("用户表");
//3创建行 行也是在我们的表中存在的,所以需要用到表来创建
//默认从0开始 也就是第一行
Row row1 = sheet.createRow(0);
//创建单元格 第一行的第一个数据 用坐标表示为(1,1)
Cell cell11 = row1.createCell(0);
//创建单元格 第一行的第二个数据 用坐标表示为(1,2)
Cell cell12 = row1.createCell(1);
//给单元格赋值
cell11.setCellValue("姓名");
cell12.setCellValue("魏一鹤");
//创建第二行
Row row2=sheet.createRow(1);
//创建第二行的第一列
Cell cell21 = row2.createCell(0);
Cell cell22 = row2.createCell(1);
//给单元格赋值（2.1）
cell21.setCellValue("出生日期");
//创建时间并且格式化
String s = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
//给单元格赋值（2.2）
cell22.setCellValue(s);
//生成一张表 其实就是IO流 *** 作 03版本就是使用xls文件结尾
FileOutputStream fileOutputStream = new FileOutputStream(path + "用户测试03.xls");
//输出工作簿
workbook.write(fileOutputStream);
//关闭流
fileOutputStream.close();
System.out.println("用户测试03.xls生成完毕");
}
}
运行后发现,会在项目本地生成我们定义的excel,打开查看
03版和07版的区别如下
1 03版本有最大长度现在 07版本没有
2 03版本后缀xls 07版本后缀xlsx
3 03版本使用的工具是HSSF,07版本使用的是XSSF
5 大数据绕导入导出(批量)
真实开发中,大多数就是大数据批量导入或者导出excel
大文件写HSSF
缺点:最多只能处理65536行,否则会报内存溢出异常
优点:过程中写入缓存,不 *** 作磁盘,最后一次性写入磁盘,速度快
大文件写XSSF
缺点:写数据时速度非常慢,非常消耗内存,也会发生内存溢出,比如100万条
优点:可以写较大的数据量,比如20万条
03版本HSSF循环导入65536行数据(03版本最大行就是65536)
03版本HSSF循环插入65536条
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.junit.Test;
import java.io.FileOutputStream;
public class BigDateExcelWrite03 {
//全局路径,供我们 *** 作使用方便
static String path = "D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite03() throws Exception {
//开始时间 用于计算时间差
long beginTime = System.currentTimeMillis();
//创建工作簿 03版本使用HSSF
Workbook workbook = new HSSFWorkbook();
//创建工作表 这里就不给它命令了 按照默认的来
Sheet sheet = workbook.createSheet();
//写入数据 循环插入65536行数据,03版的HSSF最多只能插入65536行
for (int rowNum = 0; rowNum < 65536; rowNum++) {
//循环创建行
Row row = sheet.createRow(rowNum);
for(int cellNum=0;cellNum<10;cellNum++){
//循环插入列
Cell cell = row.createCell(cellNum);
//循环设置值
cell.setCellValue(cellNum);
}
}
System.out.println("生成excel表完毕");
//03版本的后缀是xls
//开启文件流
FileOutputStream fileOutputStream = new FileOutputStream(path + "BigDateExcelWrite03.xlsx");
//开始写excel
workbook.write(fileOutputStream);
//关闭流
fileOutputStream.close();
//结束时间
long endTime = System.currentTimeMillis();
//输出花费的时间
System.out.println("花费的时间:"+(double)(endTime - beginTime)/1000);
}
}
运行发现excel已经创建成功,速度也非常的快
打开查看
已知03版本xls最多存65536行,那么如果我们循环插入65537行会怎么样呢? 保留源代码,循环最大值设置为65537
再次运行发现会报错
java.lang.IllegalArgumentException: Invalid row number (65536) outside allowable range (0..65535)
07版本XSSF循环插入65536条
把后缀改为xlsx,把HSSF缓存XSSF即可
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;
import java.io.FileOutputStream;
public class BigDateExcelWrite07 {
//全局路径,供我们 *** 作使用方便
static String path = "D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite07() throws Exception {
//开始时间 用于计算时间差
long beginTime = System.currentTimeMillis();
//创建工作簿 07版本的使用XSSF
Workbook workbook = new XSSFWorkbook();
//创建工作表 这里就不给它命令了 按照默认的来
Sheet sheet = workbook.createSheet();
//写入数据 循环插入65536行数据,03版的HSSF最多只能插入65536行
for (int rowNum = 0; rowNum < 65536; rowNum++) {
//循环创建行
Row row = sheet.createRow(rowNum);
for(int cellNum=0;cellNum<10;cellNum++){
//循环插入列
Cell cell = row.createCell(cellNum);
//循环设置值
cell.setCellValue(cellNum);
}
}
System.out.println("生成excel表完毕");
//037版本的后缀是xlsx
//开启文件流
FileOutputStream fileOutputStream = new FileOutputStream(path + "BigDateExcelWrite07.xlsx");
//开始写excel
workbook.write(fileOutputStream);
//关闭流
fileOutputStream.close();
//结束时间
long endTime = System.currentTimeMillis();
//输出花费的时间
System.out.println("花费的时间:"+(double)(endTime - beginTime)/1000);
}
}
虽然也运行成功,但是可以明显感觉到速度不如03版HSSF,但是可以存更多的数据
打开excel查看发现数据到了65536停并没有结束,说明07版本XSSF上限不是65536,是可以存储更多的,可以写更多的数据
如果我们正在查看同一个文件,但是又进行其他 *** 作,就会出现以下错误,我们把我们正在查看的文件关闭让它运行,等运行结束后再次打开即可
java.io.FileNotFoundException: D:ToolsJavaWorkSpaceJavaExeclBigDateExcelWrite07.xlsx (另一个程序正在使用此文件，进程无法访问。)
07版本XSSF导入100000条数据,把循环数改为100000即可
既然XSSF可以存这么多数据,但是速度比较慢,有没有方法可以优化效率呢(缓存,这个问题也可以叫做如何给poi加速
它就是Workbook接口三个实现类之一的SXSSFWorkbook,其他的两个我们上面都有 *** 作过
这时候需要用到我们的SXSSF
优点:可以写非常大的数据量.如100万条甚至更多,写速度非常快,占用更少的
注意
1 过程中会产生临时文件,需要清理临时文件
2 默认由100条记录被保存在内存中,如果超过这数量,则最前面的数据被写入临时文件,当然缓存数量也可以自定义
3 如果自定义内存中数据的数量,可以使用new SXSSFWorkbook(数量)
SXSSF循环插入100000条数据
package com.wyh.Test;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;
import java.io.FileOutputStream;
public class BigDateExcelWrite07Super {
//全局路径,供我们 *** 作使用方便
static String path = "D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite07Super() throws Exception {
//开始时间 用于计算时间差
long beginTime = System.currentTimeMillis();
//创建工作簿 07版本的使用XSSF
Workbook workbook = new SXSSFWorkbook();
//创建工作表 这里就不给它命令了 按照默认的来
Sheet sheet = workbook.createSheet();
//写入数据 循环插入65536行数据,03版的HSSF最多只能插入65536行
for (int rowNum = 0; rowNum < 100000; rowNum++) {
//循环创建行
Row row = sheet.createRow(rowNum);
for(int cellNum=0;cellNum<10;cellNum++){
//循环插入列
Cell cell = row.createCell(cellNum);
//循环设置值
cell.setCellValue(cellNum);
}
}
System.out.println("生成excel表完毕");
//037版本的后缀是xlsx
//开启文件流
FileOutputStream fileOutputStream = new FileOutputStream(path + "BigDateExcelWrite07Super.xlsx");
//开始写excel
workbook.write(fileOutputStream);
//关闭流
fileOutputStream.close();
//由于SXSSF会产生临时文件,这里我们需要清除下临时文件
((SXSSFWorkbook) workbook).dispose();
//结束时间
long endTime = System.currentTimeMillis();
//输出花费的时间
System.out.println("花费的时间:"+(double)(endTime - beginTime)/1000);
}
}
运行发现,excel也正常生成了,但是它(SXSSF)的速度比XSSF快的多
查看我们的super
这就是我们的临时文件,随着我们把文件的关闭,临时文件也会随之消失
1 03版poi excel读
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
public class BigDateExcelRead03 {
//全局路径,供我们 *** 作使用方便
static String path = "D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite03() throws Exception {
//需要读取,肯定需要流 所以这边我们创建流
FileInputStream filterInputStream = new FileInputStream(path+"用户测试03.xls");
// 1 创建工作簿 使用excel可以完成的 *** 作这边通过poi都可以完成
//把我们的流放在工作簿用 用于读取excel数据
Workbook workbook = new HSSFWorkbook(filterInputStream);
//2 获取工作表 可以通过名称和下标获取工作表 这边使用下标获取 0就是第一个工作表
Sheet sheet = workbook.getSheetAt(0);
//行列组成单元格
//3 获取行 下标为0就是第一个
Row row = sheet.getRow(0);
//4 获取列 下标为0就是第一个
Cell cell1 = row.getCell(0);
Cell cell2 = row.getCell(1);
//获取单元格内容
// cell 有很多方法,获取不同的数据需要用到不同的方法getStringCellValue获取字符串
//读取值的时候 一定要只要数据类型 根据不同的数据类型使用不同的方法
String stringCellValue = cell1.getStringCellValue();
double numericCellValue = cell2.getNumericCellValue();
System.out.println(stringCellValue);
System.out.println(numericCellValue);
//关闭流
filterInputStream.close();
}
}
2 07版poi excel读
只需要把引用对象(XSSF)和后缀(xlsx)改变即可
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;
import java.io.FileInputStream;
public class BigDateExcelRead07 {
//全局路径,供我们 *** 作使用方便
static String path = "D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite07() throws Exception {
//需要读取,肯定需要流 所以这边我们创建流
FileInputStream filterInputStream = new FileInputStream(path+"用户测试07.xlsx");
// 1 创建工作簿 使用excel可以完成的 *** 作这边通过poi都可以完成
//把我们的流放在工作簿用 用于读取excel数据
Workbook workbook = new XSSFWorkbook(filterInputStream);
//2 获取工作表 可以通过名称和下标获取工作表 这边使用下标获取 0就是第一个工作表
Sheet sheet = workbook.getSheetAt(0);
//行列组成单元格
//3 获取行 下标为0就是第一个
Row row = sheet.getRow(0);
//4 获取列 下标为0就是第一个
Cell cell1 = row.getCell(0);
Cell cell2 = row.getCell(1);
//获取单元格内容
// cell 有很多方法,获取不同的数据需要用到不同的方法getStringCellValue获取字符串
//读取值的时候 一定要只要数据类型 根据不同的数据类型使用不同的方法
String stringCellValue1 = cell1.getStringCellValue();
String stringCellValue2 = cell2.getStringCellValue();
System.out.println(stringCellValue1);
System.out.println(stringCellValue2);
//关闭流
filterInputStream.close();
}
}
首先准备一个多种数据类型的excel
获取全部表头信息
row.getPhysicalNumberOfCells() //获取全部的列并返回行数
获取全部表头数并且打印输出
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.Test;
import javax.sql.RowSet;
import java.io.FileInputStream;
public class ReadManyInfo {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite07() throws Exception {
//需要读取,肯定需要流 所以这边我们创建流
FileInputStream filterInputStream = new FileInputStream(path+"会员消费商品明细表.xls");
// 1 创建工作簿 使用excel可以完成的 *** 作这边通过poi都可以完成
//把我们的流放在工作簿用 用于读取excel数据
Workbook workbook = new HSSFWorkbook(filterInputStream);
//2 获取工作表
Sheet sheet = workbook.getSheetAt(0);
//3获取行(表头)
Row rowTitle = sheet.getRow(0); //其实这就是我们的表头 最上面的部分
//判断行不为空才读
if(rowTitle!=null){
//如果行不为空才去读列的信息
//getPhysicalNumberOfCells()获取全部的列并且返回行数
int cellCount = rowTitle.getPhysicalNumberOfCells();
System.out.println("cellCount = " + cellCount);
for (int cellNum = 0; cellNum
打印结果和我们的excel表头内容个数是完全对的上的
获取表中内容
row.getPhysicalNumberOfCells() //获取全部的列
比较复杂的就是不同的数据类型进行判断,我们可以把这些提取成一个公用的方法
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;
import org.junit.Test;
import javax.sql.RowSet;
import java.io.FileInputStream;
import java.util.Date;
public class ReadManyInfo {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void BigDateExcelWrite07() throws Exception {
//需要读取,肯定需要流 所以这边我们创建流
FileInputStream filterInputStream = new FileInputStream(path+"会员消费商品明细表.xls");
switchDataType(filterInputStream);
}
public void switchDataType( FileInputStream filterInputStream ) throws Exception {
// 1 创建工作簿 使用excel可以完成的 *** 作这边通过poi都可以完成
//把我们的流放在工作簿用 用于读取excel数据
Workbook workbook = new HSSFWorkbook(filterInputStream);
//2 获取工作表
Sheet sheet = workbook.getSheetAt(0);
//3获取行(表头)
Row rowTitle = sheet.getRow(0); //其实这就是我们的表头 最上面的部分
//判断行不为空才读
if(rowTitle!=null){
//如果行不为空才去读列的信息
//getPhysicalNumberOfCells()获取全部的列并且返回行数
int cellCount = rowTitle.getPhysicalNumberOfCells();
System.out.println("cellCount = " + cellCount);
for (int cellNum = 0; cellNum
9 计算公式
首先需要准备一个excel
需要获取计算公式eval Formulaevaluator
如果我们用没有计算公式的行,那么不会有用
package com.wyh.Test;
import org.apache.poi.hssf.usermodel.HSSFFormulaevaluator;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class ExcelCalculation {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void testFormula() throws Exception {
//首先还是要获取路径
FileInputStream fileInputStream = new FileInputStream(path + "计算公式.xls");
//读取文件
Workbook workbook = new HSSFWorkbook(fileInputStream);
//读取表
Sheet sheet = workbook.getSheetAt(0);
//根据表拿出数据
//因为我们的需要计算的单元格在第五行 从0开始的 所以下标为4
//如果我们用没有计算公式的行,那么不会有用
Row row = sheet.getRow(4);
//(第一行 4,1)
Cell cell = row.getCell(0);
//拿到计算公式 eval
Formulaevaluator formulaevaluator = new HSSFFormulaevaluator((HSSFWorkbook)workbook);
//输出单元格的内容
//获取类型进行便利
int cellType = cell.getCellType();
switch (cellType){
case Cell.CELL_TYPE_FORMULA://获取公式
String cellFormula = cell.getCellFormula();
System.out.println(cellFormula);
//计算
CellValue evaValue=formulaevaluator.evaluate(cell);
String cellValue = evaValue.formatAsString();
System.out.println(cellValue);
//结束循环
break;
}
}
}
10 easyExcel写
特点:阿里巴巴开源的工具,代码简化,占用内存少,优化OOM(内存溢出异常)
1 pom引入依赖
由于pom底层也是使用的poi进行处理,为了避免冲突,我们把pom引入的pom注释掉
com.alibaba
easyexcel
2.2.0-beta2
2 准备一个实体类 因为easyexcel根据实体类自动生成的表 效率非常的高
package com.wyh.entity;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
@Data
public class DemoData {
@ExcelProperty("字符串标题")
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
@ExcelIgnore
private String ignore;
}
它对应生成的就是这样
3 写一个基本的写入 *** 作
//根据list写入excel
@Test
public void simpleWrite() {
// 写法1 JDK8+
// since: 3.0.0-beta1
//生成的文件名和文件所在位置
String fileName =path+"easyExcel.xlsx";
//开始写入 这里说下几个参数
//1 fileName 是一个io流 自动生成excel
//2 DemoData.class根据哪个类的规则去生成excel
//3 sheetName 生成的表的名字
//4 进行写出,写入到规则就是我们上面定义的方法循环
EasyExcel.write(fileName,DemoData.class).sheet("模板").doWrite(data());
}
完整的代码
package com.wyh.Test;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.wyh.entity.DemoData;
import org.apache.commons.collections4.ListUtils;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class EasyExcelWrite {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
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;
}
//根据list写入excel
@Test
public void simpleWrite() {
// 写法1 JDK8+
// since: 3.0.0-beta1
//生成的文件名和文件所在位置
String fileName =path+"easyExcel.xlsx";
//开始写入 这里说下几个参数
//1 fileName 是一个io流 自动生成excel
//2 DemoData.class根据哪个类的规则去生成excel
//3 sheetName 生成的表的名字
//4 进行写出,写入到规则就是我们上面定义的方法循环
EasyExcel.write(fileName,DemoData.class).sheet("模板").doWrite(data());
}
}
运行完毕之后发现已经生成了,而且和我们想要的数据格式是一样的
11 easyExcel读
1 需要一个实体,我们已经有了,可以直接用上面的DemoData
package com.wyh.entity;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
@Data
public class DemoData {
@ExcelProperty("字符串标题")
private String string;
@ExcelProperty("日期标题")
private Date date;
@ExcelProperty("数字标题")
private Double doubleData;
@ExcelIgnore
private String ignore;
}
2 需要一个监听器
package com.wyh.Test;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.metadata.CellData;
import com.alibaba.excel.metadata.CellExtra;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.fastjson.JSON;
import com.wyh.entity.DemoData;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener {
private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
private static final int BATCH_COUNT = 5;
List list = new ArrayList();
private DemoDAO demoDAO;
public DemoDataListener() {
// 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
demoDAO = new DemoDAO();
}
public DemoDataListener(DemoDAO demoDAO) {
this.demoDAO = demoDAO;
}
@Override
public void invoke(DemoData data, AnalysisContext context) {
System.out.println(JSON.toJSONString(data));
list.add(data);
System.out.println(list);
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
if (list.size() >= BATCH_COUNT) {
saveData();
// 存储完成清理 list
list.clear();
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
// 这里也要保存数据，确保最后遗留的数据也存储到数据库
saveData();
LOGGER.info("所有数据解析完成！");
}
private void saveData() {
demoDAO.save(list);
}
}
3 然后写一个基本的读 *** 作
package com.wyh.Test;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.alibaba.fastjson.JSON;
import com.wyh.entity.DemoData;
import org.apache.commons.collections4.ListUtils;
import org.junit.Test;
import java.io.File;
import java.util.List;
public class EasyExcelRead {
//全局路径,供我们 *** 作使用方便
static String path="D:\Tools\JavaWorkSpace\JavaExecl\";
@Test
public void simpleRead() {
//文件路径
String fileName = path + "easyExcel.xlsx";
//重点注意监听器读取的逻辑
//fileName 文件
//DemoData 类规则
//DemoDataListener 监听器
//sheet().doRead() 表的读取
EasyExcel.read(fileName,DemoData.class,new DemoDataListener()).sheet().doRead();
}
}
启动发现全部数据被正常读取到
4 总结下easyExcel的步骤
1 写入 根据固定的类格式进行写入
2 读取 根据监听器设置规则进行读取
本次poi和easyExcel *** 作excel先到此为止,后续会结合项目写导入导出数据库的真实例子
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）