需求分析

Excel导入去做一些前置检查，包括非空检查和根据前面的字段生成对应的值、唯一索引等检查。
以及导入的数据失败的原因，成功的条数日志记录。
Excel的标题名和字段名数据库映射。

思路

数据映射

之前其实是有一个版本，是按照getCell(0) 列数来获取的，并没有做数据映射。这个有一个问题，就是模板一旦出现一点改动，随之而来的就是代码的大量改动。

并且硬编码代码过多，当然他也有优点，效率高。

为了完成数据映射，那么就必须引入反射，自定义注解来帮助我们完成数据映射，自定义注解引入的话，就会出现一个bean需要单独的维护。

字典

并且之前的字典写法，static {
// 加载map
}

创建了n个map，然后put进去。

这样子，会影响性能。

下个一版本，改为enum枚举类。
JAVA 之POI导入批量新增、批量检查、日志记录、失败原因、失败条数、数据库映射 - 图1

有效行数

还有一个成功条数和失败条数，本人使用了Atomic原子类，总觉得i++，i—不放心，所以我就使用了原子类。 POI的API没有计算有效行数，故而需要我们写代码实现。比如：getLastRowNum()方法获取也不是正确的行数。

什么是有效行数？

每一行有真正的数据，而不是空行数据。
JAVA 之POI导入批量新增、批量检查、日志记录、失败原因、失败条数、数据库映射 - 图2

这个逻辑就是有三个原子类。
JAVA 之POI导入批量新增、批量检查、日志记录、失败原因、失败条数、数据库映射 - 图3
我认为当连续空行数大于100行，那么没必要继续遍历查询。

计算有内容行核心逻辑

JAVA 之POI导入批量新增、批量检查、日志记录、失败原因、失败条数、数据库映射 - 图4

难点与问题

第一个难点

list.add()内容覆盖问题
参照我的博客解决方案。
https://blog.csdn.net/qq_41520636/article/details/124493078

第二个难点

比如：
class A {
private B b;
}

class B {

}

此时应该怎么处理这个B，相当于标题栏里面正好有两个Bean，还好这个情况只有一个，不然我心态崩了。
这个解决方案只有看代码了。

第三个难点

比如：
class A{
private String name;
}

class B {
private String name;
}
这两个其实一对一关系，并且在标题映射时，我用怎么让B获取到A的值。

实现

因为是公司代码就不贴全部代码，只贴核心代码。

  1. /**
  2.  * <p>
  3.  *    excel导入注解
  4.  * </p>
  5.  *
  6.  * @author lisonglin
  7.  * @version 1.0
  8.  * @since 2022/4/25 16:19
  9.  */
  10. @Documented
  11. @Inherited
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target(ElementType.FIELD)
  14. public @interface ExcelImport {
  16.     /**
  17.      * 与excel标题头对应
  18.      */
  19.     String exportName();
  21.     /**
  22.      * 转换格式, 如时间类型 yyyy-MM-dd HH:mm:ss
  23.      */
  24.     String pattern() default "";
  26.     /**
  27.      * 在excel中位置
  28.      */
  29.     int order() default 0;
  31.     /**
  32.      * 长度
  33.      **/
  34.     int width() default 0;
  36.     /**
  37.      * 检查非空
  38.      **/
  39.     boolean checkNotNull() default false;
  41.     /**
  42.      * 唯一性
  43.      */
  44.     boolean uniqueness() default false;
  46.     /**
  47.      * 可根据其他属性生成的Code（如果没有设置，则根据其他属性生成）
  48.      */
  49.     String rule() default "";
  50. }
  1. /**
  2.  * <p>
  3.  *     字典
  4.  * </p>
  5.  *
  6.  * @author lisonglin
  7.  * @version 1.0
  8.  * @since 2022/4/25 19:42
  9.  */
  10. @Documented
  11. @Inherited
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target(ElementType.FIELD)
  14. public @interface Dict {
  15.     /**
  16.      * 对应字典名称
  17.      **/
  18.     Class dictClass();
  19. }
  1. /**
  2.  * <p>
  3.  *     字段映射
  4.  * </p>
  5.  *
  6.  * @author lisonglin
  7.  * @version 1.0
  8.  * @since 2022/5/6 19:27
  9.  */
  10. @Documented
  11. @Inherited
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target(ElementType.FIELD)
  14. public @interface ExcelMapping {
  15.     /**
  16.      * 映射名
  17.      */
  18.     String mappingName() default "";
  20.     /**
  21.      * 是否必填
  22.      */
  23.     boolean isRequired() default false;
  25. }
  1. /**
  2.  * <p>
  3.  *     默认值注解
  4.  * </p>
  5.  *
  6.  * @author lisonglin
  7.  * @version 1.0
  8.  * @since 2022/4/25 18:28
  9.  */
  10. @Documented
  11. @Inherited
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target(ElementType.FIELD)
  14. public @interface ExcelToValue {
  15.     String value() default "";
  16. }
  1. @Target({ElementType.TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface TableName {
  5.     String value() default "";
  6. }
  1. @Target({ElementType.FIELD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface Column {
  5.     String value() default "";
  6. }
  1. @TableName("ZJDSP_ZJDZD")
  2. public class ZjdspZjdzd implements Serializable {
  4.     /**
  5.      *
  6.      */
  7.     @JSONField(name = "iid")
  8.     @Column("IID")
  9.     private String iid;
  11.     /**
  12.      *
  13.      */
  14.     @ExcelToValue(value = Constants.INPUT_INDEX)
  15.     @JSONField(name = "input_index")
  16.     @Column("INPUT_INDEX")
  17.     private String inputIndex;
  19.     /**
  20.      * 要素代码
  21.      */
  22.     @ExcelToValue(value = YsdmConstans.YSDM_ZRZ)
  23.     @JSONField(name = "ysdm")
  24.     @Column("YSDM")
  25.     private String ysdm;
  27.     /**
  28.      * 所有权人代码
  29.      */
  30.     @ExcelImport(exportName = "所有权人代码", checkNotNull = true, uniqueness = true)
  31.     @JSONField(name = "suyqrdm")
  32.     @Column("SUYQRDM")
  33.     private String suyqrdm;
  35.     /**
  36.      * 宅基地代码（所有权人代码+6位顺序号）
  37.      */
  38.     @ExcelMapping(mappingName = "ZjdspZjdzd")
  39.     @ExcelImport(exportName = "宅基地代码", checkNotNull = true, uniqueness = true, rule = "SUYQRDM")
  40.     @JSONField(name = "zjddm")
  41.     @Column("ZJDDM")
  42.     private String zjddm;
  44.     @ExcelToValue
  45.     private ZjdspZjdzdxx zjdspZjdzdxx;
  46. }
  1. @TableName("ZJDSP_ZJDZDXX")
  2. public class ZjdspZjdzdxx implements Serializable {
  4.     /**
  5.      *
  6.      */
  7.     @JSONField(name = "iid")
  8.     @Column("IID")
  9.     private String iid;
  11.     /**
  12.      *
  13.      */
  14.     @ExcelToValue(value = Constants.INPUT_INDEX)
  15.     @JSONField(name = "input_index")
  16.     @Column("INPUT_INDEX")
  17.     private String inputIndex;
  19.     /**
  20.      * 要素代码
  21.      */
  22.     @ExcelToValue(value = YsdmConstans.YSDM_ZJDZDXX)
  23.     @JSONField(name = "ysdm")
  24.     @Column("YSDM")
  25.     private String ysdm;
  27.     /**
  28.      * 宅基地代码
  29.      */
  30.     @ExcelMapping(mappingName = "ZjdspZjdzdxx", isRequired = true)
  31.     @JSONField(name = "zjddm")
  32.     @Column("ZJDDM")
  33.     private String zjddm;
  34. }
  1. package antu.zjdsjjg.tool;
  3. import antu.com.Database;
  4. import antu.com.annotations.Column;
  5. import antu.com.annotations.TableName;
  6. import antu.com.tools.LogUtils;
  7. import antu.zjdsjjg.action.AppConfig;
  8. import antu.zjdsjjg.domian.*;
  9. import antu.zjdsjjg.domian.constants.Constants;
  10. import antu.zjdsjjg.domian.constants.ExcelConstants;
  11. import antu.zjdsjjg.model.ZjdspDrlsLog;
  12. import antu.zjdsjjg.model.port.ObjectLocal;
  13. import antu.zjdsjjg.model.vo.ContentVo;
  14. import antu.zjdsjjg.provider.wh.GetWhAdapterProvider;
  15. import antu.zjdsjjg.provider.wh.GetWhAdapterProviderImpl;
  16. import com.alibaba.fastjson.JSON;
  17. import com.alibaba.fastjson.JSONObject;
  18. import org.apache.commons.lang.StringUtils;
  19. import org.apache.commons.lang3.SerializationUtils;
  20. import org.apache.poi.hssf.usermodel.HSSFDataFormat;
  21. import org.apache.poi.hssf.usermodel.HSSFDateUtil;
  22. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  23. import org.apache.poi.ss.usermodel.*;
  24. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  25. import org.springframework.util.StopWatch;
  26. import org.springframework.web.multipart.MultipartFile;
  28. import java.beans.PropertyDescriptor;
  29. import java.io.IOException;
  30. import java.io.InputStream;
  31. import java.io.Serializable;
  32. import java.lang.reflect.*;
  33. import java.text.DecimalFormat;
  34. import java.text.SimpleDateFormat;
  35. import java.util.*;
  36. import java.util.concurrent.CopyOnWriteArrayList;
  37. import java.util.concurrent.atomic.AtomicInteger;
  39. /**
  40.  * <p>
  41.  * excel工具类
  42.  * </p>
  43.  *
  44.  * @author lisonglin
  45.  * @version 1.0
  46.  * @since 2022/3/9 14:10
  47.  */
  48. public class ExcelTool {
  50.     /**
  51.      * 导入excel
  52.      *
  53.      * @param multipartFile 文件
  54.      * @param sheet         工作表
  55.      * @param jsonData      json
  56.      * @return 导入的数据
  57.      */
  58.     public static List<Object> importExcel(MultipartFile multipartFile, String jsonData, String token,
  59.                                            String... sheet) {
  60.         JSONObject jsonObject = JSONObject.parseObject(jsonData);
  61.         String xzqdm = jsonObject.getString("xzqdm");
  62.         String userid = jsonObject.getString("userid");
  63.         String cjzzdm = jsonObject.getString("cjzzdm");
  64.         String zjzzdm = jsonObject.getString("zjzzdm");
  65.         StopWatch watch = new StopWatch();
  66.         watch.start();
  67.         // 获取用户名
  68.         String userSql = "select name from st_employee where employee_id = ?";
  69.         Database atpDb = new Database(AppConfig.atp_db);
  70.         String userName = atpDb.firstOrDefault(String.class, userSql, userid);
  71.         // 日志记录初始值
  72.         ZjdspDrlsLog zjdspDrlsLog = new ZjdspDrlsLog();
  73.         // 设置行政区代码
  74.         zjdspDrlsLog.setXzqdm(xzqdm);
  75.         // 设置操作系统名
  76.         zjdspDrlsLog.setMis(AppConfig.zjdsjjg_db);
  77.         // 设置导入时间为系统时间
  78.         zjdspDrlsLog.setImportDate(new java.sql.Timestamp(System.currentTimeMillis()));
  79.         // 设置导入人
  80.         zjdspDrlsLog.setCreateUser(userName);
  81.         zjdspDrlsLog.setCjzzdm(cjzzdm);
  82.         zjdspDrlsLog.setZjzzdm(zjzzdm);
  83.         if (!checkFile(multipartFile)) {
  84.             LogUtils.warn("上传的文件类型出错！");
  85.             // 设置导入状态为失败
  86.             zjdspDrlsLog.setHandleType(ExcelConstants.EXCEL_TYPE_ERROR);
  87.             // 设置导入类型
  88.             zjdspDrlsLog.setGrade(ExcelConstants.EXCEL_GRADE_ERROR);
  89.             // 设置失败原因
  90.             zjdspDrlsLog.setContent("上传的文件类型出错！");
  91.             return null;
  92.         }
  93.         Workbook workBook = getWorkBook(multipartFile);
  94.         return parseExcel(workBook, zjdspDrlsLog, xzqdm, token, watch, sheet);
  95.     }
  97.     /**
  98.      * 日期类型转换
  99.      *
  100.      * @param cell 单元格
  101.      * @return 字符串的时间
  102.      */
  103.     public static String stringDateProcess(Cell cell) {
  104.         String result;
  105.         // 处理日期格式、时间格式
  106.         short dataFormat = cell.getCellStyle().getDataFormat();
  107.         if (HSSFDateUtil.isCellDateFormatted(cell)) {
  108.             SimpleDateFormat sdf = null;
  109.             if (cell.getCellStyle().getDataFormat() == HSSFDataFormat.getBuiltinFormat("h:mm")) {
  110.                 sdf = new SimpleDateFormat("HH:mm");
  111.             } else {
  112.                 // 日期
  113.                 sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  114.             }
  115.             Date date = cell.getDateCellValue();
  116.             result = sdf.format(date);
  117.         } else if (dataFormat == ExcelConstants.EXCEL_DATE_MD) {
  118.             // 处理自定义日期格式：m月d日(通过判断单元格的格式id解决，id的值是58)
  119.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  120.             double value = cell.getNumericCellValue();
  121.             Date date = DateUtil.getJavaDate(value);
  122.             result = sdf.format(date);
  123.         } else {
  124.             double value = cell.getNumericCellValue();
  125.             // int类型
  126.             if (String.valueOf(value).indexOf(".0") > 0) {
  127.                 result = String.valueOf(value).substring(0, String.valueOf(value).indexOf(".0"));
  128.             } else {
  129.                 // double类型
  130.                 DecimalFormat format = new DecimalFormat();
  131.                 int len = (value + "").length() - (value + "").indexOf(".") - 1;
  132.                 if (len > 0) {
  133.                     format.applyPattern("#." + StringUtils.repeat("0", len));
  134.                 } else {
  135.                     format.applyPattern("#");
  136.                 }
  137.                 result = format.format(value);
  138.             }
  139.         }
  140.         return result;
  141.     }
  143.     /**
  144.      * 转换excel数据类型
  145.      *
  146.      * @param cell 单元格
  147.      * @return 转换后的数据
  148.      */
  149.     private static String convertCellValueToString(Cell cell) {
  150.         if (cell == null || cell.toString().trim().equals(Constants.EMPTY)) {
  151.             return null;
  152.         }
  153.         String cellValue;
  154.         switch (cell.getCellTypeEnum()) {
  155.             case BOOLEAN:
  156.                 // 读取布尔
  157.                 cellValue = String.valueOf(cell.getBooleanCellValue());
  158.                 break;
  159.             case NUMERIC:
  160.                 // 读取日期格式
  161.                 cellValue = stringDateProcess(cell);
  162.                 break;
  163.             case FORMULA:
  164.                 // 读取公式
  165.                 cellValue = String.valueOf(cell.getCellFormula());
  166.                 break;
  167.             case STRING:
  168.                 // 读取String
  169.                 cellValue = String.valueOf(cell.getStringCellValue());
  170.                 break;
  171.             case ERROR:
  172.                 // 读取故障
  173.                 cellValue = "非法字符";
  174.                 break;
  175.             case _NONE:
  176.             case BLANK:
  177.                 cellValue = "";
  178.                 break;
  179.             default:
  180.                 cellValue = "未知类型";
  181.         }
  182.         return cellValue;
  183.     }
  185.     /**
  186.      * 获取字段键值对 如：{所有权人代码=["setSuyqrdm", "yyyy-MM-dd", “”, “91360421MA35XB656Y”]}
  187.      * 键值对关系：
  188.      * Excel表头的字段名称 = [字段set方法名, 时间格式, 需要匹配的字典, 默认值]
  189.      *
  190.      * @param clazz 实体类
  191.      * @return 字段键值对
  192.      */
  193.     public static List<Object> getFieldMap(Class<?> clazz, Object catObj) {
  194.         Field[] fields = clazz.getDeclaredFields();
  195.         List<Object> objectList = new ArrayList<>();
  196.         // 将所有标有Annotation的字段，也就是允许导入数据的字段,放入到一个map中
  197.         Map<String, ObjectLocal> fieldMap = new HashMap<>(10);
  198.         Map<String, Object[]> childrenSetMap = new HashMap<>(2);
  199.         try {
  200.             // 循环读取所有字段
  201.             for (Field field : fields) {
  202.                 putMap(clazz, fieldMap, field, catObj, childrenSetMap);
  203.             }
  204.         } catch (Exception e) {
  205.             throw new RuntimeException(e);
  206.         }
  207.         objectList.add(fieldMap);
  208.         objectList.add(childrenSetMap);
  209.         return objectList;
  210.     }
  212.     /**
  213.      * 将对象实例添加进Map中（处理一些默认值）
  214.      *
  215.      * @param clazz       bean
  216.      * @param fieldMap    字段Map
  217.      * @param field       字段属性
  218.      * @param newInstance 实例化对象
  219.      * @throws Exception 异常
  220.      */
  221.     private static void putMap(Class<?> clazz, Map<String, ObjectLocal> fieldMap, Field field, Object newInstance,
  222.                                Map<String, Object[]> childrenSetMap) throws Exception {
  223.         ExcelImport exa = field.getAnnotation(ExcelImport.class);
  224.         ExcelToValue eValue = field.getAnnotation(ExcelToValue.class);
  225.         boolean isExist = field.isAnnotationPresent(ExcelToValue.class);
  226.         Dict dict = field.getAnnotation(Dict.class);
  227.         Column column = field.getAnnotation(Column.class);
  228.         ExcelMapping excelMapping = field.getAnnotation(ExcelMapping.class);
  229.         Enum[] enumConstants = null;
  230.         if (null != excelMapping){
  231.             String fieldName = field.getName();
  232.             PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fieldName, clazz);
  233.             Method writeMethod = propertyDescriptor.getWriteMethod();
  234.             Method readMethod = propertyDescriptor.getReadMethod();
  235.             boolean required = excelMapping.isRequired();
  236.             String mappingName = excelMapping.mappingName();
  237.             if (required) {
  238.                 // zjdxx
  239.                 childrenSetMap.put(mappingName, new Object[]{writeMethod});
  240.             } else {
  241.                 // zjdzd
  242.                 childrenSetMap.put(mappingName, new Object[]{readMethod});
  243.             }
  244.         }
  245.         if (exa != null) {
  246.             String fieldName = field.getName();
  247.             // 数据库映射值
  248.             String value = column.value();
  249.             PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fieldName, clazz);
  250.             Method writeMethod = propertyDescriptor.getWriteMethod();
  251.             Method readMethod = propertyDescriptor.getReadMethod();
  252.             // 非空检查
  253.             boolean checkNotNull = exa.checkNotNull();
  254.             // 唯一性检查
  255.             boolean uniqueness = exa.uniqueness();
  256.             // 可生成性检查
  257.             String generativeCode = exa.rule();
  258.             Method dictMethod = null;
  259.             if (dict != null) {
  260.                 Class<Enum> aClass = dict.dictClass();
  261.                 // 获取所有枚举实例
  262.                 enumConstants = aClass.getEnumConstants();
  263.                 dictMethod = aClass.getDeclaredMethod("getNameByRole", String.class);
  264.             }
  265.             ObjectLocal objectLocal = new ObjectLocal();
  266.             objectLocal.setWriteMethod(writeMethod);
  267.             objectLocal.setReadMethod(readMethod);
  268.             objectLocal.setCheckNotNull(checkNotNull);
  269.             objectLocal.setUniqueness(uniqueness);
  270.             objectLocal.setGenerativeCode(generativeCode);
  271.             objectLocal.setDictMethod(dictMethod);
  272.             objectLocal.setEnumConstants(enumConstants);
  273.             objectLocal.setValue(value);
  274.             objectLocal.setNewInstance(newInstance);
  275.             fieldMap.put(exa.exportName(), objectLocal);
  276.         }
  277.         if (isExist) {
  278.             // 默认值
  279.             String value = eValue.value();
  280.             String fieldName2 = field.getName();
  281.             PropertyDescriptor propertyDescriptor2 = new PropertyDescriptor(fieldName2, clazz);
  282.             Method writeMethod2 = propertyDescriptor2.getWriteMethod();
  283.             if (!StringUtil.isNullOrEmpty(value)) {
  284.                 writeMethod2.invoke(newInstance, value);
  285.             } else {
  286.                 // 内部对象
  287.                 Class<?> type = field.getType();
  288.                 // 内部对象
  289.                 Object instance = type.newInstance();
  290.                 for (Field declaredField : type.getDeclaredFields()) {
  291.                     putMap(type, fieldMap, declaredField, instance, childrenSetMap);
  292.                 }
  293.                 // 内部对象set进包裹对象
  294.                 childrenSetMap.put("children", new Object[]{writeMethod2, newInstance, instance});
  295.             }
  296.         }
  297.     }
  299.     /**
  300.      * 解析excel
  301.      *
  302.      * @param workbook     工作簿
  303.      * @param zjdspDrlsLog 日志
  304.      * @param sheets       工作表
  305.      * @return 解析的数据
  306.      */
  307.     public static List<Object> parseExcel(Workbook workbook, ZjdspDrlsLog zjdspDrlsLog, String xzqdm, String token,
  308.                                           StopWatch watch, String... sheets) {
  309.         List<Object> resultList = new CopyOnWriteArrayList<>();
  310.         List<Object> resultList2 = new CopyOnWriteArrayList<>();
  311.         // 返回的真实行数
  312.         AtomicInteger realRow = new AtomicInteger(0);
  313.         // 连续空行数
  314.         AtomicInteger emptyRow = new AtomicInteger(0);
  315.         // 失败行数
  316.         AtomicInteger failureRow = new AtomicInteger(0);
  317.         // 主体内容，包括成功条数和失败条数，失败原因，以及失败的数据
  318.         List<ContentVo> contentVoList = new ArrayList<>();
  319.         Database zjdsjjgDb = new Database(AppConfig.zjdsjjg_db);
  320.         // 解析sheet
  322.         for (String sheet : sheets) {
  323.             try {
  324.                 String clazzName = ExcelEnum.getNameByRole(sheet);
  325.                 Class<?> classType = Class.forName(clazzName);
  326.                 Object catObj = classType.newInstance();
  327.                 TableName tableName = catObj.getClass().getAnnotation(TableName.class);
  328.                 String table = tableName.value();
  329.                 // 获取自定义注解的信息
  330.                 List<Object> list = getFieldMap(classType, catObj);
  331.                 Map<String, ObjectLocal> fieldMap = (Map<String, ObjectLocal>) list.get(0);
  332.                 SimpleObject simpleObject = new SimpleObject();
  333.                 Map<String, String> ruleMap = new HashMap<>(10);
  334.                 Sheet wbSheet = workbook.getSheet(sheet);
  335.                 // 校验sheet是否合法
  336.                 if (sheet == null) {
  337.                     // 设置导入状态为失败
  338.                     zjdspDrlsLog.setHandleType(ExcelConstants.EXCEL_TYPE_ERROR);
  339.                     // 设置导入类型
  340.                     zjdspDrlsLog.setGrade(ExcelConstants.EXCEL_GRADE_ERROR);
  341.                     // 设置失败原因
  342.                     zjdspDrlsLog.setContent("解析Excel失败，该sheet不存在！");
  343.                     continue;
  344.                 }
  345.                 // 获取第一行数据
  346.                 int firstRowNum = wbSheet.getFirstRowNum();
  347.                 Row firstRow = wbSheet.getRow(firstRowNum);
  348.                 if (null == firstRow) {
  349.                     LogUtils.warn("解析Excel失败，在第一行没有读取到任何数据！");
  350.                     // 设置导入状态为失败
  351.                     zjdspDrlsLog.setHandleType(ExcelConstants.EXCEL_TYPE_ERROR);
  352.                     // 设置导入类型
  353.                     zjdspDrlsLog.setGrade(ExcelConstants.EXCEL_GRADE_ERROR);
  354.                     // 设置失败原因
  355.                     zjdspDrlsLog.setContent("解析Excel失败，在第一行没有读取到任何数据！");
  356.                     continue;
  357.                 }
  358.                 // 第二行数据
  359.                 int startRow = firstRowNum + 2;
  360.                 // 获取物理行数，不包括空行或隔行
  361.                 int lastRowNum = wbSheet.getLastRowNum();
  362.                 if (lastRowNum > 1000) {
  363.                     lastRowNum = 1000;
  364.                 }
  366.                 // 取得标题头行
  367.                 Row titleRow = wbSheet.getRow(1);
  368.                 // 得到第一行的所有列
  369.                 Iterator<Cell> cellTitle = titleRow.cellIterator();
  370.                 // 将标题的文字内容放入到一个map中。
  371.                 Map<Integer, String> titleMap = new HashMap<>(16);
  372.                 // 循环标题所有的列
  373.                 for (int i = 0; cellTitle.hasNext(); i++) {
  374.                     Cell cell = cellTitle.next();
  375.                     if (cell == null) {
  376.                         continue;
  377.                     }
  378.                     String value = cell.getStringCellValue().trim();
  379.                     titleMap.put(i, value);
  380.                 }
  381.                 int titleSize = titleMap.size();
  382.                 // 计算有内容行
  383.                 for (int i = startRow; i <= lastRowNum; i++) {
  384.                     Row row = wbSheet.getRow(i);
  385.                     // 连续空行数超过一百行，跳过后续内容
  386.                     int emptyRowToInt = emptyRow.get();
  387.                     if (emptyRowToInt >= 100) {
  388.                         break;
  389.                     }
  390.                     if (null == row) {
  391.                         emptyRow.getAndIncrement();
  392.                         continue;
  393.                     }
  394.                     // 连续空行列数
  395.                     AtomicInteger emptyColumn = new AtomicInteger(0);
  396.                     // 遍历一行的列
  397.                     for (int rowNum = 0; rowNum < titleSize; rowNum++) {
  398.                         Cell cell = row.getCell(rowNum);
  399.                         if (cell == null || CellType.BLANK == cell.getCellTypeEnum()) {
  400.                             emptyColumn.incrementAndGet();
  401.                             int i2 = emptyColumn.get();
  402.                             // 连续空行列数大于标题数，空行数加一
  403.                             if (i2 >= titleSize) {
  404.                                 emptyRow.getAndIncrement();
  405.                             }
  406.                         }
  407.                     }
  408.                     if (emptyRow.get() <= 0) {
  409.                         realRow.getAndIncrement();
  410.                     }
  411.                 }
  413.                 // 解析内容行
  414.                 for (int i = 0; i < realRow.get(); i++) {
  415.                     int traverse = startRow + i;
  416.                     Row row = wbSheet.getRow(traverse);
  417.                     boolean checkAndConvert = true;
  418.                     // 解析内容列
  419.                     for (int rowNum = 0; rowNum < titleSize; rowNum++) {
  420.                         Cell cell = row.getCell(rowNum);
  421.                         // 对应的标题
  422.                         String title = titleMap.get(rowNum);
  423.                         // 拥有的字段mao和Excel的标题匹配
  424.                         if (fieldMap.containsKey(title)) {
  425.                             ObjectLocal obj = fieldMap.get(title);
  426.                             ObjectLocal objectLocal = obj;
  427.                             // 不为空检查
  428.                             boolean checkNotNull = obj.isCheckNotNull();
  429.                             if (cell == null || CellType.BLANK == cell.getCellTypeEnum()) {
  430.                                 // 检验数据是否合法
  431.                                 if (checkNotNull) {
  432.                                     // 日志记录（失败的导入）
  433.                                     checkContent(failureRow, contentVoList, title, "", ExcelConstants.CHECK_NOT_NULL);
  434.                                     realRow.incrementAndGet();
  435.                                     continue;
  436.                                 }
  437.                             }
  439.                             // 父类实例化对象
  440.                             checkAndConvert = checkAndConvert(cell, objectLocal, zjdsjjgDb, failureRow, contentVoList, title
  441.                                     , ruleMap, xzqdm, token, table);
  442.                         }
  443.                     }
  444.                     if (checkAndConvert){
  445.                         // 子类set进父类
  446.                         Map<String, Object[]> childrenSetMap = (Map<String, Object[]>) list.get(1);
  447.                         Object[] children = childrenSetMap.get("children");
  448.                         //Method writeMethod = (Method) children[0];
  449.                         Object newInstance = children[1];
  450.                         Object instance = children[2];
  451.                         Object[] newInstanceObjects = childrenSetMap.get(newInstance.getClass().getSimpleName());
  452.                         Object[] instanceObjects = childrenSetMap.get(instance.getClass().getSimpleName());
  453.                         Method instanceReadMethod = (Method) newInstanceObjects[0];
  454.                         Method newInstanceWriteMethod = (Method) instanceObjects[0];
  455.                         // zjdxx.setZjddm(zjdzd.getZjddm)
  456.                         newInstanceWriteMethod.invoke(instance, instanceReadMethod.invoke(newInstance));
  457.                         //writeMethod.invoke(newInstance, instance);
  458.                         simpleObject.setInstance(instance);
  459.                         simpleObject.setNewInstance(newInstance);
  460.                         SimpleObject simpleObject2 = SerializationUtils.clone(simpleObject);
  461.                         if (simpleObject2.getInstance() != null) {
  462.                             resultList2.add(simpleObject2.getInstance());
  463.                         }
  464.                         resultList.add(simpleObject2.getNewInstance());
  465.                     }
  466.                 }
  467.                 try {
  468.                     zjdsjjgDb.BeginTransaction();
  469.                     String newInstanceSql = SqlTool.genSqlInsert(simpleObject.getNewInstance(),
  470.                             resultList.size());
  471.                     if (resultList2.size() > 0) {
  472.                         String instanceSql = SqlTool.genSqlInsert(simpleObject.getInstance(), resultList2.size());
  473.                         Object[] resultColumn = SqlTool.genColumn(resultList2);
  474.                         zjdsjjgDb.executeUpdate(instanceSql, resultColumn);
  475.                     }
  476.                     zjdsjjgDb.executeUpdate(newInstanceSql, SqlTool.genColumn(resultList));
  477.                     zjdsjjgDb.CompleteTransaction();
  478.                 } catch (Exception e) {
  479.                     zjdsjjgDb.AbortTransaction();
  480.                     e.printStackTrace();
  481.                 }
  485.                 // 日志记录 （导入总数）
  486.                 LogUtils.info("》》》》" + sheet + ",共有：" + realRow + "行");
  487.                 zjdspDrlsLog.setGrade(ExcelConstants.EXCEL_GRADE_INFO);
  488.                 zjdspDrlsLog.setHandleType(ExcelConstants.EXCEL_TYPE_INFO);
  489.                 String dataCount = String.format("》》》》 %s工作簿,总共有{ %s }条数据", sheet, realRow);
  490.                 zjdspDrlsLog.setDataCount(dataCount);
  491.                 int failureRowToInt = failureRow.get();
  492.                 int realRowToInt = realRow.get();
  493.                 int result = realRowToInt - failureRowToInt;
  494.                 String contentStr = JSON.toJSON(contentVoList).toString();
  495.                 String content = String.format("入库成功{ %s }条，导入失败{ %s }条。导入失败原因：%s", result, failureRowToInt,
  496.                         contentStr);
  497.                 zjdspDrlsLog.setContent(content);
  499.             } catch (Exception e) {
  500.                 // 设置导入状态为失败
  501.                 zjdspDrlsLog.setHandleType(ExcelConstants.EXCEL_TYPE_ERROR);
  502.                 // 设置导入类型
  503.                 zjdspDrlsLog.setGrade(ExcelConstants.EXCEL_GRADE_ERROR);
  504.                 // 设置失败原因
  505.                 zjdspDrlsLog.setContent(e.getMessage());
  506.                 throw new RuntimeException(e);
  507.             } finally {
  508.                 try {
  509.                     watch.stop();
  510.                     zjdspDrlsLog.setTotalTime("总共耗时：" + watch.getTotalTimeSeconds() + "秒");
  511.                     zjdsjjgDb.BeginTransaction();
  512.                     zjdsjjgDb.insert(zjdspDrlsLog);
  513.                     zjdsjjgDb.CompleteTransaction();
  514.                 } catch (Exception e) {
  515.                     zjdsjjgDb.AbortTransaction();
  516.                     e.printStackTrace();
  517.                 }
  519.                 try {
  520.                     workbook.close();
  521.                 } catch (IOException e) {
  522.                     throw new RuntimeException(e);
  523.                 }
  524.             }
  525.         }
  527.         return resultList;
  528.     }
  530.     private static void checkContent(AtomicInteger failureRow, List<ContentVo> contentVoList, String titleString,
  531.                                      String cellValue, String reason) {
  532.         ContentVo contentVo = new ContentVo();
  533.         failureRow.getAndIncrement();
  534.         // 失败的数据关键字
  535.         contentVo.setKey(titleString + "：" + cellValue);
  536.         // 失败原因
  537.         contentVo.setReason(reason);
  538.         contentVoList.add(contentVo);
  539.     }
  541.     private static boolean checkAndConvert(Cell cell, ObjectLocal obj, Database zjdsjjgDb, AtomicInteger failureRow,
  542.                                           List<ContentVo> contentVoList, String titleString,
  543.                                           Map<String, String> ruleMap, String xzqdm, String token, String table) throws IllegalAccessException, InvocationTargetException {
  544.         // set方法
  545.         Method setMethod = obj.getWriteMethod();
  546.         // 字典
  547.         Method dictMethod = obj.getDictMethod();
  548.         // 父类实例化对象
  549.         Object clazz = obj.getNewInstance();
  550.         // 枚举类实例化对象
  551.         Enum[] anEnum = obj.getEnumConstants();
  552.         // 唯一性检查
  553.         boolean uniqueness = obj.isUniqueness();
  554.         // 可生成性检查
  555.         String rule = obj.getGenerativeCode();
  556.         // 数据库映射值
  557.         String column = obj.getValue();
  558.         // 检验数据是否合法
  559.         if (uniqueness) {
  560.             // 检查唯一性
  561.             String cellValue = cell.getStringCellValue();
  562.             String sqlFormat = "select %s from %s where %s = ?";
  563.             String sql = String.format(sqlFormat, column.toLowerCase(), table, column.toLowerCase());
  564.             // 查询数据库
  565.             String index = zjdsjjgDb.firstOrDefault(String.class, sql, cellValue);
  566.             if (!StringUtil.isNullOrEmpty(index)) {
  567.                 // 唯一性检查失败
  568.                 // 日志记录
  569.                 LogUtils.info("》》》》" + cellValue + "已存在，请检查");
  570.                 // 失败内容
  571.                 checkContent(failureRow, contentVoList, titleString, cellValue, ExcelConstants.CHECK_NOT_UNIQUENESS);
  572.                 return false;
  573.             } else {
  574.                 // 唯一性检查成功
  575.                 // 将有唯一性的数据放入Map集合
  576.                 // map存放 <数据库映射值, 单元格值>
  577.                 ruleMap.put(column, cellValue);
  578.                 if (StringUtil.isNullOrEmpty(cellValue)) {
  579.                     if (!StringUtil.isNullOrEmpty(rule)) {
  580.                         // 检查可生成性
  581.                         if (ruleMap.containsKey(rule)) {
  582.                             // 根据集合中的唯一性数据生成对应的数据
  583.                             // 那么生成规则是什么呢?
  584.                             String genRule = ruleMap.get(rule);
  585.                             GetWhAdapterProvider whAdapterProvider = new GetWhAdapterProviderImpl();
  586.                             String wh = whAdapterProvider.getWh(column, xzqdm, genRule, token);
  587.                             setMethod.invoke(clazz, wh);
  588.                         }
  589.                     } else {
  590.                         // 不检查可生成性
  591.                         convert(cell, setMethod, dictMethod, clazz, anEnum);
  592.                     }
  593.                 } else {
  594.                     // 不检查可生成性
  595.                     convert(cell, setMethod, dictMethod, clazz, anEnum);
  596.                 }
  597.             }
  598.         } else {
  599.             convert(cell, setMethod, dictMethod, clazz, anEnum);
  600.         }
  601.         return true;
  602.     }
  604.     private static void convert(Cell cell, Method setMethod, Method dictMethod, Object clazz, Enum[] anEnum) throws IllegalAccessException, InvocationTargetException {
  605.         // 得到setter方法的参数
  606.         Type[] ts = setMethod.getGenericParameterTypes();
  607.         String xclass = ts[0].toString();
  608.         // 判断参数类型
  609.         if ("class java.lang.String".equals(xclass)) {
  610.             // 拥有字典的场合
  611.             if (null != dictMethod) {
  612.                 // 字典映射后的value enum实例化对象
  613.                 Object dictValue = dictMethod.invoke(anEnum, convertCellValueToString(cell));
  614.                 setMethod.invoke(clazz, dictValue);
  615.             } else {
  616.                 setMethod.invoke(clazz, convertCellValueToString(cell));
  617.             }
  618.         } else if ("class java.util.Date".equals(xclass)) {
  619.             setMethod.invoke(clazz, !StringUtil.isNullOrEmpty(convertCellValueToString(cell)) ?
  620.                     DataTimeTool.StrToDate(convertCellValueToString(cell)) : null);
  621.         } else if ("class java.lang.Boolean".equals(xclass)) {
  622.             setMethod.invoke(clazz, convertCellValueToString(cell));
  623.         } else if ("class java.lang.Integer".equals(xclass)) {
  624.             setMethod.invoke(clazz, !StringUtils.isBlank(convertCellValueToString(cell)) ?
  625.                     Integer.parseInt(convertCellValueToString(cell)) : 0);
  626.         } else if ("class java.lang.Long".equals(xclass)) {
  627.             setMethod.invoke(clazz, convertCellValueToString(cell));
  628.         } else if ("class java.lang.Double".equals(xclass)) {
  629.             setMethod.invoke(clazz, !StringUtils.isBlank(convertCellValueToString(cell)) ?
  630.                     Double.parseDouble(convertCellValueToString(cell)) : 0D);
  631.         } else if ("class java.lang.Object".equals(xclass)) {
  632.             setMethod.invoke(clazz, convertCellValueToString(cell));
  633.         }
  634.     }
  636.     /**
  637.      * 根据文件后缀名类型获取对应的工作簿对象
  638.      *
  639.      * @param multipartFile 导入的文件
  640.      * @return 包含文件数据的工作簿对象
  641.      */
  642.     public static Workbook getWorkBook(MultipartFile multipartFile) {
  643.         //获得文件名
  644.         String fileName = multipartFile.getOriginalFilename();
  645.         Workbook workbook = null;
  646.         try {
  647.             InputStream ips = multipartFile.getInputStream();
  648.             if (Objects.requireNonNull(fileName).endsWith(ExcelConstants.EXCEL_XLSX_TYPE)) {
  649.                 //2007 及2007以上
  650.                 workbook = new XSSFWorkbook(ips);
  651.             } else if (fileName.endsWith(ExcelConstants.EXCEL_XLS_TYPE)) {
  652.                 //2003
  653.                 workbook = new HSSFWorkbook(ips);
  654.             } else {
  655.                 throw new NoSuchMethodError("没有能够处理此文件的方法");
  656.             }
  657.         } catch (IOException e) {
  658.             e.getMessage();
  659.         }
  660.         return workbook;
  661.     }
  663.     /**
  664.      * 检查文件类型
  665.      *
  666.      * @param file 导入的文件
  667.      * @return 是否是XLS或XLSX文件
  668.      */
  669.     public static boolean checkFile(MultipartFile file) {
  670.         //判断文件是否存在
  671.         if (null == file) {
  672.             return false;
  673.         }
  674.         //获得文件名
  675.         String fileName = file.getOriginalFilename();
  676.         //判断文件是否是excel文件
  677.         return Objects.requireNonNull(fileName).endsWith(ExcelConstants.EXCEL_XLSX_TYPE) || fileName.endsWith(ExcelConstants.EXCEL_XLS_TYPE);
  678.     }
  679. }
  681. class SimpleObject implements Serializable {
  682.     private Object newInstance;
  684.     private Object instance;
  686.     public Object getInstance() {
  687.         return instance;
  688.     }
  690.     public void setInstance(Object instance) {
  691.         this.instance = instance;
  692.     }
  694.     public Object getNewInstance() {
  695.         return newInstance;
  696.     }
  698.     public void setNewInstance(Object newInstance) {
  699.         this.newInstance = newInstance;
  700.     }
  701. }
public class ObjectLocal implements Serializable {

    private Method writeMethod;
    private Method readMethod;
    private boolean checkNotNull;
    private boolean uniqueness;
    private String generativeCode;
    private Method dictMethod;
    private Enum[] enumConstants;
    private String value;
    private Object newInstance;

    public Method getWriteMethod() {
        return writeMethod;
    }

    public void setWriteMethod(Method writeMethod) {
        this.writeMethod = writeMethod;
    }

    public Method getReadMethod() {
        return readMethod;
    }

    public void setReadMethod(Method readMethod) {
        this.readMethod = readMethod;
    }

    public boolean isCheckNotNull() {
        return checkNotNull;
    }

    public void setCheckNotNull(boolean checkNotNull) {
        this.checkNotNull = checkNotNull;
    }

    public boolean isUniqueness() {
        return uniqueness;
    }

    public void setUniqueness(boolean uniqueness) {
        this.uniqueness = uniqueness;
    }

    public String getGenerativeCode() {
        return generativeCode;
    }

    public void setGenerativeCode(String generativeCode) {
        this.generativeCode = generativeCode;
    }

    public Method getDictMethod() {
        return dictMethod;
    }

    public void setDictMethod(Method dictMethod) {
        this.dictMethod = dictMethod;
    }

    public Enum[] getEnumConstants() {
        return enumConstants;
    }

    public void setEnumConstants(Enum[] enumConstants) {
        this.enumConstants = enumConstants;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Object getNewInstance() {
        return newInstance;
    }

    public void setNewInstance(Object newInstance) {
        this.newInstance = newInstance;
    }
}

参照连接：https://blog.csdn.net/fangchao2011/article/details/105534252
https://blog.csdn.net/lbq15735104044/article/details/108980532