【导入导出Excel】POI与EasyExcel

一、POI与EasyExcel

1.1、常用场景

1. 将用户信息导出为excel表格（导出数据…)
2. 将Excel表中的信息录入到网站数据库（习题上传…)
   开发中经常会设计到excel的处理，如导出Excel，导入Excel到数据库中!操作Excel目前比较流行的就是Apache POI和阿里巴巴的easyExcel !

1.2、POI

Apache POl是Apache软件基金会的开放源码函式库.POI提供API给Java程序对Microsoft Office格式档案读和写的功能
结构:
HSSF一提供读写Microsoft Excel格式档案的功能。
XSSF一提供读写MicrosoftExcel OoXML洛式档案的功能。
HWPF一提供读写Microsoft word各式档案的功能。
HSLF一提供读写Microsof PowerPoint格式档案的功能。
HDGF一提供读写Microsoft Visio格式档案的功能。

1.3、EasyExcel

EasyExcel是阿里巴巴开源的一个excel处理框架，以使用简单、节省内存著称。
EasyExcel能大大减少占用内存的主要原因是在解析Excel时没有将文件数据一次性全部加载到内存中，而是从磁盘上一行行读取数据，逐个解析。

二、POI

2.1、写入

注意对象的一个区别，文件后缀!|

2.1.1、03版本(xls)[HSSFWorkbook]

    public void testWriter03() throws IOException {
        //1.创建一个工作簿
        Workbook workbook=new HSSFWorkbook();
        //2/创建一个工作表
        Sheet sheet = workbook.createSheet( "Blog阅读统计表");
        //3.创建一个行
        Row row1 = sheet.createRow(0);
        //4.创建一个单元格
        Cell cell11 = row1.createCell(0);//(1,1)
        cell11.setCellValue("今日新增");
        Cell cell12 = row1.createCell(1 );//(1,2)
        cell12.setCellValue(666);
        //第二行
        Row row2 = sheet.createRow(1);
        Cell cell21 = row2.createCell(0);//(2,1)
        cell21.setCellValue("统计时间");
        Cell cell22=row2.createCell(1);//（2,2)
        String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell22.setCellValue(time);
        //输出生成表单
        FileOutputStream fileOutputStream = new FileOutputStream(PATH + "Blog阅读统计表03版本.xls");
        workbook.write(fileOutputStream);
        //关闭流
        fileOutputStream.close();
        System.out.println("Blog阅读统计表03版本   生成完毕!");
    }

2.1.2、07版本(xlsx)[XSSFWorkbook]

 public void testWriter07() throws IOException {
        //1.创建一个工作簿
        Workbook workbook=new XSSFWorkbook();
        //2/创建一个工作表
        Sheet sheet = workbook.createSheet( "Blog阅读统计表");
        //3.创建一个行
        Row row1 = sheet.createRow(0);
        //4.创建一个单元格
        Cell cell11 = row1.createCell(0);//(1,1)
        cell11.setCellValue("今日新增");
        Cell cell12 = row1.createCell(1 );//(1,2)
        cell12.setCellValue(666);
        //第二行
        Row row2 = sheet.createRow(1);
        Cell cell21 = row2.createCell(0);//(2,1)
        cell21.setCellValue("统计时间");
        Cell cell22=row2.createCell(1);//（2,2)
        String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
        cell22.setCellValue(time);
        //输出生成表单
        FileOutputStream fileOutputStream = new FileOutputStream(PATH + "Blog阅读统计表07版本.xlsx");
        workbook.write(fileOutputStream);
        //关闭流
        fileOutputStream.close();
        System.out.println("Blog阅读统计表07版本   生成完毕!");
    }

2.2、大量数据写入

2.2.1、03版本(xls)[HSSFWorkbook]

缺点:最多只能处理65536行，否则会抛出异常
优点:过程中写入缓存，不操作磁盘，最后一次性写入磁盘，速度快

public void testWriter03BigData() throws IOException{
        long begin = System.currentTimeMillis();
        //创建一个薄
        Workbook workbook = new HSSFWorkbook( );
        //创建表
        Sheet sheet = workbook.createSheet();
        //写入数据
        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( "over" ) ;
        FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWriter03BigData.xls");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(double)(end-begin)/1000) ;
    }

超过65536行会报错：
java.lang.IllegalArgumentException: Invalid row number (65536) outside allowable range (0..65535)

2.2.2、07版本(xlsx)

缺点∶写数据时速度非常慢，非常耗内存，也会发生内存溢出，如100万条
优点:可以写较大的数据量，如20万条

public void testWriter07BigData() throws IOException{
        long begin = System.currentTimeMillis();
        //创建一个薄
        Workbook workbook = new XSSFWorkbook();
        //创建表
        Sheet sheet = workbook.createSheet();
        //写入数据
        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( "over" ) ;
        FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWriter07BigData.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(double)(end-begin)/1000) ;

    }

2.2.3、07版本(xlsx)优化

优点:可以写非常大的数据量，如100万条甚至更多条，韦数据速度快,，占用更少的内存
注意:
过程中余产生临时文件,需要清理临时文件（3.9的版本好像不需要了）
默认由100条记录被保存在内存中，如果超过这数量，则最前面的数据被写入临时文件如果想自定义内存中数据的数量，可以使用new sxSSFWorkbook(数量)

    public void testWriter07BigDataS() throws IOException{
        long begin = System.currentTimeMillis();
        //创建一个薄
        Workbook workbook = new SXSSFWorkbook();
        //创建表
        Sheet sheet = workbook.createSheet();
        //写入数据
        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( "over" ) ;
        FileOutputStream fileOutputStream = new FileOutputStream(PATH + "testWriter07BigDataS.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(double)(end-begin)/1000) ;

    }

2.3、读取

2.3.1、03普通数据读取

public void testRead03() throws IOException {
        //获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "Blog阅读统计表03版本.xls");
        //1.创建一个工作簿
        Workbook workbook=new HSSFWorkbook(fileInputStream);
        //2.获取一个工作表
        Sheet sheet = workbook.getSheetAt(0);
        //3.获取行
        Row row = sheet.getRow(0);
        //4.获取列
        Cell cell = row.getCell(0);
        //读取值的时候，一定需要注意类型!
        System.out.println(cell.getStringCellValue());
        fileInputStream.close();
    }

2.3.2、07普通数据读取

public void testRead07() throws IOException {
        //获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "Blog阅读统计表07版本.xlsx");
        //1.创建一个工作簿
        Workbook workbook=new XSSFWorkbook(fileInputStream);
        //2.获取一个工作表
        Sheet sheet = workbook.getSheetAt(0);
        //3.获取行
        Row row = sheet.getRow(0);
        //4.获取列
        Cell cell = row.getCell(0);
        //读取值的时候，一定需要注意类型!
        System.out.println(cell.getStringCellValue());
        fileInputStream.close();
    }

2.3.3、获取不同的数据类型

public void testReadCellType() throws IOException {
        //获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "Blog阅读统计表07版本.xlsx");
        //1.创建一个工作簿
        Workbook workbook=new XSSFWorkbook(fileInputStream);
        //2.获取一个工作表
        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 + "|");
                }
            }
        }
        //获取数据内容
        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.print("["+(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_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(" 【ERROR】 ");
                                break;
                        }
                        System.out.println(cellValue);
                    }
                }
            }
        }
        fileInputStream.close();
    }

2.3.4、计算公式

public void testFormula() throws IOException{
        //获取文件流
        FileInputStream fileInputStream = new FileInputStream(PATH + "Blog阅读统计表07版本.xlsx");
        //1.创建一个工作簿
        Workbook workbook=new XSSFWorkbook(fileInputStream);
        //2.获取一个工作表
        Sheet sheet = workbook.getSheetAt(0);

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

        //拿到计算公司eval
        FormulaEvaluator formulaEvaluator = new XSSFFormulaEvaluator((XSSFWorkbook) 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 string = evaluate.formatAsString();
                System.out.println(string);
                break;
        }
    }

三、EasyExcel

需要三个文件

1. vo
2. Listener
3. 操作类

vo:

@Data
public class DemoData {
        @ExcelProperty("字符串标题")
        private String string;
        @ExcelProperty("日期标题")
        private Date date;
        @ExcelProperty("数字标题")
        private Double doubleData;
        /**
         * 忽略这个字段
         */
        @ExcelIgnore
        private String ignore;
}

3.1、写入

public class EasyTest {

    String PATH="D:\\Code\\EXArea\\EXArea-EasyExcel\\";

    private 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;
    }
    @Test
    public void simplewrite( ) {
        //写法1
        String fileName = PATH +"EasyTest.xlsx";
        //这里需要指定写用哪个class去写,然后写到第一个sheet，名字为模板然后文件流会自动关闭
        //write (fiLeName，格式类)
        //sheet(表名)
        //dowrite(数据)
        EasyExcel.write(fileName, DemoData.class).sheet("模板" ).doWrite(data());
    }
}

3.1、读取

dao:

public class DemoDAO {
    public void save(List<DemoData> list) {
        // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    }
}

DemoDataListener:

public class DemoDataListener implements ReadListener<DemoData> {

    /**
     * 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 100;
    /**
     * 缓存的数据
     */
    private List<DemoData> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
    /**
     * 假设这个是一个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
     * @param context
     */
    //AnaLysisContext分析上下文
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        System.out.println(JSON.toJSONString(data));
        cachedDataList.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (cachedDataList.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
        }
    }

    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        log.info("所有数据解析完成！");
    }

    /**
     * 加上存储数据库
     */
    private void saveData() {
        log.info("{}条数据，开始存储数据库！", cachedDataList.size());
        demoDAO.save(cachedDataList);
        log.info("存储数据库成功！");
    }
}

操作类：

public class EasyTest {

    String PATH="D:\\Code\\EXArea\\EXArea-EasyExcel\\";
    @Test
    public void simpleRead() {
        String fileName = PATH +"EasyTest.xlsx";
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        // 这里每次会读取100条数据 然后返回过来 直接调用使用数据就行
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
    }
}