主要对 hutool 的 ExcelUtil._readBySax(_inputStream, 0, rowHandler_)_; API 进行了增强，自定义 RowHandler 实现如下的增强功能：

  1. 解析一行数据，给出一个对象
  2. 自己对某个业务字段判定时，可以获取到该字段在文件中的位置信息，比如第 n 行，n 列
  3. 每个字段转换异常可以获取到详细信息

依赖如下

  1.     implementation 'cn.hutool:hutool-all:5.5.4'
  2.     implementation 'org.apache.poi:poi:4.1.2'
  3.     implementation 'org.apache.poi:poi-ooxml:4.1.2'
  5.     // 数据对象使用了 lombok 注解，可以自行解决不使用
  6.     compileOnly 'org.projectlombok:lombok'
  7.     annotationProcessor 'org.projectlombok:lombok'

工具代码

核心处理器 DataRowHandler

  1. package cn.mrcode.parse.data;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.LinkedHashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.function.Function;
  9. import java.util.function.Supplier;
  10. import java.util.stream.Collectors;
  12. import cn.hutool.core.annotation.Alias;
  13. import cn.hutool.core.convert.Convert;
  14. import cn.hutool.core.util.StrUtil;
  15. import cn.hutool.poi.excel.sax.handler.RowHandler;
  16. import lombok.Data;
  18. /**
  19.  * 通用详细位置的数据行解析
  20.  * <pre>
  21.  *     接受行内容的数据对象, 请继承 DataRowNumber 对象，可以给你提供行号
  22.  *     另外，对象字段使用 cn.hutool.core.annotation.Alias 注解指定对应表头信息，如下所示：
  23.  *     @Alias("客户名称")
  24.  *     private String customerName;
  25.  *   使用方式：ExcelUtil.readBySax(inputStream, 0, rowHandler); 将本对象传递给 rowHandler
  26.  * </pre>
  27.  *
  28.  * @param <T> 接受行内容的数据对象
  29.  * @author mrcode
  30.  * @date 2021/9/16 20:03
  31.  */
  32. public class DataRowHandler<T extends DataRowNumber> implements RowHandler {
  33.     private DataRowFunction<T, Boolean> successFun;
  34.     private Function<DataRowFailMsg, Boolean[]> failFun;
  35.     private Supplier<T> factoryNew;
  37.     private List<String> headers;
  38.     Map<String, FieldItem> fieldItemMap;  // 字段类型映射
  40.     /**
  41.      * @param successFun 当一行数据解析成功时的回调函数，你处理之后，如果需要继续处理，请返回 true，否则返回 false
  42.      * @param failFun    当某行数据的某个字段解析失败时的回调函数，返回两个值：1：决定当前对象剩余字段是否还继续解析，2：当前整个文件解析是否还继续， true
  43.      *                   继续，false 停止; 或则直接返回 null，会继续解析剩余数据
  44.      * @param factoryNew 当需要一个新的行对象时，请返回一个初始化对象
  45.      */
  46.     public DataRowHandler(DataRowFunction<T, Boolean> successFun,
  47.                           Function<DataRowFailMsg, Boolean[]> failFun,
  48.                           Supplier<T> factoryNew) {
  49.         this.successFun = successFun;
  50.         this.failFun = failFun;
  51.         this.factoryNew = factoryNew;
  52.         this.buildFieldItemMap();
  53.     }
  55.     /**
  56.      * 获取该行对应的某个字段信息
  57.      *
  58.      * @param headerName 表头字段的别名
  59.      * @param item       给你的行结果信息，主要为了获取里面的行号
  60.      * @return
  61.      */
  62.     public DataRowFieldInfo getFieldInfo(String headerName, T item) {
  63.         final DataRowFieldInfo fieldInfo = new DataRowFieldInfo();
  64.         fieldInfo.setRowNum(item.getRowNum());
  65.         fieldInfo.setField(headerName);
  67.         // 根据表头字段顺序定位该字段在 excel 中的位置
  68.         for (int i = 0; i < headers.size(); i++) {
  69.             if (headerName.equals(headers.get(i))) {
  70.                 fieldInfo.setPosition(ExcelColumnUtil.excelColIndexToStr(i + 1) + item.getRowNum());
  71.                 break;
  72.             }
  73.         }
  74.         return fieldInfo;
  75.     }
  77.     @Override
  78.     public void handle(int sheetIndex, long rowIndex, List<Object> rowList) {
  79.         // 第 0 行为：表头字段
  80.         if (rowIndex == 0) {
  81.             // 将表头收集起来，后续以此顺序 判定某个字段所在的位置
  82.             headers = rowList.stream().map(Object::toString).collect(Collectors.toList());
  83.             return;
  84.         }
  86.         // 将该行内容与 表头一一对应上
  87.         final int headerSize = headers.size();
  88.         final int rowSize = rowList.size();
  89.         final Map<String, Object> kvMap = new LinkedHashMap<>(headerSize);
  90.         for (int i = 0; i < headerSize; i++) {
  91.             if (i < rowSize) {
  92.                 kvMap.put(headers.get(i), rowList.get(i));
  93.             }
  94.         }
  96.         // 解析该行内容成对象
  97.         T row = parse(rowIndex, kvMap);
  98.         if (!successFun.apply(row, this)) {
  99.             throw new DataRowParseStopException();
  100.         }
  101.     }
  103.     private T parse(long rowIndex, Map<String, Object> kvMap) {
  104.         final long excelRowNum = rowIndex + 1;
  106.         final T row = factoryNew.get();
  107.         row.setRowNum(excelRowNum);
  108.         // 按表头顺序获取内容
  109.         for (int i = 0; i < headers.size(); i++) {
  110.             final String header = headers.get(i);
  111.             final Object valueObject = kvMap.get(header);
  112.             if (valueObject == null || valueObject.toString() == "") {
  113.                 continue;
  114.             }
  115.             final FieldItem fieldItem = fieldItemMap.get(header);
  116.             // 当一行中出现了某个字段是无法识别时，该行解析失败
  117.             if (fieldItem == null) {
  118.                 final DataRowFailMsg dataRowFailMsg = new DataRowFailMsg();
  119.                 dataRowFailMsg.setRowNum(excelRowNum);
  120.                 dataRowFailMsg.setField(header);
  121.                 dataRowFailMsg.setPosition(ExcelColumnUtil.excelColIndexToStr(i + 1) + excelRowNum);
  122.                 dataRowFailMsg.setMsg("无法识别的字段");
  123.                 // 如果不继续，则直接抛出停止异常
  124.                 final Boolean[] isContinues = failFun.apply(dataRowFailMsg);
  125.                 if (isContinues != null) {
  126.                     // 剩余文件不继续解析
  127.                     if (!isContinues[0]) {
  128.                         throw new DataRowParseStopException();
  129.                     }
  130.                     // 剩余字段不继续解析
  131.                     if (!isContinues[1]) {
  132.                         break;
  133.                     }
  134.                     // 剩余字段继续解析
  135.                     continue;
  136.                 }
  137.             }
  138.             // 利用反射给对应的字段赋值
  139.             final Class<?> type = fieldItem.getType();
  140.             final Field field = fieldItem.getField();
  141.             try {
  142.                 final Object value = Convert.convert(type, valueObject);
  143.                 field.set(row, value);
  144.             } catch (Exception e) {
  145.                 String msg = StrUtil.format("值转换异常，目标值类型={} ，原始值={}",
  146.                         type.getName(),
  147.                         valueObject
  148.                 );
  150.                 final DataRowFailMsg dataRowFailMsg = new DataRowFailMsg();
  151.                 dataRowFailMsg.setRowNum(excelRowNum);
  152.                 dataRowFailMsg.setField(header);
  153.                 dataRowFailMsg.setPosition(ExcelColumnUtil.excelColIndexToStr(i + 1) + excelRowNum);
  154.                 dataRowFailMsg.setMsg(msg);
  155.                 // 如果不继续，则直接抛出停止异常
  156.                 final Boolean[] isContinues = failFun.apply(dataRowFailMsg);
  157.                 if (isContinues != null) {
  158.                     // 剩余文件不继续解析
  159.                     if (!isContinues[0]) {
  160.                         throw new DataRowParseStopException();
  161.                     }
  162.                     // 剩余字段不继续解析
  163.                     if (!isContinues[1]) {
  164.                         row.setError(true);
  165.                         break;
  166.                     }
  167.                     // 剩余字段继续解析
  168.                     row.setError(true);
  169.                     continue;
  170.                 }
  171.             }
  172.         }
  173.         return row;
  174.     }
  176.     /**
  177.      * 构建字段别名
  178.      * <pre>
  179.      *     表头使用中文字段，想要处理过程中中文字段与对象字段对应上，
  180.      *     该方法就是将：中文字段 与 对象的字段 关联上，方便后续的 set 操作
  181.      * </pre>
  182.      */
  183.     private void buildFieldItemMap() {
  184.         final Class clzz = factoryNew.get().getClass();
  185.         final Field[] declaredFields = clzz.getDeclaredFields();
  186.         Map<String, FieldItem> fieldItemMap = new HashMap<>();
  187.         for (Field declaredField : declaredFields) {
  188.             final Class<?> type = declaredField.getType();
  189.             final Alias aliasAnno = declaredField.getAnnotation(Alias.class);
  190.             if (aliasAnno == null) {
  191.                 continue;
  192.             }
  193.             final String value = aliasAnno.value();
  194.             declaredField.setAccessible(true);
  195.             fieldItemMap.put(value, new FieldItem(declaredField, type));
  196.         }
  197.         this.fieldItemMap = fieldItemMap;
  198.     }
  200.     @Data
  201.     private static class FieldItem {
  202.         // 字段实例
  203.         private Field field;
  204.         // 参数类型
  205.         private Class<?> type;
  207.         public FieldItem(Field field, Class<?> type) {
  208.             this.field = field;
  209.             this.type = type;
  210.         }
  211.     }
  212. }

其他辅助类，响应的字段位置、行号、异常等类

  1. package cn.mrcode.parse.data;
  3. import lombok.Data;
  4. import lombok.ToString;
  6. /**
  7.  * 数据所在行
  8.  * @author mrcode
  9.  * @date 2021/9/16 20:03
  10.  */
  11. @Data
  12. @ToString
  13. public class DataRowNumber {
  14.     // 行号
  15.     private Long rowNum;
  16.     // 这一行数据中是否有解析错误的信息，当某个字段解析失败还继续解析剩余字段时，这里就会标识为 true，标识该条数据不完整
  17.     private boolean isError;
  18. }
  1. package cn.mrcode.parse.data;
  3. import lombok.Data;
  4. import lombok.EqualsAndHashCode;
  6. /**
  7.  * 某个字段的位置信息
  8.  * @author mrcode
  9.  * @date 2021/9/16 20:03
  10.  */
  11. @Data
  12. @EqualsAndHashCode(callSuper = true)
  13. public class DataRowFieldInfo extends DataRowNumber {
  14.     // 位置
  15.     private String position;
  16.     // 字段
  17.     private String field;
  19.     @Override
  20.     public String toString() {
  21.         return "DataRowFieldInfo{" +
  22.                 "rowNum=" + getRowNum() +
  23.                 ", position='" + position + '\'' +
  24.                 ", field='" + field + '\'' +
  25.                 '}';
  26.     }
  28.      /**
  29.      * 转换为错误信息，可用于二次加工
  30.      *
  31.      * @return
  32.      */
  33.     public DataRowFailMsg toFailMsg() {
  34.         final DataRowFailMsg failMsg = new DataRowFailMsg();
  35.         failMsg.setRowNum(this.getRowNum());
  36.         failMsg.setField(this.field);
  37.         failMsg.setPosition(this.position);
  38.         return failMsg;
  39.     }
  40. }
  1. package cn.mrcode.parse.data;
  3. import lombok.Data;
  4. import lombok.EqualsAndHashCode;
  6. /**
  7.  * 解析失败时的位置定位信息详情
  8.  * @author mrcode
  9.  * @date 2021/9/16 20:03
  10.  */
  11. @Data
  12. @EqualsAndHashCode(callSuper = true)
  13. public class DataRowFailMsg extends DataRowFieldInfo {
  14.     // 错误信息
  15.     private String msg;
  17.     @Override
  18.     public String toString() {
  19.         return "DataRowFailMsg{" +
  20.                 "rowNum=" + getRowNum() +
  21.                 ", position='" + getPosition() + '\'' +
  22.                 ", field='" + getField() + '\'' +
  23.                 ", msg='" + msg + '\'' +
  24.                 '}';
  25.     }
  26. }
  1. package cn.mrcode.parse.data;
  3. /**
  4.  * 解析停止时的异常; 用于手动停止解析的中断逻辑流程
  5.  * @author mrcode
  6.  * @date 2021/9/16 20:03 
  7.  */
  8. public class DataRowParseStopException extends RuntimeException {
  9.     public DataRowParseStopException() {
  10.     }
  11. }
  1. package cn.mrcode.parse.data;
  3. /**
  4.  * 数据解析成功，回调函数
  5.  * @author mrcode
  6.  * @date 2021/9/16 20:03
  7.  */
  8. @FunctionalInterface
  9. public interface DataRowFunction<T, R> {
  10.     /**
  11.      * @param t
  12.      * @param handler 行解析对象本身
  13.      * @return
  14.      */
  15.     R apply(T t, DataRowHandler handler);
  16. }

excel 位置信息工具类

  1. package cn.mrcode.parse.data;
  3. /**
  4.  * Excel 列的下标 和 字母互转
  5.  *
  6.  * @author Stephen.Huang
  7.  * @version 2015-7-8
  8.  */
  9. public class ExcelColumnUtil {
  10.     public static int excelColStrToNum(String colStr) {
  11.         return excelColStrToNum(colStr, colStr.length());
  12.     }
  14.     /**
  15.      * 列字母转数字
  16.      * <pre>
  17.      *
  18.      * 注意：Excel column index 从 1 开始
  19.      *
  20.      * </pre>
  21.      *
  22.      * @param colStr
  23.      * @param length
  24.      * @return
  25.      */
  26.     public static int excelColStrToNum(String colStr, int length) {
  27.         int num = 0;
  28.         int result = 0;
  29.         for (int i = 0; i < length; i++) {
  30.             char ch = colStr.charAt(length - i - 1);
  31.             num = (int) (ch - 'A' + 1);
  32.             num *= Math.pow(26, i);
  33.             result += num;
  34.         }
  35.         return result;
  36.     }
  38.     /**
  39.      * 将列转成字母
  40.      *
  41.      * @param columnIndex 注意：Excel column index 从 1 开始
  42.      * @return
  43.      */
  44.     public static String excelColIndexToStr(int columnIndex) {
  45.         if (columnIndex <= 0) {
  46.             return null;
  47.         }
  48.         String columnStr = "";
  49.         columnIndex--;
  50.         do {
  51.             if (columnStr.length() > 0) {
  52.                 columnIndex--;
  53.             }
  54.             columnStr = ((char) (columnIndex % 26 + (int) 'A')) + columnStr;
  55.             columnIndex = (int) ((columnIndex - columnIndex % 26) / 26);
  56.         } while (columnIndex > 0);
  57.         return columnStr;
  58.     }
  60.     public static void main(String[] args) {
  61.         String colstr = "AA";
  62.         int colIndex = excelColStrToNum(colstr, colstr.length());
  63.         System.out.println("'" + colstr + "' column index of " + colIndex);
  64.         colIndex = 26;
  65.         colstr = excelColIndexToStr(colIndex);
  66.         System.out.println(colIndex + " column in excel of " + colstr);
  67.         colstr = "AAAA";
  68.         colIndex = excelColStrToNum(colstr, colstr.length());
  69.         System.out.println("'" + colstr + "' column index of " + colIndex);
  70.         colIndex = 466948;
  71.         colstr = excelColIndexToStr(colIndex);
  72.         System.out.println(colIndex + " column in excel of " + colstr);
  73.     }
  74. }

业务代码与测试

步骤 1：首先准备一份 excel 文件，如下图所示：第一行是表头，第二行开始是数据
image.png
步骤 2：准备对应的数据对象

  1. package cn.mrcode.parse.data.test;
  3. import cn.mrcode.parse.data.DataRowNumber;
  5. import cn.hutool.core.annotation.Alias;
  6. import lombok.Data;
  7. import lombok.EqualsAndHashCode;
  8. import lombok.ToString;
  11. @Data
  12. @ToString
  13. @EqualsAndHashCode(callSuper = true)
  14. public class CustomerRow extends DataRowNumber {
  15.     @Alias(CustomerRowFieldAlias.CUSTOMER_NAME)
  16.     private String customerName;
  17.     @Alias(CustomerRowFieldAlias.COMPANY)
  18.     private String company;
  19.     @Alias(CustomerRowFieldAlias.PRODUCT_TYPE)
  20.     private String productType;
  21.     @Alias(CustomerRowFieldAlias.BRAND)
  22.     private String brand;
  23.     @Alias(CustomerRowFieldAlias.WEBSITE)
  24.     private String website;
  25.     @Alias(CustomerRowFieldAlias.AREA)
  26.     private String area;
  27.     @Alias(CustomerRowFieldAlias.CHANNEL_CODE)
  28.     private String channelCoding;
  29.     @Alias(CustomerRowFieldAlias.SOURCE)
  30.     private String source;
  31.     @Alias(CustomerRowFieldAlias.CONTACT_INFO)
  32.     private String contactInfo;
  33.     @Alias(CustomerRowFieldAlias.DEMAND)
  34.     private String demand;
  35.     @Alias(CustomerRowFieldAlias.REMARK)
  36.     private Integer remark;
  37. }

文件表头对应的别名常量类

  1. public interface CustomerRowFieldAlias {
  2.     String CUSTOMER_NAME="客户名称（必填）";
  3.     String COMPANY="客户公司";
  4.     String PRODUCT_TYPE="产品品类";
  5.     String BRAND="客户品牌";
  6.     String WEBSITE="客户网站";
  7.     String AREA="地区";
  8.     String CHANNEL_CODE="来源渠道（必填）";
  9.     String SOURCE="来源";
  10.     String CONTACT_INFO="联系方式";
  11.     String DEMAND="客户需求";
  12.     String REMARK="备注";
  13. }

步骤 3：编写解析代码测试

  1. package cn.mrcode.parse.data.test;
  3. import cn.mrcode.parse.data.test.CustomerRow;
  4. import cn.mrcode.parse.data.test.CustomerRowFieldAlias;
  6. import org.junit.jupiter.api.Test;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.nio.file.Files;
  11. import java.nio.file.Path;
  12. import java.nio.file.Paths;
  14. import cn.hutool.core.util.StrUtil;
  15. import cn.hutool.poi.excel.ExcelUtil;
  17. /**
  18.  * @author mrcode
  19.  * @date 2021/9/16 20:03
  20.  */
  21. class DataRowHandlerTest {
  23.     @Test
  24.     void handle() {
  25.         Path path = Paths.get("C:\\clue-customer.xlsx");
  26.         try (final InputStream inputStream = Files.newInputStream(path)) {
  27.             final DataRowHandler<CustomerRow> rowHandler = new DataRowHandler<>(
  28.                     // 一行数据解析成功
  29.                     (item, handler) -> {
  30.                         System.out.println("数据解析成功，其中是否有某个字段解析失败？" + item.isError());
  31.                         System.out.println("数据解析成功：" + item);
  33.                         // 这里可以做业务的校验等，比如该字段是必须的，
  34.                         final String customerName = item.getCustomerName();
  35.                         if (StrUtil.isBlank(customerName)) {
  36.                             // 校验失败之后，获取该字段在文件中的位置信息
  37.                             DataRowFieldInfo fieldInfo = handler.getFieldInfo(CustomerRowFieldAlias.CUSTOMER_NAME, item);
  38.                             System.out.println("业务校验未通过，字段信息：" + fieldInfo);
  40.                             // 遇到一个错误之后，就不再继续解析文件了
  41.                             return false;
  42.                         }
  43.                         return true;
  44.                     },
  45.                     // 一行的某个字段解析失败时调用
  46.                     item -> {
  47.                         System.out.println("数据解析失败：" + item);
  48.                         // 如果该字段解析失败，还需要继续往下解析，发挥 true，否则返回  false
  49.                         // 第一个值：剩余文件是否还继续解析, 如果文件都不继续了，则直接返回，剩余字段信息也不会解析
  50.                         // 第二个值：剩余字段还是否继续解析, 如果是 true，那么这一行数据将可能会出现多个字段解析异常的消息,最后会回调解析成功的函数
  51.                         //          继而可以在回调成功的函数中，使用 item.isError() 判定该条数据是否完整
  52.                         return new Boolean[]{true, false};
  53.                     },
  54.                     // 一行数据的承载对象
  55.                     CustomerRow::new
  56.             );
  57.             // 开始解析，只解析第一个 sheet 的内容
  58.             ExcelUtil.readBySax(inputStream, 0, rowHandler);
  59.         } catch (DataRowParseStopException e) {
  60.             System.out.println("手动中断解析");
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.             System.out.println("未知异常，需要看源码确定是哪里的问题");
  64.         }
  66.     }
  67. }

自定义业务校验失败时

  1. 数据解析成功：CustomerRow(customerName=null, company=北京科技有限公司, productType=成衣,假发, brand=null, website=null, area=null, channelCoding=请填写渠道编码，如：abc123, source=来源渠道补充信息, contactInfo=联系名称和联系方式用英文冒号分隔，多个用英文;分隔，如：手机:123456;QQ:123456, demand=null, remark=null)
  2. 业务校验未通过，字段信息：DataRowFieldInfo{rowNum=2, position='A2', field='客户名称（必填）'}
  3. 手动中断解析

某行字段解析失败，并且剩余文件不继续解析、剩余字段不继续解析时

  1. 数据解析失败：DataRowFailMsg{rowNum=2, position='K2', field='备注', msg='值转换异常，目标值类型=java.lang.Integer ，原始值=15xxx，解析错误'}
  2. 手动中断解析

某行字段解析失败，并且剩余文件继续解析、剩余字段不继续解析时：

  1. 数据解析失败：DataRowFailMsg{rowNum=2, position='K2', field='备注', msg='值转换异常，目标值类型=java.lang.Integer ，原始值=算法ss'}
  2. 数据解析成功，其中是否有某个字段解析失败？true
  3. 数据解析成功：CustomerRow(customerName=张三, company=北京科技有限公司, productType=成衣,假发, brand=null, website=null, area=null, channelCoding=请填写渠道编码，如：abc123, source=来源渠道补充信息, contactInfo=联系名称和联系方式用英文冒号分隔，多个用英文;分隔，如：手机:123456;QQ:123456, demand=null, remark=null)

真实业务场景使用

需求：对一个文件进行解析入库，解析成功的行、经过业务校验通过后，入库，未经过校验的或则解析失败的，响应详细信息给前端

  1. @Override
  2.     @AccessLog(value = "线索导入", isPrintRes = false)
  3.     public ImportCustomerResult importCustomer(Path path, UserInfo userInfo) {
  4.         // 解析的总数
  5.         AtomicReference<Integer> totalCount = new AtomicReference<>(0);
  6.         // 失败的数量
  7.         AtomicReference<Integer> failCount = new AtomicReference<>(0);
  8.         // 成功的数量
  9.         AtomicReference<Integer> successCount = new AtomicReference<>(0);
  10.         // 用于存储失败行的错误信息，每行错误信息只存储一条
  11.         List<DataRowFailMsg> errDetails = new ArrayList<>();
  12.         try (final InputStream inputStream = Files.newInputStream(path)) {
  13.             final DataRowHandler<CustomerRow> rowHandler = new DataRowHandler<>(
  14.                     // 一行数据解析成功
  15.                     (item, handler) -> {
  16.                         //由于忽略某一行解析失败， 除了致命的文件解析异常，都会进入到这里，在这里进行总行数的统计
  17.                         totalCount.getAndSet(totalCount.get() + 1);
  18.                         // 该行数据有异常,剩余文件数据继续解析
  19.                         if (item.isError()) {
  20.                             // 失败数量+1
  21.                             failCount.getAndSet(failCount.get() + 1);
  22.                             return true;
  23.                         }
  25.                         final DataRowFailMsg failMsg = this.checkData(item, handler);
  26.                         if (failMsg != null) {
  27.                             errDetails.add(failMsg);
  28.                             failCount.getAndSet(failCount.get() + 1);
  29.                             return true;
  30.                         }
  31.                         successCount.getAndSet(successCount.get() + 1);
  32.                         // 插入数据库操作
  34.                         return true;
  35.                     },
  36.                     // 一行的某个字段解析失败时调用
  37.                     item -> {
  38.                         errDetails.add(item); // 将该行数据的第一个错误信息添加到详情中
  39.                         // 某个字段解析失败，文件继续解析，剩余字段不继续解析
  40.                         return new Boolean[]{true, false};
  41.                     },
  42.                     // 一行数据的承载对象
  43.                     CustomerRow::new
  44.             );
  45.             // 开始解析，只解析第一个 sheet 的内容
  46.             ExcelUtil.readBySax(inputStream, 0, rowHandler);
  47.         } catch (DataRowParseStopException e) {
  48.             // 响应导入结果
  49.             final ImportCustomerResult result = new ImportCustomerResult();
  50.             result.setTotalCount(totalCount.get());
  51.             result.setFailCount(failCount.get());
  52.             result.setSuccessCount(successCount.get());
  53.             result.setErrDetails(errDetails);
  54.             return result;
  55.         } catch (IOException e) {
  56.             log.error("文件解析异常", e);
  57.             throwErr("导入失败，未知错误");
  58.         }
  60.         // 响应导入结果
  61.         final ImportCustomerResult result = new ImportCustomerResult();
  62.         result.setTotalCount(totalCount.get());
  63.         result.setFailCount(failCount.get());
  64.         result.setSuccessCount(successCount.get());
  65.         result.setErrDetails(errDetails);
  66.         return result;
  67.     }
  69.     /**
  70.      * 业务数据校验
  71.      *
  72.      * @param item
  73.      * @param handler
  74.      * @return
  75.      */
  76.     private DataRowFailMsg checkData(CustomerRow item, DataRowHandler handler) {
  77.         final String customerName = item.getCustomerName();
  78.         if (StrUtil.isBlank(customerName)) {
  79.             DataRowFieldInfo fieldInfo = handler.getFieldInfo(CustomerRowFieldAlias.CUSTOMER_NAME, item);
  80.             DataRowFailMsg failMsg = fieldInfo.toFailMsg();
  81.             failMsg.setMsg("该数据必填");
  82.             return failMsg;
  83.         }
  85.         final String channelCoding = item.getChannelCoding();
  86.         if (StrUtil.isBlank(channelCoding)) {
  87.             DataRowFieldInfo fieldInfo = handler.getFieldInfo(CustomerRowFieldAlias.CHANNEL_CODE, item);
  88.             DataRowFailMsg failMsg = fieldInfo.toFailMsg();
  89.             failMsg.setMsg("该数据必填");
  90.             return failMsg;
  91.         }
  93.         // 客户名称不能重复校验
  95.         // 渠道编码真实性校验
  97.         return null;
  98.     }

返回给前端渲染报告图
image.png