优雅的写导入

    @Override
    @Transactional
    public int importFile(MultipartFile file) {

        List<List<String>> xlsValues = GapUtil.getXLSValues(file, 8, 2);

        AssertUtil.notNull(xlsValues, "上传文件未解析到数据");

        List<Integer> formatError = new ArrayList<>();
        List<Integer> repetitionError = new ArrayList<>();

        Set<String> eleCodes = new HashSet<>();
        Set<Integer> newYears = new HashSet<>();
        Set<String> mofDivCodes = new HashSet<>();

        Map<String, List<Integer>> xlsRepetition = new HashMap<>();

        Function<ElementValueYearCompare, String> keyFunction =
                e -> e.getEle_catalog_code() + e.getNew_year() + e.getMof_div_code() + e.getNew_code() + e.getOld_code();

        List<ElementValueYearCompare> pending = xlsValues.stream()
                .map(e -> {
                    ElementValueYearCompare compare = new ElementValueYearCompare();
                    String order = e.get(0);
                    compare.setOrder(StringUtil.isNotNull(order) ? Integer.parseInt(order) : 0);
                    String eleCode = e.get(1);
                    compare.setEle_catalog_code(StringUtil.isNotNull(eleCode) ? eleCode : null);
                    String mofDivCode = e.get(2);
                    compare.setMof_div_code(StringUtil.isNotNull(mofDivCode) ? mofDivCode : "109900000");
                    String newYear = e.get(3);
                    compare.setNew_year(StringUtil.isNotNull(newYear) ? Integer.parseInt(newYear) : null);
                    String newCode = e.get(4);
                    compare.setNew_code(StringUtil.isNotNull(newCode) ? newCode : null);
                    String newName = e.get(5);
                    compare.setNew_name(StringUtil.isNotNull(newName) ? newName : null);
                    String oldCode = e.get(6);
                    compare.setOld_code(StringUtil.isNotNull(oldCode) ? oldCode : null);
                    String oldName = e.get(7);
                    compare.setOld_name(StringUtil.isNotNull(oldName) ? oldName : null);
                    return compare;
                })
                .filter(e -> {
                    if (StringUtil.isNotNull(e.getEle_catalog_code())
                            && StringUtil.isNotNull(e.getNew_year())
                            && StringUtil.isNotNull(e.getNew_code())
                            && StringUtil.isNotNull(e.getNew_name())
                            && StringUtil.isNotNull(e.getOld_code())
                            && StringUtil.isNotNull(e.getOld_name())
                    ) {
                        eleCodes.add(e.getEle_catalog_code());
                        newYears.add(e.getNew_year());
                        mofDivCodes.add(e.getMof_div_code());
                        e.setEle_compare_id(UUID.randomUUID().toString());
                        e.init();
                        xlsRepetition.compute(keyFunction.apply(e), (k, v) -> {
                            if (v == null){
                                return Lists.newArrayList(e.getOrder());
                            }
                            v.add(e.getOrder());
                            return v;
                        });
                        return true;
                    }
                    formatError.add(e.getOrder());
                    return false;
                })
                .collect(Collectors.toList());

        AssertUtil.isTrue(StringUtil.isNull(formatError), "数据格式错误，序号 = " + formatError);

        if (xlsValues.size() != xlsRepetition.size()){
            StringBuilder errorStr = new StringBuilder("xls中存在重复数据，序号组合：| ");
            xlsRepetition.forEach((k,v) -> {
                if (v.size() <= 1){
                    return;
                }
                errorStr.append(v).append(" | ");
            });
            throw new RuntimeException(errorStr.toString());
        }

        List<ElementValueYearCompare> dbData = elementValueYearCompareDao.getByEleCodeAndNewYear(Lists.newArrayList(eleCodes), Lists.newArrayList(newYears), Lists.newArrayList(mofDivCodes));
        if (StringUtil.isNull(dbData)) {
            return elementValueYearCompareDao.batchInsert(pending);
        }

        Set<String> dbKeys = dbData.stream().map(keyFunction).collect(Collectors.toSet());

        List<ElementValueYearCompare> pendingInserts = pending.stream()
                .filter(e -> {
                    if (!dbKeys.contains(keyFunction.apply(e))) {
                        return true;
                    }
                    repetitionError.add(e.getOrder());
                    return false;
                })
                .collect(Collectors.toList());

        AssertUtil.isTrue(StringUtil.isNull(repetitionError), "与数据库中数据重复，序号 = " + repetitionError);
        return elementValueYearCompareDao.batchInsert(pendingInserts);
    }