一、 Poi

POI是Apache软件基金会的，POI为“Poor Obfuscation Implementation”的首字母缩写，意为“简洁版的模糊实现”。
所以POI的主要功能是可以用Java操作Microsoft Office的相关文件。

1 .1 导入依赖

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.17</version>
</dependency>
//下面是07(xlsx)版本的，上面是03(xls)
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.17</version>
</dependency>

1.2 开启读写操作

无非就是对api的充分认识，接下来我们先去了解他的api

 Workbook wordkbook =new HSSFWorkbook();//创建一个Workbook对象
 wordkbook.createSheet();//创建表名，如果不写参数，会有默认值
 Row row1=sheet.createRow(0);//根据里面的数字拿到对应的行，0默认为第一行
 Cell cell = row1.createCell(0);//根据行对象创建单元格，这里0为第一个
 cell.setCellValue("");//可以给单元格赋值

写入一个Excel

package com.example.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.joda.time.DateTime;
import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ExcelWriter {
    
    
    //先要有个路径
    static String path="F:\\demo\\javapoi\\demopoi\\";
    public static void main(String[] args) throws IOException {
    
    
        //1，创建一个工作薄
        Workbook wordkbook =new HSSFWorkbook();
        //表名
        Sheet sheet=wordkbook.createSheet("灰灰统计表");
        //创建行
        Row row1=sheet.createRow(0);
        //4.创建一个单元格
        Cell cell = row1.createCell(0);
        cell.setCellValue("今日新增观众");
        Cell cell2 = row1.createCell(1);
        cell2.setCellValue("卢本伟");

        //创建行
        Row row2=sheet.createRow(1);
        //4.创建一个单元格
        Cell cell3 = row2.createCell(0);
        cell3.setCellValue("统计时间");
        Cell cell24= row2.createCell(1);
        String time=new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell24.setCellValue(time);

        //生成一张表 03是xls 07是xlsx
        FileOutputStream fileOutputStream = new FileOutputStream(path + "灰灰统计表07.xlsx");
       wordkbook.write(fileOutputStream);

       fileOutputStream.close();
        System.out.println("灰灰统计表03已生成");
    }

}

上面写完后会在项目目录下生成一个表格

读取我们所写的表格

这个操作跟上述的写并没有什么不同，不同就是方法是get而不是set

 static String path="F:\\demo\\javapoi\\demopoi";
    @Test
    public void testread03() throws IOException {
    
    


        //Sheet sheet=workbook.createSheet("统计表");
        //sheet操作表中元素
        FileInputStream fileInputStream = new FileInputStream(path + "灰灰统计表03.xls");
        Workbook workbook=new HSSFWorkbook(fileInputStream);
        Sheet sheet = workbook.getSheetAt(0);
        Sheet sheet2 = workbook.getSheet("灰灰统计表");
        Row row = sheet.getRow(1);
        Cell cell = row.getCell(0);
        Cell cell2 = row.getCell(1);
        System.out.println(cell.getStringCellValue());
        System.out.println(cell2.getNumericCellValue());
        fileInputStream.close();
    }

这里值得注意的是，使用表格对象要注意三种创建方式

• POI-HSSF
• POI-XSSF
• SXSSF

HSSF：Excel97-2003版本，扩展名为.xls。一个sheet最大行数65536，最大列数256。

XSSF：Excel2007版本开始，扩展名为.xlsx。一个sheet最大行数1048576，最大列数16384。

SXSSF：是在XSSF基础上，POI3.8版本开始提供的支持低内存占用的操作方式，扩展名为.xlsx。

Excel版本兼容性是向下兼容。

在读取数据的时候我们需要先判断值类型，才能用对应API

下面这个是先拿到表头那一行，相当于数据库的字段

 FileInputStream fileInputStream = new FileInputStream(path + "数据表07.xlsx");
    Workbook workbook=new XSSFWorkbook(fileInputStream);
    Sheet sheet = workbook.getSheetAt(0);
    Row rowTitle = sheet.getRow(0);
    if(rowTitle!=null){
    
    
        int cellCount=rowTitle.getPhysicalNumberOfCells();    //拿到第row行的那一行的总个数
        for (int i = 0; i <cellCount ; i++) {
    
      //循环个数取出
            Cell cell = rowTitle.getCell(i);
            if(cell!=null){
    
              //如果不等于空取出值
                int cellType = cell.getCellType();   //这里是知道我们标题是String，考虑不确定的时候怎么取
                String cellValue = cell.getStringCellValue();
                System.out.print(cellValue+"|");
            }
        }
        System.out.println();
    }

下面接着读取对应的数据，这里就需要我们刚刚讲的类型判断

int cellType=cell.getCellType();利用这个，然后判断它的XSSFCell类型再具体输出

  @Test
public void testCellType() throws Exception {
    
    

//获取文件流
FileInputStream fis = new FileInputStream(PATH +"课题信息表20190701.xlsx");

//创建一个工作簿。使用 excel能操作的这边他都可以操作
Workbook workbook = new XSSFWorkbook(fis);
Sheet sheet = workbook.getSheetAt(0);

//获取标题内容
Row rowTitle = sheet.getRow(0);
if (rowTitle != null) {
    
    
//得到一行有多少列有数据
int cellCount = rowTitle.getPhysicalNumberOfCells();
for (int cellNum = 0; cellNum < cellCount; cellNum++) {
    
    
Cell cell = rowTitle.getCell(cellNum);
if (cell != null) {
    
    
int cellType = cell.getCellType();
String cellValue = cell.getStringCellValue();
System.out.print(cellValue + "|");
}
}
System.out.println();
}

//获取表中的内容
//获取表中有多少行有数据
int rowCount = sheet.getPhysicalNumberOfRows();
for (int rowNum = 1; rowNum < rowCount; rowNum++) {
    
    
Row rowData = sheet.getRow(rowNum);
if (rowData != null) {
    
    
//读取列
int cellCount = rowTitle.getPhysicalNumberOfCells();
for (int cellNum = 0; cellNum < cellCount; cellNum++) {
    
    
System.out.println("[" + (rowNum + 1) + "-" + (cellNum + 1) + "]");

Cell cell = rowData.getCell(cellNum);
//匹配列的数据类型
if (cell != null) {
    
    
int cellType = cell.getCellType();
String cellValue = "";

switch (cellType) {
    
    
case HSSFCell.CELL_TYPE_STRING://字符
System.out.print("【 String】");
cellValue = cell.getStringCellValue();
break;
case HSSFCell.CELL_TYPE_BOOLEAN://布尔
System.out.print("【 BOOLEAN】");
cellValue = String.valueOf(cell.getBooleanCellValue());
break;
case HSSFCell.CELL_TYPE_BLANK://空
System.out.print("【 BLANK】");
break;
case HSSFCell.CELL_TYPE_NUMERIC://数字(日期、普通数字)
System.out.print("【 NUMERIC】");
if (HSSFDateUtil.isCellDateFormatted(cell)) {
    
    // 日期
System.out.print("--【日期】");
Date date = cell.getDateCellValue();
cellValue = new DateTime(date).toString("yyyy-MM-dd");
} else {
    
    
//不是日期格式，防止数字过长！
System.out.print("--【转换为字符串输出】");
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
cellValue = cell.toString();
}
break;
case HSSFCell.CELL_TYPE_ERROR://错误
System.out.print("【 数据类型错误】");
break;
}
System.out.println(cellValue);
}
}
}
}
//关闭流
fis.close();
}

1.3 计算公式

@Test
public void testFormula() throws Exception {
    
    
FileInputStream fis = new FileInputStream(PATH+"公式.xls");
//创建一个工作簿。使用 excel能操作的这边他都可以操作
Workbook workbook = new HSSFWorkbook(fis);
Sheet sheet = workbook.getSheetAt(0);

Row row = sheet.getRow(4);
Cell cell = row.getCell(0);

//拿到计算公司 evaL
FormulaEvaluator FormulaEvaluator = new HSSFFormulaEvaluator((HSSFWorkbook) workbook);

//输出单元格的内容
int cellType = cell.getCellType();
switch (cellType) {
    
    
case Cell.CELL_TYPE_FORMULA://公式
String formula = cell.getCellFormula();
System.out.println(formula);

//计算
CellValue evaluate = FormulaEvaluator.evaluate(cell);
String cellValue = evaluate.formatAsString();
System.out.println(cellValue);
break;
}
}

二、 EasyExcel

这个的出现比poi简单非常多，只需要认清他的对应API就可以进行操作了，即使记不清楚了，我们也可以去网站上在线COPY

https://www.yuque.com/

导入依赖

 //注意它里面自带poi依赖，如果重复带入会报ClassNotfound        
    <dependency>   
        <groupId>com.alibaba</groupId>
        <artifactId>easyexcel</artifactId>
        <version>2.2.0-beta2</version>
    </dependency>

2.1 读写操作

以上面这个表格为例来进行读写操作

2.1.1 写操作

先来个实体类方便插入数据

import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

import java.util.Date;

@Data   //lombok
public class DemoData {
    
    
    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;
    /**
     * 忽略这个字段
     */
    @ExcelIgnore   //注意这个注解是高版本的easyexcel依赖才有
    private String ignore;
}

再来一个工具类方便我们写数据

public class utilList {
    
    
    public static List<DemoData> data() {
    
    
        List<DemoData> list = new ArrayList<DemoData>();
        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;
    }
}

进行写

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

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

写完就有了这样一个表格

扩展知识

重复多次写,根据数据库的分页查询再写入到表格中，这里如果要写到多个表的话，需要建立多个writeSheet对象

@Test
public void repeatedWrite() {
    
    
    // 方法1 如果写到同一个sheet
    String fileName = TestFileUtil.getPath() + "repeatedWrite" + System.currentTimeMillis() + ".xlsx";
    // 这里 需要指定写用哪个class去写
    ExcelWriter excelWriter = EasyExcel.write(fileName, DemoData.class).build();
    // 这里注意 如果同一个sheet只要创建一次
    WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
    // 去调用写入,这里我调用了五次，实际使用时根据数据库分页的总的页数来
    for (int i = 0; i < 5; i++) {
    
    
        // 分页去数据库查询数据 这里可以去数据库查询每一页的数据
        List<DemoData> data = data();
        excelWriter.write(data, writeSheet);
    }
    /// 千万别忘记finish 会帮忙关闭流
    excelWriter.finish();

WEB中的写（重点）

这个方法经常用到，导出Excel，失败的时候返回json

/**
 * 文件下载并且失败的时候返回json（默认失败了会返回一个有部分数据的Excel）
 *
 * @since 2.1.1
 */
@GetMapping("downloadFailedUsingJson")
public void downloadFailedUsingJson(HttpServletResponse response) throws IOException {
    
    
    // 这里注意 有同学反应使用swagger 会导致各种问题，请直接用浏览器或者用postman
    try {
    
    
        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).autoCloseStream(Boolean.FALSE).sheet("模板")
            .doWrite(data());
    } catch (Exception e) {
    
    
        // 重置response
        response.reset();
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        Map<String, String> map = new HashMap<String, String>();
        map.put("status", "failure");
        map.put("message", "下载文件失败" + e.getMessage());
        response.getWriter().println(JSON.toJSONString(map));
    }
}

2.1.2 读操作

首先我们一个监听器，因为和poi的不同，easyExcel是spring接管的，自己监控和改写方法

package com.example.easyExcel;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.example.Dao.DemoDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener<DemoData> {
    
    
    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 5;
    List<DemoData> list = new ArrayList<DemoData>();
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDAO;
    public DemoDataListener() {
    
    
        // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
        demoDAO = new DemoDAO();
    }
    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param demoDAO
     */
    public DemoDataListener(DemoDAO demoDAO) {
    
    
        this.demoDAO = demoDAO;
    }
    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data
     *            one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
    
    
        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));
        System.out.println( JSON.toJSONString(data));
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
    
    
            saveData();
            // 存储完成清理 list
            list.clear();
        }
    }
    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
    
    
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        LOGGER.info("所有数据解析完成！");
    }
    /**
     * 加上存储数据库
     */
    private void saveData() {
    
    
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        demoDAO.save(list);
        LOGGER.info("存储数据库成功！");
    }
}

这里的saveData是为了给读取前台的表格之后可以执行这个然后通过下面的方法持久化到数据库，而且这里默认是5条持久一次

/**
 * 假设这个是你的DAO存储。当然还要这个类让spring管理，当然你不用需要存储，也不需要这个类。
 **/
public class DemoDAO {
    
    
    public void save(List<DemoData> list) {
    
    
        // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    }
}

开始读的操作

 /**
     * 最简单的读
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>3. 直接读即可
     */
    @Test
    public void simpleRead() {
    
    
        String fileName = path + "EasyTest.xlsx";
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
    }

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";
}

三、总结

1. EasyExcel的确比poi方便，但是它的读需要编写监听器
2. 建议大数据量用easyExcel,因为大数据时poi对于内存消耗非常大
3. 由于apache poi和jxl，excelPOI都有一个严重的问题，就是非常消耗内存，特别处理数据量多时，速度慢并且时有异常发生，所以改用由阿里研发的easyExcel更可靠一些,它的官方建议对于1000行以内的采用原来poi的写法一次读写，但于1000行以上的数据，有用了一行行进行解析的方案，这样避免了内存的溢出。
4. EasyExcel扩展功能很多，且Api式调用真的轻松很多