EasyExcel实现文件导出

官网：https://www.yuque.com/easyexcel/doc/easyexcel

导出

准备工作

引入依赖

<!--EasyExcel相关依赖-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>easyexcel</artifactId>
    <version>3.0.5</version>
  </dependency>

创建监听器

@Data
public class ExcelDataListener<T> extends AnalysisEventListener<T> {
    private static Logger log4 = Logger.getLogger(AreaServiceImpl.class);

    /**
     * 导入出错的信息(此处保存的为解析时错误的信息，某行某列+错误信息+；)
     */
    private List<String> errorMsg = new ArrayList<>();

    /**
     * 必要列为空的信息（某行+'列1，列2...'+的值为空）
     */
    private List<String> nullFields = new ArrayList<>();

    /**
     * 导入的表头（解析到的表头）
     */
    private Map<Integer, String> headMap = new HashMap<>();

    /**
     * 缓存的数据（成功解析的数据）
     */
    private List<T> dataList = new ArrayList<>();

    /**
     * 读取报错的数据(解析错误的数据，即无法映射到导出的实体类)
     */
    private List<Map<String, String>> errorDataList = ListUtils.newArrayList();

    /** 导出实体类的行索引字段名。
      *用于设置解析到的数据所在的行数（在进行导入的时候用于定位service中save出错的数
      *据，所在的行）
      */
    private String rowIndexField;

    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
//    private DemoDAO demoDAO;

//    public ExcelDataListener(DemoDAO demoDAO) {
//        this.demoDAO = demoDAO;
//    }

    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data    one row value
     * @param context
     */
    @Override
    public void invoke(T data, AnalysisContext context) {
        log4.info("解析到一条数据:" + JSON.toJSONString(data));
        // 由于会读取空行（excel中删除数据后的行）所以这里加判断
        if (!"{}".equals(JSON.toJSONString(data))) {
        // 由于第一行是表头，因此这里+1
           int rowIndex = context.readRowHolder().getRowIndex() + 1;
            Class<?> dataClazz = data.getClass();
            try {
                // 如果没有设置实体类行索引的字段名，则默认为rowIndex
                String fieldName = StringUtils.isEmpty(rowIndexField) ? "rowIndex" : rowIndexField;
                Field rowIndexField = dataClazz.getDeclaredField(fieldName);
                rowIndexField.setAccessible(true);
                rowIndexField.set(data,rowIndex);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
                log4.info("对应的实体中没有行数");
            }
            // 校验必要列是否为空
            List<String> checkField = ExcelUtil.checkField(data);
            if (checkField.size() > 0) {
                String errorMsg = "第" + rowIndex + "行，" +
                        String.join("、",checkField) + "列的值为空";
                nullFields.add(errorMsg);
            } else {
                dataList.add(data);
            }
        }
        else
            context.readRowHolder().setRowType(RowTypeEnum.EMPTY);
    }

    /**
     * 读取的表头
     *
     * @param headMap  表头
     * @param context
     */
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        // 此处由于会读取空单元格表头（删除内容后的单元格也会被读取）所以进行遍历判断
        Set<Map.Entry<Integer, String>> entries = headMap.entrySet();
        for (Map.Entry<Integer, String> head : entries) {
            if (!StringUtils.isEmpty(head.getValue()))
                this.headMap.put(head.getKey(),head.getValue());
        }
    }

    @Override
    public boolean hasNext(AnalysisContext context) {
        // 由于会读取空行数据，因此此处加判断遇到空行停止读取；（invoke方法中遇到空行会设置RowType）
        if (RowTypeEnum.EMPTY.equals(context.readRowHolder().getRowType())) {
            doAfterAllAnalysed(context);
            return false;
        }
        return super.hasNext(context);
    }

    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        log4.info("所有数据解析完成！");
    }

    /**
     * 在转换异常 获取其他异常下会调用本接口。抛出异常则停止读取。如果这里不抛出异常则 继续读取下一行。
     *
     * @param exception
     * @param context
     * @throws Exception
     */
    @Override
    public void onException(Exception exception, AnalysisContext context) {
        // 如果是某一个单元格的转换异常 能获取到具体行号
        // 如果要获取头的信息 配合invokeHeadMap使用
        if (exception instanceof ExcelDataConvertException) {
            ExcelDataConvertException e = (ExcelDataConvertException)exception;
            String errorIndexInfo = "第" + (e.getRowIndex() + 1) + "行"
                    + "的”" +headMap.get(e.getColumnIndex()) +"“列,";
            errorMsg.add(errorIndexInfo + exception.getMessage());
            // 构造错误的数据
            ReadRowHolder readRowHolder = context.readRowHolder();
            HashMap<String, String> data = new HashMap<>();
            Set<Map.Entry<Integer, Cell>> entries = readRowHolder.getCellMap().entrySet();
            for (Map.Entry<Integer, Cell> entry : entries) {
                ReadCellData value = (ReadCellData)(entry.getValue());
                data.put(headMap.get(entry.getKey()),value.getStringValue());
            }
            errorDataList.add(data);
        }
    }

}

工具类校验必要字段

/**
     * 校验导入实体的必要字段
     * @param entity 导入的实体
     * @param <T>
     * @return
     */
    public static <T> List<String> checkField(T entity){
        Class<?> clazz = entity.getClass();
        Field[] fields = clazz.getDeclaredFields();
        List<String> nullFields = new ArrayList<>();
        for (Field field : fields) {
            NeedNotNull notNull = field.getDeclaredAnnotation(NeedNotNull.class);
            ExcelProperty property = field.getDeclaredAnnotation(ExcelProperty.class);
            field.setAccessible(true);
            // 该字段是否不能为空
            if (!ObjectUtils.isEmpty(notNull)){
                try {
                    Object value = field.get(entity);
                    // 如果必要字段的值为空则校验失败
                    if (ObjectUtils.isEmpty(value))
                        nullFields.add(StringUtils.join(property.value(),","));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    log4.error(field.getName() + "字段值获取异常:"+e.getMessage());
                }
            }
        }
        return nullFields;
    }

自定义注解

/**
 * 自定义注解，用于判断是否需要合并以及合并的主键
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface CustomMerge {

    /**
     * 是否需要合并单元格
     */
    boolean needMerge() default false;

    /**
     * 是否是主键,即该字段相同的行合并
     */
    boolean isPk() default false;
}

/**
 * 自定义注解，用于判断字段是否不能为空
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface NeedNotNull {

    /**
     * 是否不能为空
     */
    boolean value() default true;
    /**
     * 字段名称
     */
    String name() default "";
}

创建导出的实体类

@Data
public class AreaImportDto {

    /** 区域名称 */
    @ExcelProperty("区域名称")
    @CustomMerge(needMerge = true, isPk = true)
    @ColumnWidth(20)
    @NeedNotNull(name = "区域名称")
    private String areaName;

    /** 区域的X坐标 */
    @ExcelProperty("父区域")
    @CustomMerge(needMerge = true)
    @ColumnWidth(10)
    private String parentName;

    /** 人员名称 */
    @ExcelProperty("人员名称")
    @CustomMerge(needMerge = true)
    @ColumnWidth(20)
    private String personName;

    /** 导入数据所在的行数 */
    private Integer rowIndex;
}

ps：

@ExcelProperty: 导出的列名（如果是多行表头，则值为数组，详见官网）

@CustomMerge(needMerge = true, isPk = true)：要合并的列

@ColumnWidth(20)：列宽

@NeedNotNull(name = "区域名称")：是否为必要列

构造数据

• 调用service查询数据库数据
• 定义转换方法，将实体类转换为导出实体（此处可以省略，如果不另外定义导出实体的话耦合性较高）

创建导出工具类

private static final String FILE_SEPARATOR = "/";

/**
     * 数据导出到excel
     *
     * @param params          请求参数(自定义的请求参数实体，包含query（Map）、sort、page属性)
     * @param serverPath      服务器文件导出路径
     * @param defaultFileName 默认文件名
     * @param targetData      导出数据
     * @param clazz           导出数据的类对象
     * @param isMergeStrategy 是否要合并行（一对多导出时用到）
     * @return
     * @throws IOException
     */
    public static <T> Map<String, String> exportExcel(SearchParamDto params, String defaultFileName,
                                                      String serverPath, String urlPath, List<T> targetData,
                                                      Class<T> clazz, boolean isMergeStrategy) throws IOException {
        HashMap<String, String> result = new HashMap<String, String>() {{
            put("msg", "数据导出成功");
        }};
        // 请求中传递的需要导出的列
        JSONArray fields = JSONArray.parseArray(params.getQuery().get("fields").toString());
        // 设置文件名
        String fileName1 = ObjectUtils.isEmpty(params.getQuery().get("fileName")) ?
                defaultFileName :
                params.getQuery().get("fileName").toString();
//        String fileName = URLEncoder.encode(fileName1, "UTF-8").replaceAll("\\+", "%20") + ".xlsx";
        String fileName = fileName1 + ".xlsx";

        try {
            // 获取当前时间
            String updTm = DateUtil.getAllTime();
            String filePath = serverPath + FILE_SEPARATOR + updTm + FILE_SEPARATOR + fileName;
            String destDirName = serverPath + FILE_SEPARATOR + updTm;
            createDir(destDirName);
            FileOutputStream fileOutputStream = new FileOutputStream(filePath);
            log4.info(fileName1 + "数据导出成功！");
            ExcelWriterBuilder head = EasyExcel.write(fileOutputStream).autoCloseStream(true)
                    .includeColumnFiledNames(fields.toJavaList(String.class))
                    .head(clazz);
            if (isMergeStrategy) {
                head.registerWriteHandler(new CustomMergeStrategy(clazz));
            }
            head.excelType(ExcelTypeEnum.XLSX)
                    .sheet("sheet1")
                    .doWrite(targetData);
            String url = urlPath + FILE_SEPARATOR + updTm + FILE_SEPARATOR + fileName;
             // 返回请求文件的url以及服务器报错路径
            result.put("url", url);
            result.put("savePath", serverPath + FILE_SEPARATOR + updTm);
        } catch (Exception e) {
            log4.error("数据导出失败: {}", e);
            result.put("msg", "数据导出失败");
            return result;
        }

        return result;
    }