SpringBoot系列之集成EasyExcel导入合并行数据

转x33g5p2x  于2022-03-18 转载在 Spring  
字(9.7k)|赞(0)|评价(0)|浏览(1240)

最近在做Excel导入功能，是一种一对多的数据，涉及到合并单元格的，考虑到使用poi去学，要自己去做处理，所以，看看有什么开源的框架，找到两个合适的框架，一个是easypoi是能支持这种的，这个框架提供了特定注解；还有一种是EasyExcel，阿里开源的，不过功能相对没easypoi齐全，比如这种合并单元格数据导入，就没有特定的注解，不过通过搜索资料，是可以实现的，不过要自己写工具类做处理，工具类整理自网上教程

不过在官网看到EasyExcel更专注于性能和易用，虽然功能支持不如easypoi，所以还是想尝试使用一下这个框架。所以，业务比较复杂，可以使用easypoi，业务简单点可以使用easyexcel，图来自EasyExcel官网：

加上easyexcel配置：

  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>easyexcel</artifactId>
  4.     <version>2.2.10</version>
  5. </dependency>

加上ExcelProperty注解，加上value和index，index是excel对应的列

  1. package com.example.easyexcel.model.dto;
  3. import com.alibaba.excel.annotation.ExcelProperty;
  4. import lombok.Data;
  5. import org.hibernate.validator.constraints.Length;
  7. import javax.validation.constraints.NotBlank;
  9. @Data
  10. public class UserExcelDto {
  12.     @ExcelProperty(value = "序号",index = 0)
  13.     @NotBlank(message = "序号必须填！")
  14.     private String seq;
  16.     @ExcelProperty(value = "用户名" ,index = 1)
  17.     @NotBlank(message = "用户名必须填！")
  18.     private String name;
  20.     @ExcelProperty(value = "密码", index = 2)
  21.     @Length(min = 0 , max = 8 , message = "密码最多8位！")
  22.     private String password;
  24.     @ExcelProperty(value = "描述",index = 3)
  25.     private String addressName;
  27.     @ExcelProperty(value = "邮政编码",index = 4)
  28.     private String code;
  31. }
  1. package com.common.excel;
  3. import cn.hutool.core.util.ReflectUtil;
  4. import cn.hutool.core.util.StrUtil;
  5. import cn.hutool.json.JSONUtil;
  6. import com.alibaba.excel.context.AnalysisContext;
  7. import com.alibaba.excel.event.AnalysisEventListener;
  8. import com.alibaba.excel.metadata.CellExtra;
  9. import lombok.extern.slf4j.Slf4j;
  11. import java.util.ArrayList;
  12. import java.util.List;
  14. @Slf4j
  15. public class EasyExcelListener<T> extends AnalysisEventListener<T> {
  17.     private List<T> datas;
  19.     private Integer rowIndex;
  21.     private List<CellExtra> extraMergeInfoList;
  23.     public EasyExcelListener(Integer rowIndex) {
  24.         this.rowIndex = rowIndex;
  25.         datas = new ArrayList<>();
  26.         extraMergeInfoList = new ArrayList<>();
  27.     }
  29.     @Override
  30.     public void invoke(T data, AnalysisContext context) {
  31.         // 是否忽略空行数据，因为自己要做数据校验，所以还是加上，可以根据业务情况使用
  32.         context.readWorkbookHolder().setIgnoreEmptyRow(false);
  33.         ReflectUtil.invoke(data, "setIndex", StrUtil.toString(context.readRowHolder().getRowIndex()));
  34.         datas.add(data);
  35.     }
  37.     @Override
  38.     public void doAfterAllAnalysed(AnalysisContext context) {
  39.         log.info("所有数据解析完成！");
  40.     }
  42.     @Override
  43.     public void extra(CellExtra extra, AnalysisContext context) {
  44.         switch (extra.getType()) {
  45.             case MERGE:
  46.                 if (extra.getRowIndex() >= rowIndex) {
  47.                     extraMergeInfoList.add(extra);
  48.                 }
  49.                 break;
  50.             default:
  51.         }
  52.     }
  54.     public List<T> getData() {
  55.         return datas;
  56.     }
  58.     public List<CellExtra> getExtraMergeInfoList() {
  59.         return extraMergeInfoList;
  60.     }
  62. }
  1. EasyExcel.read(file.getInputStream(), UserExcelDto.class, easyExcelListener)
  2.                 .extraRead(CellExtraTypeEnum.MERGE)
  3.                 .sheet(sheetNo)
  4.                 .headRowNumber(headRowNumber)
  5.                 .doRead();
  6.         
  7. System.out.println(JSONUtil.toJsonPrettyStr(easyExcelListener.getData()));
  8. List<CellExtra> extraMergeInfoList = easyExcelListener.getExtraMergeInfoList();

EasyExcel Merge默认数据读取，这种情况，那些非合并的数据，比如姓名，密码这些数据，只会在第一个附上，框架之后的读取，不能读取到

  1. [
  2.     {
  3.         "code": "510000",
  4.         "password": "********",
  5.         "name": "user1",
  6.         "addressName": "广州天河区",
  7.         "seq": "1"
  8.     },
  9.     {
  10.         "code": "510001",
  11.         "addressName": "广州天河区"
  12.     },
  13.     {
  14.         "code": "510002",
  15.         "password": "***",
  16.         "name": "user2",
  17.         "addressName": "广州天河区",
  18.         "seq": "2"
  19.     }
  20. ]

所以借助网上一个工具类实现，具体参考ExcelMergeHelper

工具类，思路也是读取excel数据，然后读取ExcelProperty注解，注意必须加上index，通过反射机制读取数据

  1. package com.example.easyexcel.core.excel;
  3. import com.alibaba.excel.EasyExcel;
  4. import com.alibaba.excel.annotation.ExcelProperty;
  5. import com.alibaba.excel.enums.CellExtraTypeEnum;
  6. import com.alibaba.excel.metadata.CellExtra;
  7. import com.alibaba.excel.util.CollectionUtils;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  11. import java.lang.reflect.Field;
  12. import java.util.List;
  14. public class ExcelMergeHelper<T> {
  16.     private static final Logger LOGGER = LoggerFactory.getLogger(ExcelMergeHelper.class);
  18.     /**
  19.      * 返回解析后的List
  20.      *
  21.      * @param: fileName 文件名
  22.      * @param: clazz Excel对应属性名
  23.      * @param: sheetNo 要解析的sheet
  24.      * @param: headRowNumber 正文起始行
  25.      * @return java.util.List<T> 解析后的List
  26.      */
  27.     public List<T> getList(String fileName, Class<T> clazz, Integer sheetNo, Integer headRowNumber) {
  28.         UserEasyExcelListener<T> listener = new UserEasyExcelListener<>(headRowNumber);
  29.         try {
  30.             EasyExcel.read(fileName, clazz, listener).extraRead(CellExtraTypeEnum.MERGE).sheet(sheetNo).headRowNumber(headRowNumber).doRead();
  31.         } catch (Exception e) {
  32.             LOGGER.error(e.getMessage());
  33.         }
  34.         List<CellExtra> extraMergeInfoList = listener.getExtraMergeInfoList();
  35.         if (CollectionUtils.isEmpty(extraMergeInfoList)) {
  36.             return listener.getData();
  37.         }
  38.         List<T> data = explainMergeData(listener.getData(), extraMergeInfoList, headRowNumber);
  39.         return data;
  40.     }
  42.     /**
  43.      * 处理合并单元格
  44.      *
  45.      * @param data               解析数据
  46.      * @param extraMergeInfoList 合并单元格信息
  47.      * @param headRowNumber      起始行
  48.      * @return 填充好的解析数据
  49.      */
  50.     public List<T> explainMergeData(List<T> data, List<CellExtra> extraMergeInfoList, Integer headRowNumber) {
  51.         //循环所有合并单元格信息
  52.         extraMergeInfoList.forEach(cellExtra -> {
  53.             int firstRowIndex = cellExtra.getFirstRowIndex() - headRowNumber;
  54.             int lastRowIndex = cellExtra.getLastRowIndex() - headRowNumber;
  55.             int firstColumnIndex = cellExtra.getFirstColumnIndex();
  56.             int lastColumnIndex = cellExtra.getLastColumnIndex();
  57.             //获取初始值
  58.             Object initValue = getInitValueFromList(firstRowIndex, firstColumnIndex, data);
  59.             //设置值
  60.             for (int i = firstRowIndex; i <= lastRowIndex; i++) {
  61.                 for (int j = firstColumnIndex; j <= lastColumnIndex; j++) {
  62.                     setInitValueToList(initValue, i, j, data);
  63.                 }
  64.             }
  65.         });
  66.         return data;
  67.     }
  69.     /**
  70.      * 设置合并单元格的值
  71.      *
  72.      * @param filedValue  值
  73.      * @param rowIndex    行
  74.      * @param columnIndex 列
  75.      * @param data        解析数据
  76.      */
  77.     public void setInitValueToList(Object filedValue, Integer rowIndex, Integer columnIndex, List<T> data) {
  78.         T object = data.get(rowIndex);
  80.         for (Field field : object.getClass().getDeclaredFields()) {
  81.             //提升反射性能，关闭安全检查
  82.             field.setAccessible(true);
  83.             ExcelProperty annotation = field.getAnnotation(ExcelProperty.class);
  84.             if (annotation != null) {
  85.                 if (annotation.index() == columnIndex) {
  86.                     try {
  87.                         field.set(object, filedValue);
  88.                         break;
  89.                     } catch (IllegalAccessException e) {
  90.                         LOGGER.error("设置合并单元格的值异常："+e.getMessage());
  91.                     }
  92.                 }
  93.             }
  94.         }
  95.     }
  97.     /**
  98.      * 获取合并单元格的初始值
  99.      * rowIndex对应list的索引
  100.      * columnIndex对应实体内的字段
  101.      *
  102.      * @param firstRowIndex    起始行
  103.      * @param firstColumnIndex 起始列
  104.      * @param data             列数据
  105.      * @return 初始值
  106.      */
  107.     private Object getInitValueFromList(Integer firstRowIndex, Integer firstColumnIndex, List<T> data) {
  108.         Object filedValue = null;
  109.         T object = data.get(firstRowIndex);
  110.         for (Field field : object.getClass().getDeclaredFields()) {
  111.             //提升反射性能，关闭安全检查
  112.             field.setAccessible(true);
  113.             ExcelProperty annotation = field.getAnnotation(ExcelProperty.class);
  114.             if (annotation != null) {
  115.                 if (annotation.index() == firstColumnIndex) {
  116.                     try {
  117.                         filedValue = field.get(object);
  118.                         break;
  119.                     } catch (IllegalAccessException e) {
  120.                         LOGGER.error("设置合并单元格的初始值异常："+e.getMessage());
  121.                     }
  122.                 }
  123.             }
  124.         }
  125.         return filedValue;
  126.     }
  127. }

对数据进行处理：

  1. List<UserExcelDto> data = new ExcelMergeHelper().explainMergeData(easyExcelListener.getData(), extraMergeInfoList, headRowNumber);

封装后的数据，这种数据，我们就可以进行业务处理，过程相对比较麻烦

  1. [
  2.     {
  3.         "code": "510000",
  4.         "password": "********",
  5.         "name": "user1",
  6.         "addressName": "广州天河区",
  7.         "seq": "1"
  8.     },
  9.     {
  10.         "code": "510001",
  11.         "password": "********",
  12.         "name": "user1",
  13.         "addressName": "广州天河区",
  14.         "seq": "1"
  15.     },
  16.     {
  17.         "code": "510002",
  18.         "password": "***",
  19.         "name": "user2",
  20.         "addressName": "广州天河区",
  21.         "seq": "2"
  22.     }
  23. ]
  1. package com.common.excel;
  3. import com.alibaba.excel.annotation.ExcelProperty;
  4. import com.alibaba.excel.metadata.CellExtra;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  8. import java.lang.reflect.Field;
  9. import java.util.List;
  11. public class ExcelMergeHelper<T> {
  13.     private static final Logger LOGGER = LoggerFactory.getLogger(ExcelMergeHelper.class);
  15.     /**
  16.      * 处理合并单元格
  17.      *
  18.      * @param data               解析数据
  19.      * @param extraMergeInfoList 合并单元格信息
  20.      * @param headRowNumber      起始行
  21.      * @return 填充好的解析数据
  22.      */
  23.     public List<T> explainMergeData(List<T> data, List<CellExtra> extraMergeInfoList, Integer headRowNumber) {
  24.         //循环所有合并单元格信息
  25.         extraMergeInfoList.forEach(cellExtra -> {
  26.             int firstRowIndex = cellExtra.getFirstRowIndex() - headRowNumber;
  27.             int lastRowIndex = cellExtra.getLastRowIndex() - headRowNumber;
  28.             int firstColumnIndex = cellExtra.getFirstColumnIndex();
  29.             int lastColumnIndex = cellExtra.getLastColumnIndex();
  30.             //获取初始值
  31.             Object initValue = getInitValueFromList(firstRowIndex, firstColumnIndex, data);
  32.             //设置值
  33.             for (int i = firstRowIndex; i <= lastRowIndex; i++) {
  34.                 for (int j = firstColumnIndex; j <= lastColumnIndex; j++) {
  35.                     setInitValueToList(initValue, i, j, data);
  36.                 }
  37.             }
  38.         });
  39.         return data;
  40.     }
  42.     /**
  43.      * 设置合并单元格的值
  44.      *
  45.      * @param filedValue  值
  46.      * @param rowIndex    行
  47.      * @param columnIndex 列
  48.      * @param data        解析数据
  49.      */
  50.     public void setInitValueToList(Object filedValue, Integer rowIndex, Integer columnIndex, List<T> data) {
  51.         if (!(data.size()>rowIndex))
  52.             return;
  53.         T object = data.get(rowIndex);
  55.         for (Field field : object.getClass().getDeclaredFields()) {
  56.             //提升反射性能，关闭安全检查
  57.             field.setAccessible(true);
  58.             ExcelProperty annotation = field.getAnnotation(ExcelProperty.class);
  59.             if (annotation != null) {
  60.                 if (annotation.index() == columnIndex) {
  61.                     try {
  62.                         field.set(object, filedValue);
  63.                         break;
  64.                     } catch (IllegalAccessException e) {
  65.                         LOGGER.error("设置合并单元格的值异常："+e.getMessage());
  66.                     }
  67.                 }
  68.             }
  69.         }
  70.     }
  72.     /**
  73.      * 获取合并单元格的初始值
  74.      * rowIndex对应list的索引
  75.      * columnIndex对应实体内的字段
  76.      *
  77.      * @param firstRowIndex    起始行
  78.      * @param firstColumnIndex 起始列
  79.      * @param data             列数据
  80.      * @return 初始值
  81.      */
  82.     private Object getInitValueFromList(Integer firstRowIndex, Integer firstColumnIndex, List<T> data) {
  83.         Object filedValue = null;
  84.         T object = data.get(firstRowIndex);
  85.         for (Field field : object.getClass().getDeclaredFields()) {
  86.             //提升反射性能，关闭安全检查
  87.             field.setAccessible(true);
  88.             ExcelProperty annotation = field.getAnnotation(ExcelProperty.class);
  89.             if (annotation != null) {
  90.                 if (annotation.index() == firstColumnIndex) {
  91.                     try {
  92.                         filedValue = field.get(object);
  93.                         break;
  94.                     } catch (IllegalAccessException e) {
  95.                         LOGGER.error("设置合并单元格的初始值异常："+e.getMessage());
  96.                     }
  97.                 }
  98.             }
  99.         }
  100.         return filedValue;
  101.     }
  102. }

本博客代码例子可以在GitHub找到下载链接

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://smilenicky.blog.csdn.net/article/details/123529499

内容来源于网络，如有侵权，请联系作者删除！

Javaspring

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com