excel导入 Easy Excel

依旧是框架感觉有东西，但是确实是模拟不出来，各种零零散散的件太多了

controller层

  @ApiOperation(value = "导入Excel", notes = "导入Excel", httpMethod = "POST", response = ExcelResponseDTO.class)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "X-Person-Id", value = "登录人ID", paramType = "header", dataType = "long", required = true),
            @ApiImplicitParam(name = "X-Person-Name", value = "登录人姓名", paramType = "header", dataType = "string", required = true),
            @ApiImplicitParam(name = "X-Data-Permission", value = "数据安全性", paramType = "header", dataType = "String", required = true),
            @ApiImplicitParam(name = "X-Business-Group-Id", value = "用户所属业务组编号", paramType = "header", dataType = "long", required = true, defaultValue = "1001"),
            @ApiImplicitParam(name = "multipartFile", value = "附件", dataType = "__file", required = true),
            @ApiImplicitParam(name = "modelType", value = "导入模块标示,严格大小写,例如:BaseInfo", dataType = "string", required = true)
    })
    @ApiResponses({
            @ApiResponse(code = 204, message = "导入失败"),
            @ApiResponse(code = 200, message = "导入成功")
    })
    @PostMapping("/excel/{modelType}")
    public ResponseEntity<Object> excel(
            @RequestHeader("X-Person-Id") Long xPersonId,
            @RequestHeader("X-Person-Name") String xPersonName,
            @RequestHeader("X-Data-Permission") String dataPermission,
            @RequestHeader("X-Business-Group-Id") Long xBusinessGroupId,
            @RequestPart("multipartFile") MultipartFile multipartFile,
            @PathVariable("modelType") String modelType,
            @RequestParam(value = IMPORT_PARAM_MAP_K1, required = false) String param1,
            @RequestParam(value = IMPORT_PARAM_MAP_K2, required = false) String param2,
            @RequestParam(value = IMPORT_PARAM_MAP_K3, required = false) String param3,
            @RequestParam(value = IMPORT_PARAM_MAP_K4, required = false) String param4,
            @RequestParam(value = IMPORT_PARAM_MAP_K5, required = false) String param5) {
        if (!multipartFile.getOriginalFilename().endsWith(EXCEL_SUFFIX_XLSX) &&
                !multipartFile.getOriginalFilename().endsWith(EXCEL_SUFFIX_XLS)) {
            return new ResponseEntity<>(new MessageResponse("导入暂时只支持[" + EXCEL_SUFFIX_XLSX + "]或[" + EXCEL_SUFFIX_XLS + "]格式的文件！"), HttpStatus.NOT_FOUND);
        }
        Map<String, String> paramMap = fillParamMap(dataPermission,param1, param2, param3, param4, param5);
        /**
         * 导入逻辑
         * 1.上传文件到aws
         * 2.存储上传记录到redis
         * 3.异步请求获取导入记录
         * 4.从记录中获取需要执行的记录
         * 5.执行记录并把进度放入redis
         */
        try {
            Class<?> iClass = this.foundClass(modelType);
            ExcelResponseDTO excelResponseDTO = excelResponseService.buildExcelResponse(xPersonId, xPersonName, xBusinessGroupId, multipartFile,this.getRequestHeaderContext());
            importService.importExcel(excelResponseDTO, iClass, paramMap);
            return ResponseEntity.ok(excelResponseDTO);
        } catch (ClassNotFoundException e) {
            log.error("com.chinaunicom.ihr.coreperson.web.ImportController.excel", e);
            return new ResponseEntity<>(new MessageResponse("导入模块未找到！"), HttpStatus.NOT_FOUND);
        } catch (Exception e) {
            log.error("com.chinaunicom.ihr.coreperson.web.ImportController.excel", e);
            return new ResponseEntity<>(new MessageResponse("系统暂时不支持上传,请联系管理员！"), HttpStatus.NOT_FOUND);
        }
    }

我们一块一块的分析。
首先开始时对于excel不同的版本的一个处理

        if (!multipartFile.getOriginalFilename().endsWith(EXCEL_SUFFIX_XLSX) &&
                !multipartFile.getOriginalFilename().endsWith(EXCEL_SUFFIX_XLS)) {
            return new ResponseEntity<>(new MessageResponse("导入暂时只支持[" + EXCEL_SUFFIX_XLSX + "]或[" + EXCEL_SUFFIX_XLS + "]格式的文件！"), HttpStatus.NOT_FOUND);
        }

然后是将接口传入的参数储存进map中便于后续调用

Map<String, String> paramMap = fillParamMap(dataPermission,param1, param2, param3, param4, param5);

因为这个导入是一个通用方法，传入不同的实体类名称，去读取制定的类

Class<?> iClass = this.foundClass(modelType);

    private Class foundClass(String modelType) throws ClassNotFoundException {
        // 获取模块 加载 com.chinaunicom.ihr.coreperson.dao.excel.domain. 下的导入类
        return Class.forName(IMPORT_DOMAIN_PACKAGE_NAME + "." + modelType + "Import");
    }

这是所有的导入的类，

@Getter
@Setter
@ToString
@ExcelImportServiceTag(PersonBaseInfoImportService.class)
@CloseImportOperateStatus(closeDelete = true, closeUpdate = true, closeRenew = false, closeModify = false)
public class PersonBaseInfoNewImport {
    @IdVerify(PersonBaseInfoService.class)
    @ExcelProperty(value = "数据唯一标识", index = 0)
    protected String id;

    @OperateStatusVerify
    @ExcelProperty(value = "操作状态[创建,更正,更新]", index = 1)
    protected String operateStatus;

    /**
     * 使用操作日期作为生效日期
     * 生效日期就是加入本企业日期
     */
    @NotEmptyVerify
    @ExcelProperty(value = "生效日期（*）(日期格式:1990/1/1)" + YELLOW_CELL_SUFFIX, index = 2)
    protected String operateDate;

    /**
     * 证件类型
     */
    @GlobalLookupCodeInfoVerify(value = "证件类型有误;", lookupType = LookupType.PERSON_ID_CARD_TYPE)
    @ExcelProperty(value = "证件类型（*）" + YELLOW_CELL_SUFFIX, index = 3)
    private String idCardType;
    /**
     * 证件编号
     */
    @IdCardNumberVerify
    @ExcelProperty(value = "证件编号（*）" + YELLOW_CELL_SUFFIX, index = 4)
    private String idCardNumber;

    /**
     * 是否残疾人
     */
    @BooleanVerify("是否残疾人有误;")
    @ExcelProperty(value = "是否残疾人（*）(是/否)" + YELLOW_CELL_SUFFIX, index = 5)
    private String handicapped;

    /**
     * 是否外籍人员
     */
    @BooleanVerify("是否外籍人员有误;")
    @ExcelProperty(value = "是否外籍人员（*）(是/否)" + YELLOW_CELL_SUFFIX, index = 6)
    private String foreigner;

    /**
     * 员工编号
     */
    @CreateCanEmptyVerify("员工编号不能为空;")
    @PersonNoUniqueVerify
    @ExcelProperty(value = "员工编号（*）" + YELLOW_CELL_SUFFIX, index = 7)
    private String employeeNumber;

    /**
     * 姓名
     */
    @NotEmptyVerify
    @ExcelProperty(value = "姓名（*）" + YELLOW_CELL_SUFFIX, index = 8)
    private String chineseName;

    /**
     * 英文名
     */
    @ExcelProperty(value = "英文名", index = 9)
    private String englishName;

    /**
     * 用工性质
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "用工性质有误;", lookupType = LookupType.PERSON_EMPLOYMENT_NATURE)
    @EmploymentNatureVerify
    @ExcelProperty(value = "用工性质（*）" + YELLOW_CELL_SUFFIX, index = 10)
    private String employmentNature;

    /**
     * 性别:1 男 0 女
     */
    @SexVerify("性别有误;")
    @ExcelProperty(value = "性别（*）(1/男 0/女)" + YELLOW_CELL_SUFFIX, index = 11)
    private String sex;

    /**
     * 婚姻状况
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "婚姻状况有误;", lookupType = LookupType.PERSON_MARITAL_STATUS)
    @ExcelProperty(value = "婚姻状况（*）" + YELLOW_CELL_SUFFIX, index = 12)
    private String maritalStatus;

    /**
     * 出生日期
     */
    @NotEmptyVerify
    @DateVerify("出生日期有误;")
    @ExcelProperty(value = "出生日期（*）(日期格式:1990/1/1)" + YELLOW_CELL_SUFFIX, index = 13)
    private String dateOfBirth;

    /**
     * 国籍
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "国籍有误;", lookupType = LookupType.PERSON_NATIONALITY)
    @ExcelProperty(value = "国籍（*）" + YELLOW_CELL_SUFFIX, index = 14)
    private String nationality;

    /**
     * 民族
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "民族有误;", lookupType = LookupType.PERSON_ETHNICITY)
    @ExcelProperty(value = "民族（*）" + YELLOW_CELL_SUFFIX, index = 15)
    private String ethnicity;

    /**
     * 籍贯
     */
    @NotEmptyVerify
    @ExcelProperty(value = "籍贯（*）" + YELLOW_CELL_SUFFIX, index = 16)
    private String nativePlace;

    /**
     * 出生地
     */
    @ExcelProperty(value = "出生地", index = 17)
    private String townOfBirth;

    /**
     * 户籍所在地
     */
    @ExcelProperty(value = "户籍所在地", index = 18)
    private String domicile;

    /**
     * 政治面貌
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "政治面貌;", lookupType = LookupType.PERSON_POLITICAL)
    @ExcelProperty(value = "政治面貌（*）" + YELLOW_CELL_SUFFIX, index = 19)
    private String political;

    /**
     * 公司邮箱
     */
    @ExcelProperty(value = "公司邮箱", index = 20)
    private String officeEmail;

    /**
     * 手机号码
     */
    @NotEmptyVerify
    @MobilePhoneNoVerify
    @ExcelProperty(value = "手机号码（*）" + YELLOW_CELL_SUFFIX, index = 21)
    private String phoneNumber;

    /**
     * 个人邮箱
     */
    @ExcelProperty(value = "个人邮箱", index = 22)
    private String personEmail;

    /**
     * 最高学历
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "最高学历有误;", lookupType = LookupType.PERSON_HIGHEST_EDUCATION)
    @ExcelProperty(value = "最高学历（*）" + YELLOW_CELL_SUFFIX, index = 23)
    private String highestEducation;

    /**
     * 是否职业经理人 （1 是 0 否）
     */
    @NotEmptyVerify
    @ProfessionalManageVerify("是否职业经理人有误;")
    @ExcelProperty(value = "是否职业经理人（*）" + YELLOW_CELL_SUFFIX, index = 24)
    private String professionalManager;

    /**
     * 学历类型
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "学历类型有误;", lookupType = LookupType.EDUCATION_TYPE)
    @ExcelProperty(value = "学历类型（*）" + YELLOW_CELL_SUFFIX, index = 25)
    private String educationType;

    /**
     * 最高学位
     */
    @GlobalLookupCodeInfoVerify(value = "最高学位有误;", lookupType = LookupType.PERSON_HIGHEST_DEGREE)
    @ExcelProperty(value = "最高学位", index = 26)
    private String highestDegree;

    /**
     * 参加工作日期
     */
    @NotEmptyVerify
    @DateVerify("参加工作日期有误;")
    @ExcelProperty(value = "参加工作日期(日期格式:1990/1/1)（*）" + YELLOW_CELL_SUFFIX, index = 27)
    private String dateOfWork;

    /**
     * 社会工龄调整值（月）
     */
    @IntegerVerify("社会工龄调整值有误;")
    @ExcelProperty(value = "社会工龄调整值（月）", index = 28)
    private String dateOfWorkAdj;

    /**
     * 企业工龄调整值（月）
     */
    @IntegerVerify("企业工龄调整值有误;")
    @ExcelProperty(value = "企业工龄调整值（月）", index = 29)
    private String dateOfJoinAdj;

    /**
     * 加入本企业途径
     */
    @GlobalLookupCodeInfoVerify(value = "加入本企业途径有误;", lookupType = LookupType.PERSON_WAY_TO_JOIN)
    @ExcelProperty(value = "加入本企业途径", index = 30)
    private String wayToJoin;

    /**
     * 劳务派遣入本企业日期
     */
    @DateVerify("劳务派遣入本企业日期有误;")
    @ExcelProperty(value = "劳务派遣入本企业日期(日期格式:1990/1/1)", index = 31)
    private String dateOfLaborDispatch;

    /**
     * 劳务派遣工龄调整值（月）
     */
    @IntegerVerify("劳务派遣工龄调整值有误;")
    @ExcelProperty(value = "劳务派遣工龄调整值（月）", index = 32)
    private String dateOfLaborDispatchAdj;

    /**
     * 部门
     */
    @NotEmptyVerify
    @OrgCodeVerify
    @ExcelProperty(value = "部门编码（*）" + YELLOW_CELL_SUFFIX, index = 33)
    private String orgCode;
    @ExcelProperty(value = "部门名称", index = 34)
    private String orgName;

    /**
     * 职位
     */
    @NotEmptyVerify
    @PositionCodeVerify
    @ExcelProperty(value = "职位编码（*）" + YELLOW_CELL_SUFFIX, index = 35)
    private String positionCode;
    @ExcelProperty(value = "职位名称", index = 36)
    private String positionName;
    /**
     * 职务
     */
    @JobCodeVerify
    @ExcelProperty(value = "职务编码", index = 37)
    private String jobCode;
    @ExcelProperty(value = "职务名称", index = 38)
    private String jobName;

    /**
     * 在岗类别
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "在岗类别有误;", lookupType = LookupType.PERSON_ON_DUTY_CATEGORY)
    @ExcelProperty(value = "在岗类别（*）" + YELLOW_CELL_SUFFIX, index = 39)
    private String onDutyCategory;

    /**
     * 人员类别
     */
    @GlobalLookupCodeInfoVerify(value = "人员类别有误;", lookupType = LookupType.PERSON_EMPLOYEE_CATEGORY)
    @ExcelProperty(value = "人员类别", index = 40)
    private String employeeCategory;

    /**
     * 上级主管
     */
    @SeniorRoleVerify
    @ExcelProperty(value = "上级主管员工编号", index = 41)
    private String seniorRoleNo;
    @ExcelProperty(value = "上级主管姓名", index = 42)
    private String seniorRoleName;

    /**
     * 岗级
     */
    @NotEmptyVerify
    @GlobalLookupCodeInfoVerify(value = "职位级别有误;", lookupType = LookupType.PERSON_GRADE)
    @ExcelProperty(value = "职位级别（*）" + YELLOW_CELL_SUFFIX, index = 43)
    private String grade;





    /**
     * 退伍时间
     */
    @DateVerify("退伍时间有误;")
    @ExcelProperty(value = "退伍时间", index = 44)
    private String dateOfDisbandment;

    /**
     * 党内职务
     */
    @GlobalLookupCodeInfoVerify(value = "党内职务有误;", lookupType = LookupType.PARTY_JOB)
    @ExcelProperty(value = "党内职务", index = 45)
    private String jobOnParty;

    /**
     * 工龄
     */
    @ExcelProperty(value = "工龄", index = 46)
    private String workYear;

    /**
     * 职位备注
     */
    @ExcelProperty(value = "职位备注", index = 47)
    private String positionRemark;

    @ExcelProperty(value = "报错提示", index = 48)
    protected String message;

}

这个实体类大有文章，我们先按照顺序看代码后续再回来看。

            ExcelResponseDTO excelResponseDTO = excelResponseService.buildExcelResponse(xPersonId, xPersonName, xBusinessGroupId, multipartFile,this.getRequestHeaderContext());

    /**
     * 构建一个 ExcelResponse
     *
     * @param xPersonId
     * @param xPersonName
     * @param xBusinessGroupId
     * @param multipartFile
     * @return
     */
    public ExcelResponseDTO buildExcelResponse(Long xPersonId, String xPersonName, Long xBusinessGroupId, MultipartFile multipartFile, RequestHeaderContext requestHeaderContext) {
        String url = uploadService.uploadFile(xPersonId, multipartFile);
        ExcelResponseDTO excelResponseDTO = new ExcelResponseDTO(xPersonId, xPersonName, xBusinessGroupId,
                url, multipartFile.getOriginalFilename(),requestHeaderContext);
        manageable.putExcelResponse(excelResponseDTO);
        return excelResponseDTO;
    }

实话说从开始一直没有看懂为啥要把导入的文件存起来，会占用空间吧，我能够理解的想法就是，这样可以不用将文件存储在内容中，然后再讲对象读取出来用于后续的导入以及校验，

importService.importExcel(excelResponseDTO, iClass, paramMap);

    public void importExcel(ExcelResponseDTO excelResponseDTO, Class<?> iClass, Map<String, String> paramMap) {
        // 导入上下文
        ExcelImportContext excelImportContext = new ExcelImportContext(iClass, excelResponseDTO.getPersonId(),
                excelResponseDTO.getPersonName(), excelResponseDTO.getBusinessGroupId(), paramMap);
        String url = uploadService.getRealPath(excelResponseDTO.getAddress());
        try (InputStream inputStream = new BufferedInputStream(new URL(url).openConnection().getInputStream())) {
            boolean bo = false;
            List<Class<?>> queue = Collections.singletonList(iClass);
            // 如果是多个，获取多个的导入类
            ExcelMultipleImportClassTag multipleImportClassTag = iClass.getAnnotation(ExcelMultipleImportClassTag.class);
            if (Objects.nonNull(multipleImportClassTag)) {
                queue = Arrays.asList(multipleImportClassTag.value());
                // 是否多sheet页对应同一个导入模板
                bo = multipleImportClassTag.mulSheet();
            }
            // 队列执行
            for (Class<?> ic : queue) {
                EasyExcel
                        .read(inputStream)
                        .head(ic)
                        .password(EasyExcelUtils.getPassword(ic))
                        .headRowNumber(EasyExcelUtils.getHeadRowNumber(ic))
                        .registerReadListener(new ImportVerifyEventListener(excelImportContext, excelResponseDTO))
                        .registerReadListener(new ImportObjectMapEventListener(excelImportContext))
                        .sheet(EasyExcelUtils.getSheetIndex(ic))
                        .doRead();
            }
            // 如果多sheet页对应同一导入类
            if (bo) {
                // 获取sheet页数量
                Workbook workbook = Workbook.getWorkbook(inputStream);
                Sheet[] sheets = workbook.getSheets();

                //
                for (int i = multipleImportClassTag.index(); i < sheets.length; i++) {
                    EasyExcel
                            .read(inputStream)
                            .head(multipleImportClassTag.mulSheetToTemplate())
                            .password(EasyExcelUtils.getPassword(multipleImportClassTag.mulSheetToTemplate()))
                            .headRowNumber(EasyExcelUtils.getHeadRowNumber(multipleImportClassTag.mulSheetToTemplate()))
                            .registerReadListener(new ImportVerifyEventListener(excelImportContext, excelResponseDTO))
                            .registerReadListener(new ImportObjectMapEventListener(excelImportContext))
                            .sheet(i-1)
                            .doRead();
                }
            }
        } catch (Exception e) {
            excelResponseDTO.setResult("导入出错,请检查与标准模板的差异或联系管理员");
            excelResponseService.importFailure(excelResponseDTO);
            log.error("com.chinaunicom.ihr.coreperson.service.BaseImportService.importExcel Exception:", e);
        }
    }

其实这一块才是主要去实现导入以及导入的字段的校验的地方，我也是用过easyexcel但是我感觉这个项目中是用的高级用法，包括easyexcel在官网的demo真的好简单

主要是这一块的两个类，去实现的具体的校验以及具体的导入

public class ImportVerifyEventListener extends AnalysisEventListener {

    /**
     * 处理 信息dto
     */
    private final ExcelResponseService excelResponseService;

    /**
     * 类验证字段之前处理器
     */
    private final List<VerifyProcess> classVerifyFieldBeforeList = new ArrayList<>();

    /**
     * 类验证字段之后处理器
     */
    private final List<VerifyProcess> classVerifyFieldAfterList = new ArrayList<>();

    /**
     * 字段验证处理器
     */
    private final Map<Integer, List<VerifyProcess>> fieldVerifyMap = new TreeMap<>();

    /**
     * 导入类 index 与 字段集合
     */
    private Map<Integer, Field> fieldMap = new TreeMap<>();

    /**
     * 导入上下文
     */
    private ExcelImportContext excelImportContext;
    /**
     * 导入 信息dto
     */
    private ExcelResponseDTO excelResponseDTO;
    /**
     * 当前的数据Map
     */
    private BeanMap currentDataBeanMap;
    /**
     * 所有已经读取出来的数据BeanMap（包含当前）
     */
    private List<BeanMap> dataBeanMapList = new ArrayList<>();
    /**
     * 所有的数据 Object 如果最后验证完无效，那么导出的就是这个List
     */
    private List<Object> dataList = new ArrayList<>();


    public ImportVerifyEventListener(ExcelImportContext excelImportContext, ExcelResponseDTO excelResponseDTO) {
        this.excelImportContext = excelImportContext;
        this.excelResponseDTO = excelResponseDTO;
        this.excelResponseService = SpringContextUtils.getApplicationContext().getBean(ExcelResponseService.class);
        this.initClassVerifyMap();
        this.initFieldMap();
        this.initFieldVerifyMap();
    }

    /**
     * 初始化类验证处理器
     */
    private void initClassVerifyMap() {
        for (Annotation annotation : excelImportContext.getImportClass().getAnnotations()) {
            VerifyProcessTag processTag = annotation.annotationType().getAnnotation(VerifyProcessTag.class);
            if (Objects.nonNull(processTag)) {
                if (processTag.fieldBefore()) {
                    classVerifyFieldBeforeList.add(buildClassVerifyProcess(processTag.processClass(), annotation, processTag.order()));
                }
                if (processTag.fieldAfter()) {
                    classVerifyFieldAfterList.add(buildClassVerifyProcess(processTag.processClass(), annotation, processTag.order()));
                }
            }
        }
        classVerifyFieldBeforeList.sort(Comparator.comparingInt(VerifyProcess::getOrder));
        classVerifyFieldAfterList.sort(Comparator.comparingInt(VerifyProcess::getOrder));
    }

    /**
     * 初始化字段Map
     *
     * @return
     */
    public void initFieldMap() {
        List<Field> fieldList = new ArrayList<>();
        // 当为空时即还没有初始化
        Class<?> tempClass = excelImportContext.getImportClass();
        while (tempClass != null) {
            Collections.addAll(fieldList, tempClass.getDeclaredFields());
            tempClass = tempClass.getSuperclass();
        }
        for (Field field : fieldList) {
            ExcelIgnore excelIgnore = field.getAnnotation(ExcelIgnore.class);
            if (excelIgnore != null) {
                continue;
            }
            ExcelProperty excelProperty = field.getAnnotation(ExcelProperty.class);
            if (excelProperty != null && excelProperty.index() >= 0) {
                fieldMap.put(excelProperty.index(), field);
            }
        }
    }

    /**
     * 初始化字段验证处理器
     */
    private void initFieldVerifyMap() {
        for (Map.Entry<Integer, Field> fieldEntry : fieldMap.entrySet()) {
            Field field = fieldEntry.getValue();
            List<VerifyProcess> processList = new ArrayList<>();
            for (Annotation annotation : field.getAnnotations()) {
                FieldVerifyProcessTag processTag = annotation.annotationType().getAnnotation(FieldVerifyProcessTag.class);
                if (Objects.nonNull(processTag)) {
                    processList.add(buildFieldVerifyProcess(processTag.processClass(), annotation, processTag.order(), field));
                }
            }
            processList.sort(Comparator.comparingInt(VerifyProcess::getOrder));
            fieldVerifyMap.put(fieldEntry.getKey(), processList);
        }
    }


    /**
     * 构造处理器
     *
     * @param processClass
     * @return
     */
    private AbstractVerifyProcess buildClassVerifyProcess(Class<? extends AbstractVerifyProcess> processClass, Annotation annotation, int order) {
        return ReflectUtil.newInstance(processClass, excelImportContext, annotation, order);
    }

    /**
     * 构造处理器
     *
     * @param processClass
     * @return
     */
    private AbstractFieldVerifyProcess buildFieldVerifyProcess(Class<? extends AbstractFieldVerifyProcess> processClass, Annotation annotation, int order, Field field) {
        return ReflectUtil.newInstance(processClass, excelImportContext, annotation, order, field);
    }

    @Override
    public void invoke(Object data, AnalysisContext context) {
        dataList.add(data);
        currentDataBeanMap = BeanMap.create(data);
        // 把代入的 message 去掉
        currentDataBeanMap.put(IMPORT_MESSAGE_FIELD_NAME, null);
        dataBeanMapList.add(currentDataBeanMap);
        // 把 data 转换为 Map 并且去掉 null 值
        Map<String, Object> objectMap = BeanUtil.beanToMap(data, false, true);

        // 字段之前验证的类验证
        eachVerifyMap(objectMap, classVerifyFieldBeforeList);
        // 字段验证
        // 根据字段顺序处理
        for (Map.Entry<Integer, List<VerifyProcess>> verifyEntry : fieldVerifyMap.entrySet()) {
            // 根据处理器顺序处理
            eachVerifyMap(objectMap, verifyEntry.getValue());
        }

        // 字段之后验证的类验证
        eachVerifyMap(objectMap, classVerifyFieldAfterList);

        Object message = objectMap.get(IMPORT_MESSAGE_FIELD_NAME);
        if (Objects.nonNull(message) && CollectionUtils.isNotEmpty((List) message)) {
            currentDataBeanMap.put(IMPORT_MESSAGE_FIELD_NAME, String.join("", (List) message));
            excelImportContext.setInvalid(Boolean.TRUE);
        }
        context.readRowHolder().setCurrentRowAnalysisResult(objectMap);
    }

    /**
     * 循环验证
     *
     * @param objectMap
     * @param verifyList
     */
    private void eachVerifyMap(Map<String, Object> objectMap, List<VerifyProcess> verifyList) {
        // 字段之后验证的类验证
        for (VerifyProcess verifyProcess : verifyList) {
            // 只要有一个跳过那么就都跳过
            if (verifyProcess.skip(currentDataBeanMap, dataBeanMapList, objectMap)) {
                return;
            }
            verifyProcess.execute(currentDataBeanMap, dataBeanMapList, objectMap);
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        if (excelImportContext.getInvalid()) {
            // 验证不成功,进度:50
            excelResponseService.importFailure(excelResponseDTO, dataList, excelImportContext.getImportClass(),excelImportContext.getParamMap());
        } else {
            // 否则成功
            excelResponseService.importSuccess(excelResponseDTO);
        }
        dataBeanMapList.clear();
        dataList.clear();
    }

    @Override
    public void onException(Exception exception, AnalysisContext context) throws Exception {
        log.error("验证异常", exception);
        String msg = "该行导入出错，请联系管理员;";
        // 这里捕获异常，包含 ImportObjectMapEventListener 抛出的异常
        if (exception instanceof ServiceException) {
            // 处理 ServiceException
            msg = ((ServiceException) exception).getMessageResponse().getMsg();
        }
        String message = (String) currentDataBeanMap.get(IMPORT_MESSAGE_FIELD_NAME);
        currentDataBeanMap.put(IMPORT_MESSAGE_FIELD_NAME,
                StringUtils.isEmpty(message) ? msg : (message + ";" + msg));
        excelImportContext.setInvalid(Boolean.TRUE);
    }
}

具体的操作在invoke里面

这一块我真的踩了好多坑，其实这一块是去读实体类上面的注解，
我们以id为例将几种类型

    @IdVerify(PersonBaseInfoService.class)
    @ExcelProperty(value = "数据唯一标识", index = 0)
    protected String id;

ExcelProperty这是生成excel中的字段名，IdVerify专门写的id的注解，用来验证id字段的

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@FieldVerifyProcessTag(processClass = IdVerifyProcess.class)
public @interface IdVerify {
    /**
     * 调用查询的 service 类型
     *
     * @return
     */
    Class<? extends ServiceImpl> value();
}

FieldVerifyProcessTag这个注解就是专门用来去实现的类

public class IdVerifyProcess extends AbstractFieldVerifyProcess {


    public IdVerifyProcess(ExcelImportContext context, Annotation annotation, int order, Field field) {
        super(context, annotation, order, field);
    }

    @Override
    public void execute(BeanMap dataBeanMap, List<BeanMap> dataBeanMapList, Map<String, Object> objectMap) {
        if (this.isUpdateOperateStatus(dataBeanMap)
                || this.isDeleteOperateStatus(dataBeanMap)) {
            String fieldValue = this.getFieldValue(dataBeanMap);
            if (StringUtils.isEmpty(fieldValue)) {
                this.setMessage(objectMap, "未找到要操作的数据，操作状态为【更新或更正或更改】时，唯一标识不能为空;");
            } else {
                try {
                    fieldValue = ExcelImportUtils.decode(fieldValue, StringUtils.UTF8);
                } catch (UnsupportedEncodingException e) {
                    this.setMessage(objectMap, "ID解码失败;");
                }
                IdVerify annotation = (IdVerify) this.annotation;
                // 如果是带时间戳的类
                if (HistoryServiceImpl.class.isAssignableFrom(annotation.value())) {
                    String operateDate = this.getFieldValue(dataBeanMap, String.class, IMPORT_OPERATE_DATE_FIELD_NAME);
                    if (StringUtils.isNotEmpty(operateDate)) {
                        LocalDate localDate = ExcelImportUtils.convertDate(operateDate);
                        if (Objects.nonNull(localDate)) {
                            objectMap.put(IMPORT_OPERATE_DATE_FIELD_NAME, localDate);
                            dataBeanMap.put(IMPORT_OPERATE_DATE_FIELD_NAME, localDate.toString());
                            // 把日期传入
                            idVerify(objectMap, fieldValue,
                                    ((HistoryServiceImpl) this.getBean(annotation.value())).selectById(fieldValue, localDate));
                        } else {
                            this.setMessage(objectMap, "操作日期有误;");
                        }
                    } else {
                        this.setMessage(objectMap, "操作日期不能为空;");
                    }
                } else {
                    idVerify(objectMap, fieldValue, (this.getBean(annotation.value())).selectById(fieldValue));
                }
            }
        }
    }

    /**
     * 验证 Id
     *
     * @param objectMap
     * @param fieldValue
     * @param selectById
     */
    private void idVerify(Map<String, Object> objectMap, String fieldValue, Object selectById) {
        if (Objects.isNull(selectById)) {
            this.setMessage(objectMap, "当前行数据唯一标识的数据在系统中未找到;");
        } else {
            objectMap.put(field.getName(), fieldValue);
        }
    }

    @Override
    public boolean skip(BeanMap dataBeanMap, List<BeanMap> dataBeanMapList, Map<String, Object> objectMap) {
        return false;
    }
}

其他的都是一样的实现方法，我觉得这个框架真的很有趣，但是我真的没有办法拿出来，想要抽离真的代价太大了