Java处理Excel文件工具包-easyexcel使用详解

傷城~ 2022-03-16 12:18 594阅读 0赞

https://github.com/alibaba/easyexcel

由于项目需要对大量Excel数据进行输入输出处理，在使用JXL，POI后发现很容易出现OOM，最后在网上找到阿里的开源项目EasyExcel能很快速的读取写入超大Excel文件。经过大量的调试优化，现通过JAVA生成104万行20列的数据并写入到Excel文件的Sheet中只需要70秒的时间。

以下为本工程代码：

如果是maven工程在pom.xml中加入以下内容： 

  1.    <dependency>
  3.            <groupId>com.google.guava</groupId>
  5.            <artifactId>guava</artifactId>
  7.            <version>27.0-jre</version>
  9.        </dependency>
  11.        <dependency>
  13.            <groupId>com.alibaba</groupId>
  15.            <artifactId>easyexcel</artifactId>
  17.            <version>1.1.2-beta5</version>
  19.        </dependency>

工具包封装

  1. package utils;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Map.Entry;
  14. import com.alibaba.excel.EasyExcelFactory;
  15. import com.alibaba.excel.ExcelReader;
  16. import com.alibaba.excel.ExcelWriter;
  17. import com.alibaba.excel.context.AnalysisContext;
  18. import com.alibaba.excel.event.AnalysisEventListener;
  19. import com.alibaba.excel.metadata.BaseRowModel;
  20. import com.alibaba.excel.metadata.Sheet;
  22. import com.google.common.base.Splitter;
  23. import com.google.common.base.Strings;
  24. import com.google.common.collect.Lists;
  25. import com.google.common.collect.Maps;
  26. import org.slf4j.Logger;
  27. import org.slf4j.LoggerFactory;
  29. /**
  30.  * @author zhao.yingchao
  31.  * @date 2019-02-27
  32.  * @since v1.0.0
  33.  */
  35. public class EasyExcelUtil {
  36.     private static final Logger LOGGER = LoggerFactory.getLogger(EasyExcelUtil.class);
  38.     /**
  39.      * 通过String类,读取工作表数据
  40.      *
  41.      * @param filePath 文件路径
  42.      * @return 数据集
  43.      */
  44.     public static Map<String, List<List<String>>> readExcelByString(String filePath) {
  45.         return readExcelByString(filePath, null);
  46.     }
  48.     /**
  49.      * 通过String类,读取工作表数据
  50.      *
  51.      * @param filePath  文件路径
  52.      * @param sheetName sheetName
  53.      * @return 数据集合
  54.      */
  55.     public static Map<String, List<List<String>>> readExcelByString(String filePath, String sheetName) {
  56.         // 创建返回信息
  57.         Map<String, List<List<String>>> dataListMap;
  58.         // 解析监听器
  59.         StringExcelListener excelListener = new StringExcelListener();
  60.         InputStream inputStream = null;
  61.         try {
  62.             // 创建文件流
  63.             inputStream = new FileInputStream(filePath);
  64.             dataListMap = readExcelByStringFromInputStream(inputStream, sheetName);
  66.         } catch (Exception e) {
  67.             throw new EasyExcelException("readExcelByModel from filePath failed." + e, e);
  68.         } finally {
  69.             // 关闭文件流
  70.             try {
  71.                 if (null != inputStream) {
  72.                     inputStream.close();
  73.                 }
  74.             } catch (IOException e) {
  75.                 LOGGER.error("inputStream.close failed!", e);
  76.             }
  77.         }
  78.         return dataListMap;
  79.     }
  81.     /**
  82.      * 通过String类,读取工作表数据
  83.      *
  84.      * @param inputStream 文件流
  85.      * @param sheetName   sheetName
  86.      * @return 数据集合
  87.      */
  88.     public static Map<String, List<List<String>>> readExcelByStringFromInputStream(InputStream inputStream,
  89.                                                                                    String sheetName) {
  90.         // 创建返回信息
  91.         Map<String, List<List<String>>> dataListMap = Maps.newLinkedHashMap();
  92.         // 解析监听器
  93.         StringExcelListener excelListener = new StringExcelListener();
  94.         try {
  95.             // 创建文件流
  96.             ExcelReader excelReader = EasyExcelFactory.getReader(inputStream, excelListener);
  97.             // 得到所有工作表
  98.             List<Sheet> sheets = excelReader.getSheets();
  99.             // 取所有工作表数据
  100.             for (Sheet sheet : sheets) {
  101.                 // 工作表名称
  102.                 String currentSheetName = sheet.getSheetName();
  103.                 // 没有指定工作表，或多个工作表
  104.                 if (Strings.isNullOrEmpty(sheetName) || Splitter.on(',').trimResults().omitEmptyStrings().splitToList(
  105.                     sheetName).contains(currentSheetName)) {
  106.                     // 读取Excel数据
  107.                     excelReader.read(sheet);
  108.                     // 返回明细数据
  109.                     List<List<String>> sheetDataInfo = Lists.newArrayList(excelListener.getDataList());
  110.                     // 将工作表数据放入工作薄
  111.                     dataListMap.put(currentSheetName, sheetDataInfo);
  112.                     // 清除缓存数据
  113.                     excelListener.clear();
  114.                 }
  115.             }
  117.         } catch (Exception e) {
  118.             throw new EasyExcelException("readExcelByStringFromInputStream from inputStream failed." + e, e);
  119.         }
  120.         return dataListMap;
  121.     }
  123.     /**
  124.      * 通过Model类,读取工作表数据
  125.      *
  126.      * @param filePath 文件路径
  127.      * @param clazz    BaseRowModel
  128.      * @return 数据集合
  129.      */
  130.     public static Map<String, List<? extends BaseRowModel>> readExcelByModel(String filePath,
  131.                                                                              Class<? extends BaseRowModel> clazz) {
  132.         return readExcelByModel(filePath, null, clazz);
  133.     }
  135.     /**
  136.      * 通过Model类,读取工作表数据
  137.      *
  138.      * @param file  文件
  139.      * @param clazz BaseRowModel
  140.      * @return 数据集合
  141.      */
  142.     public static Map<String, List<? extends BaseRowModel>> readExcelByModel(File file,
  143.                                                                              Class<? extends BaseRowModel> clazz) {
  144.         return readExcelByModel(file, null, clazz);
  145.     }
  147.     /**
  148.      * 通过Model类,读取工作表数据
  149.      *
  150.      * @param filePath  文件路径
  151.      * @param sheetName sheetName
  152.      * @param clazz     BaseRowModel
  153.      * @return 数据集合
  154.      */
  155.     public static List<? extends BaseRowModel> readExcelByModelSheetName(String filePath, String sheetName,
  156.                                                                          Class<? extends BaseRowModel> clazz) {
  157.         Map<String, List<? extends BaseRowModel>> dataListMap = readExcelByModel(filePath, sheetName, clazz);
  158.         return dataListMap.getOrDefault(sheetName, null);
  159.     }
  161.     /**
  162.      * 通过Model类,读取工作表数据
  163.      *
  164.      * @param file      文件
  165.      * @param sheetName sheetName
  166.      * @param clazz     BaseRowModel
  167.      * @return 数据集合
  168.      */
  169.     public static List<? extends BaseRowModel> readExcelByModelSheetName(File file, String sheetName,
  170.                                                                          Class<? extends BaseRowModel> clazz) {
  171.         Map<String, List<? extends BaseRowModel>> dataListMap = readExcelByModel(file, sheetName, clazz);
  172.         return dataListMap.getOrDefault(sheetName, null);
  173.     }
  175.     /**
  176.      * 通过Model类,读取工作表数据
  177.      *
  178.      * @param filePath  文件路径
  179.      * @param sheetName sheetName
  180.      * @param clazz     BaseRowModel
  181.      * @return 数据集合
  182.      */
  183.     public static Map<String, List<? extends BaseRowModel>> readExcelByModel(String filePath, String sheetName,
  184.                                                                              Class<? extends BaseRowModel> clazz) {
  185.         Map<String, List<? extends BaseRowModel>> dataListMap;
  186.         InputStream inputStream = null;
  187.         try {
  188.             // 创建文件流
  189.             inputStream = new FileInputStream(filePath);
  191.             dataListMap = readExcelByModelFromInputStream(inputStream, sheetName, clazz);
  193.         } catch (Exception e) {
  194.             throw new EasyExcelException("readExcelByModel from filePath failed." + e, e);
  195.         } finally {
  196.             // 关闭文件流
  197.             try {
  198.                 if (null != inputStream) {
  199.                     inputStream.close();
  200.                 }
  201.             } catch (IOException e) {
  202.                 LOGGER.error("inputStream.close failed!", e);
  203.             }
  204.         }
  205.         return dataListMap;
  206.     }
  208.     /**
  209.      * 通过Model类,读取工作表数据
  210.      *
  211.      * @param file      文件
  212.      * @param sheetName sheetName
  213.      * @param clazz     BaseRowModel
  214.      * @return 数据集合
  215.      */
  216.     public static Map<String, List<? extends BaseRowModel>> readExcelByModel(File file, String sheetName,
  217.                                                                              Class<? extends BaseRowModel> clazz) {
  218.         Map<String, List<? extends BaseRowModel>> dataListMap;
  219.         InputStream inputStream = null;
  221.         try {
  222.             // 创建文件流
  223.             inputStream = new FileInputStream(file);
  224.             dataListMap = readExcelByModelFromInputStream(inputStream, sheetName, clazz);
  225.             // 关闭文件流
  226.             inputStream.close();
  227.         } catch (Exception e) {
  228.             throw new EasyExcelException("readExcelByModel from File failed." + e, e);
  230.         } finally {
  231.             // 关闭文件流
  232.             try {
  233.                 if (null != inputStream) {
  234.                     inputStream.close();
  235.                 }
  236.             } catch (IOException e) {
  237.                 LOGGER.error("inputStream.close failed!", e);
  238.             }
  239.         }
  240.         return dataListMap;
  241.     }
  243.     /**
  244.      * 通过Model类,读取工作表数据
  245.      *
  246.      * @param inputStream 文件流
  247.      * @param sheetName   sheetName
  248.      * @param clazz       BaseRowModel
  249.      * @return 数据集合
  250.      */
  251.     public static Map<String, List<? extends BaseRowModel>> readExcelByModelFromInputStream(InputStream inputStream,
  252.                                                                                             String sheetName,
  253.                                                                                             Class<?
  254.                                                                                                 extends BaseRowModel> clazz) {
  255.         // 解析每行结果在listener中处理
  256.         // 创建返回信息
  257.         Map<String, List<? extends BaseRowModel>> dataListMap = Maps.newLinkedHashMap();
  258.         // 解析监听器
  259.         ModelExcelListener excelListener = new ModelExcelListener();
  260.         try {
  261.             // 创建文件流
  262.             ExcelReader excelReader = EasyExcelFactory.getReader(inputStream, excelListener);
  264.             // 得到所有工作表
  265.             List<Sheet> sheets = excelReader.getSheets();
  266.             // 取所有工作表数据
  267.             for (Sheet sheet : sheets) {
  268.                 // 工作表名称
  269.                 String currentSheetName = sheet.getSheetName();
  270.                 if (Strings.isNullOrEmpty(sheetName) || Splitter.on(',').trimResults().omitEmptyStrings().splitToList(
  271.                     sheetName).contains(currentSheetName)) {
  272.                     // 设置模板
  273.                     sheet.setClazz(clazz);
  274.                     // 读取Excel数据
  275.                     excelReader.read(sheet);
  276.                     // 返回明细数据
  277.                     List<? extends BaseRowModel> sheetDataInfo = Lists.newArrayList(excelListener.getDataList());
  278.                     // 将工作表数据放入工作薄
  279.                     dataListMap.put(currentSheetName, sheetDataInfo);
  280.                     // 清除缓存数据
  281.                     excelListener.clear();
  283.                 }
  284.             }
  285.         } catch (Exception e) {
  286.             throw new EasyExcelException("readExcelByModel from inputStream failed." + e, e);
  287.         }
  288.         return dataListMap;
  289.     }
  291.     /**
  292.      * 通过String类,将一个sheet写入到一个Excel
  293.      *
  294.      * @param filePath  文件路径
  295.      * @param sheetName sheetName
  296.      * @param dataList  数据集
  297.      */
  298.     public static void writeExcelByString(String filePath, String sheetName, List<List<String>> dataList) {
  299.         // 创建返回信息
  300.         Map<String, List<List<String>>> dataListMap = Maps.newLinkedHashMap();
  301.         // 将工作表放入到Excel中
  302.         dataListMap.put(sheetName, dataList);
  303.         // 输出Excel数据
  304.         writeExcelByString(filePath, dataListMap);
  305.     }
  307.     /**
  308.      * 通过String类,将多个sheet写入到一个Excel
  309.      *
  310.      * @param filePath    文件路径
  311.      * @param dataListMap 数据集
  312.      */
  313.     public static void writeExcelByString(String filePath, Map<String, List<List<String>>> dataListMap) {
  314.         try {
  315.             // 工作表编号
  316.             int sheetNo = 1;
  317.             // 创建文件流
  318.             OutputStream out = new FileOutputStream(filePath);
  319.             ExcelWriter writer = EasyExcelFactory.getWriter(out);
  320.             // 循环写入每个工作表
  321.             for (Entry<String, List<List<String>>> entry : dataListMap.entrySet()) {
  322.                 // 得到工作表名称
  323.                 String sheetName = entry.getKey();
  324.                 // 得到工作表数据
  325.                 List<List<String>> dataList = entry.getValue();
  326.                 // 设置工作表信息
  327.                 Sheet sheet1 = new Sheet(sheetNo++, 1, null, sheetName, null);
  328.                 // 设置开始行为-1
  329.                 sheet1.setStartRow(-1);
  330.                 // 设置自适应宽度
  331.                 sheet1.setAutoWidth(Boolean.TRUE);
  332.                 // 开始写数据
  333.                 writer.write0(dataList, sheet1);
  334.             }
  335.             // 清空缓存
  336.             writer.finish();
  337.             // 关闭文件
  338.             out.close();
  339.         } catch (Exception e) {
  340.             throw new EasyExcelException("writeExcelByString failed." + e, e);
  341.         }
  342.     }
  344.     /**
  345.      * 通过Model类,将一个sheet写入到一个Excel
  346.      *
  347.      * @param filePath  文件路径
  348.      * @param sheetName sheetName
  349.      * @param dataList  数据集
  350.      * @param clazz     BaseRowModel
  351.      */
  352.     public static void writeExcelByModel(String filePath, String sheetName, List<? extends BaseRowModel> dataList,
  353.                                          Class<? extends BaseRowModel> clazz) {
  354.         // 创建返回信息
  355.         Map<String, List<? extends BaseRowModel>> dataListMap = Maps.newLinkedHashMap();
  356.         // 将工作表放入到Excel中
  357.         dataListMap.put(sheetName, dataList);
  358.         // 输出Excel数据
  359.         writeExcelByModel(filePath, dataListMap, clazz);
  360.     }
  362.     /**
  363.      * 通过String类,将多个sheet写入到一个Excel
  364.      *
  365.      * @param filePath    文件路径
  366.      * @param dataListMap 数据集
  367.      * @param clazz       BaseRowModel
  368.      */
  369.     public static void writeExcelByModel(String filePath, Map<String, List<? extends BaseRowModel>> dataListMap,
  370.                                          Class<? extends BaseRowModel> clazz) {
  371.         try {
  372.             // 创建文件流
  373.             OutputStream out = new FileOutputStream(filePath);
  374.             // 写入文件
  375.             writeIntoOutputStream(dataListMap, clazz, out);
  376.             // 关闭文件
  377.             out.close();
  378.         } catch (Throwable e) {
  379.             throw new EasyExcelException("write to file failed." + e, e);
  380.         }
  381.     }
  383.     /**
  384.      * export to byte array.
  385.      *
  386.      * @param sheetName sheetName
  387.      * @param dataList  data
  388.      * @param clazz     BaseRowModel
  389.      * @return return a byte array with data.
  390.      */
  391.     public static byte[] exportByteArray(String sheetName, List<? extends BaseRowModel> dataList,
  392.                                          Class<? extends BaseRowModel> clazz) {
  393.         // 创建返回信息
  394.         Map<String, List<? extends BaseRowModel>> dataListMap = Maps.newLinkedHashMap();
  395.         // 将工作表放入到Excel中
  396.         dataListMap.put(sheetName, dataList);
  398.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  400.         writeIntoOutputStream(dataListMap, clazz, out);
  402.         return out.toByteArray();
  403.     }
  405.     /**
  406.      * export to byte array.
  407.      *
  408.      * @param dataListMap data
  409.      * @param clazz       BaseRowModel
  410.      * @return return a byte array with data.
  411.      */
  412.     public static byte[] exportByteArray(Map<String, List<? extends BaseRowModel>> dataListMap,
  413.                                          Class<? extends BaseRowModel> clazz) {
  414.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  416.         writeIntoOutputStream(dataListMap, clazz, out);
  418.         return out.toByteArray();
  419.     }
  421.     /**
  422.      * 数据写入输出流
  423.      *
  424.      * @param dataListMap  数据
  425.      * @param clazz        BaseRowModel
  426.      * @param outputStream 输出流
  427.      */
  428.     public static void writeIntoOutputStream(Map<String, List<? extends BaseRowModel>> dataListMap,
  429.                                              Class<? extends BaseRowModel> clazz,
  430.                                              OutputStream outputStream) {
  431.         try {
  432.             // 工作表编号
  433.             int sheetNo = 1;
  434.             // 创建文件流
  435.             ExcelWriter writer = EasyExcelFactory.getWriter(outputStream);
  436.             // 循环写入每个工作表
  437.             for (Entry<String, List<? extends BaseRowModel>> entry : dataListMap.entrySet()) {
  438.                 // 得到工作表名称
  439.                 String sheetName = entry.getKey();
  440.                 // 得到工作表数据
  441.                 List<? extends BaseRowModel> dataList = entry.getValue();
  442.                 // 设置工作表信息
  443.                 Sheet sheet1 = new Sheet(sheetNo++, 1, clazz, sheetName, null);
  444.                 // 设置自适应宽度
  445.                 sheet1.setAutoWidth(Boolean.TRUE);
  446.                 // 开始写数据
  447.                 writer.write(dataList, sheet1);
  448.             }
  449.             // 清空缓存
  450.             writer.finish();
  451.         } catch (Throwable e) {
  452.             throw new EasyExcelException("write to OutputStream failed." + e, e);
  453.         }
  455.     }
  457.     /**
  458.      * String类,解析监听器
  459.      */
  460.     private static class StringExcelListener extends AnalysisEventListener<List<String>> {
  461.         /**
  462.          * 自定义用于暂时存储data 可以通过实例获取该值
  463.          */
  464.         private List<List<String>> dataList = Lists.newArrayList();
  466.         @Override
  467.         public void invoke(List<String> rowInfo, AnalysisContext context) {
  468.             // 数据存储到list，供批量处理，或后续自己业务逻辑处理。
  469.             dataList.add(rowInfo);
  470.         }
  472.         @Override
  473.         public void doAfterAllAnalysed(AnalysisContext context) {
  474.             //解析结束销毁不用的资源
  475.         }
  477.         private List<List<String>> getDataList() {
  478.             return dataList;
  479.         }
  481.         private void setDataList(List<List<String>> dataList) {
  482.             this.dataList = dataList;
  483.         }
  485.         private void clear() {
  486.             dataList.clear();
  487.         }
  488.     }
  490.     /**
  491.      * Model类,解析监听器
  492.      */
  493.     private static class ModelExcelListener extends AnalysisEventListener<BaseRowModel> {
  494.         /**
  495.          * 自定义用于暂时存储data 可以通过实例获取该值
  496.          */
  497.         private List<BaseRowModel> dataList = Lists.newArrayList();
  499.         @Override
  500.         public void invoke(BaseRowModel rowInfo, AnalysisContext context) {
  501.             dataList.add(rowInfo);
  502.         }
  504.         /**
  505.          * 解析结束销毁不用的资源
  506.          *
  507.          * @param context AnalysisContext
  508.          */
  509.         @Override
  510.         public void doAfterAllAnalysed(AnalysisContext context) {
  511.             //解析结束销毁不用的资源
  512.         }
  514.         /**
  515.          * 获取
  516.          *
  517.          * @return 返回sheet数据
  518.          */
  519.         private List<? extends BaseRowModel> getDataList() {
  520.             return dataList;
  521.         }
  523.         /**
  524.          * 设置sheet数据
  525.          *
  526.          * @param dataList 数据
  527.          */
  528.         private void setDataList(List<BaseRowModel> dataList) {
  529.             this.dataList = dataList;
  530.         }
  532.         /**
  533.          * 清空数据
  534.          */
  535.         private void clear() {
  536.             dataList.clear();
  537.         }
  538.     }
  540.     /**
  541.      * EasyExcelException
  542.      */
  543.     public static class EasyExcelException extends RuntimeException {
  545.         private static final long serialVersionUID = -5456062088984840434L;
  547.         public EasyExcelException() {
  548.             super();
  549.         }
  551.         public EasyExcelException(String message) {
  552.             super(message);
  553.         }
  555.         public EasyExcelException(String message, Throwable cause) {
  556.             super(message, cause);
  557.         }
  559.         public EasyExcelException(Throwable cause) {
  560.             super(cause);
  561.         }
  562.     }
  564. }

样例：

  1. /**
  2.  * Excel模型
  3.  *
  4.  * @author zhao.yingchao
  5.  * @date 2019年02月27日
  6.  * @since v1.0.0
  7.  */
  8. @Data
  9. public class Test extends BaseRowModel {
  11.     @ExcelProperty(value = "姓名", index = 0)
  12.     private String name;
  14.     @ExcelProperty(value = "年龄", index = 1)
  15.     private String age;
  16.     @ExcelProperty(value = "手机号", index = 2)
  17.     private String phoneNum;
  19. }

使用：

  1. /**
  2.  * @author zhao.yingchao
  3.  * @date 2019-02-27
  4.  * @since v1.0.0
  5.  */
  6. public class EasyExcelUtilTest {
  8.     @Test
  9.     public void test_parse_excel() {
  10.         Resource resource = new ClassPathResource("file/list1W.xlsx");
  11.         try {
  12.             long startTime = MonitorUtil.startLogInfo("parse begin");
  13.             List<Test> list = (List<Test>)EasyExcelUtil.readExcelByModelSheetName(resource.getFile(),
  14.                 "Sheet1",
  15.                 Test.class);
  16.             MonitorUtil.endLogInfo(startTime, "parse end");
  17.             Assert.assertEquals(list.size(), 10000);
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  21.     }
  22. }

使用问题请与我反馈，谢谢

发表评论

表情：
评论列表 （有 0 条评论，594人围观）

还没有评论，来说两句吧...

相关阅读