读取Excel文档的两种写法

需用读取Excel文档，所以了解了一下大概做法，并整理如下：
1.使用jxl,创建单元格对象，读取文档内容，优点是代码简单，按行读取，缺点是在智能处理03版本的EXCEL文件，如下 ：
导入依赖：

<!-- https://mvnrepository.com/artifact/net.sourceforge.jexcelapi/jxl -->
        <dependency>
            <groupId>net.sourceforge.jexcelapi</groupId>
            <artifactId>jxl</artifactId>
            <version>2.6.12</version>
        </dependency>

接下来是代码实现，逻辑比较简单就不多说了

import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
 
public class simple {
  public static void main(String[] args) {
    try {
      File file = new File("XXX.xls" +""); // 创建文件对象
      Workbook wb = Workbook.getWorkbook(file); // 从文件流中获取Excel工作区对象（WorkBook）
      Sheet sheet = wb.getSheet(0); // 从工作区中取得页（Sheet）
      for (int i = 0; i < sheet.getRows(); i++) { // 循环打印Excel表中的内容
        for (int j = 0; j < sheet.getColumns(); j++) {
          Cell cell = sheet.getCell(j, i);
          System.out.printf(cell.getContents()+" ");
        }
        System.out.println();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

2.使用阿里巴巴的fastExcel，代码稍微复杂一点，功能多，能处理03和07版本的
我的目录结构如下：

 导入依赖

 <!--EasyExcel-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.2.0-beta2</version>
        </dependency>
 
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>
 
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
 
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
 
        <!--fastJson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>
 
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

根据EXCEL文档表头信息编辑实体类，即pojo中的TableInfo

import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
 
@Data
public class TableInfo {
 
  @ExcelIgnore
  @ExcelProperty("序号")
  private Integer num;
 
  //字段    数据类型    字段标题    字段说明    字段来源
  @ExcelProperty("字段")
  private String fieldName;
 
  @ExcelProperty("数据类型")
  private String dataType;
 
  @ExcelProperty("字段标题")
  private String comment1;
 
  @ExcelProperty("字段说明")
  private String comment2;
 
  @ExcelIgnore
  @ExcelProperty("字段来源")
  private String url;
}

dao层用于处理数据库，如果不需要存储到数据库可以不写具体实现：

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

具体实现代码：

import ExcelRead.dao.TableDao;
import ExcelRead.pojo.TableInfo;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
 
public class TableDataListener extends AnalysisEventListener<TableInfo> {
  private static final Logger LOGGER = (Logger) LoggerFactory.getLogger(TableDataListener.class);
  /**
   * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
   */
  private static final int BATCH_COUNT = 200;
  List<TableInfo> list = new ArrayList<TableInfo>();
  /**
   * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
   */
  private TableDao tableDao;
  public TableDataListener() {
    // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
    tableDao = new TableDao();
  }
  /**
   * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
   *
   * @param tableDao
   */
  public TableDataListener(TableDao tableDao) {
    this.tableDao = tableDao;
  }
  /**
   * 这个每一条数据解析都会来调用
   *
   * @param data
   *            one row value. Is is same as {@link AnalysisContext#readRowHolder()}
   * @param context
   */
  @Override
  public void invoke(TableInfo data, AnalysisContext context) {
    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() {
   // System.out.println("{}条数据，开始存储数据库！"+ list.size());
    tableDao.save(list);
    LOGGER.info("存储数据库成功！");
  }
}

到这里基本就结束了，最后来个测试文件

import ExcelRead.listener.TableDataListener;
import ExcelRead.pojo.TableInfo;
import com.alibaba.excel.EasyExcel;
import org.junit.Test;
 
public class readTest {
  @Test
  public void simpleRead() {
    // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
    String fileName ="XXX.xlsx";
 
    // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
    EasyExcel.read(fileName, TableInfo.class, new TableDataListener()).sheet().doRead();
  }
}