devbox
cp456
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

EasyExcel实现导入导出Excel_easyexcel依赖哪些包

作者：cp456 | 2024-02-05 15:26:07

赞

踩

easyexcel依赖哪些包

平时项目经常用到导入导出功能，网上翻阅很多资料都没有找到理想的，这里做个记录

一、用到的依赖包

  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>easyexcel</artifactId>
  4.     <version>2.2.10</version>
  5. </dependency>
  6.  
  7. <dependency>
  8.     <groupId>org.apache.poi</groupId>
  9.     <artifactId>ooxml-schemas</artifactId>
  10.     <version>1.4</version>
  11. </dependency>
  12.  
  13. <dependency>
  14.     <groupId>javax.servlet</groupId>
  15.     <artifactId>javax.servlet-api</artifactId>
  16.     <version>4.0.1</version>
  17.     <scope>provided</scope>
  18. </dependency>

二、封装工具类EasyExcelUtil 

  1. package com.hkl.utils;
  2.  
  3. import cn.hutool.core.date.DateUtil;
  4. import cn.hutool.core.date.TimeInterval;
  5. import cn.hutool.core.util.ObjectUtil;
  6. import cn.hutool.core.util.StrUtil;
  7. import com.alibaba.excel.EasyExcel;
  8. import com.alibaba.excel.ExcelReader;
  9. import com.alibaba.excel.ExcelWriter;
  10. import com.alibaba.excel.context.AnalysisContext;
  11. import com.alibaba.excel.enums.CellDataTypeEnum;
  12. import com.alibaba.excel.event.AnalysisEventListener;
  13. import com.alibaba.excel.metadata.CellData;
  14. import com.alibaba.excel.metadata.Head;
  15. import com.alibaba.excel.read.builder.ExcelReaderBuilder;
  16. import com.alibaba.excel.support.ExcelTypeEnum;
  17. import com.alibaba.excel.util.CollectionUtils;
  18. import com.alibaba.excel.write.metadata.WriteSheet;
  19. import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
  20. import com.alibaba.excel.write.style.column.AbstractColumnWidthStyleStrategy;
  21. import lombok.extern.slf4j.Slf4j;
  22. import org.apache.poi.ss.usermodel.Cell;
  23.  
  24. import javax.servlet.http.HttpServletResponse;
  25. import java.io.IOException;
  26. import java.io.InputStream;
  27. import java.io.OutputStream;
  28. import java.net.URLEncoder;
  29. import java.util.ArrayList;
  30. import java.util.HashMap;
  31. import java.util.List;
  32. import java.util.Map;
  33.  
  34. /**
  35.  * <p>ClassName：EasyExcel工具类</p >
  36.  * <p>Description：</p >
  37.  * <p>Date：2021/9/1</p >
  38.  */
  39. @Slf4j
  40. public class EasyExcelUtil {
  41.  
  42.  
  43.     //-------------------------------------------------------------- 读取文件解析监听类 start ----------------------------------------------------
  44.     /**
  45.      * <p>ClassName：ExcelListener</p >
  46.      * <p>Description：读取文件解析监听类，此类供外部实例化使用需要设置为静态类</p >
  47.      * <p>Date：2021/9/2</p >
  48.      */
  49.     public static class ExcelListener<T> extends AnalysisEventListener<T>{
  50.  
  51.         /**
  52.          * <p>存放读取后的数据</p >
  53.          * @date 2021/9/2 0:10
  54.         */
  55.         public List<T> datas = new ArrayList<>();
  56.  
  57.         /**
  58.          * <p>读取数据，一条一条读取</p >
  59.          * @date 2021/9/2 0:15
  60.         */
  61.         @Override
  62.         public void invoke(T t, AnalysisContext analysisContext) {
  63.             datas.add(t);
  64.         }
  65.  
  66.         /**
  67.          * <p>解析完毕之后执行</p >
  68.          * @date 2021/9/2 0:06
  69.         */
  70.         @Override
  71.         public void doAfterAllAnalysed(AnalysisContext analysisContext) {
  72.             log.info("读取数据条数：{}条！", datas.size());
  73.         }
  74.  
  75.         public List<T> getDatas(){
  76.             return this.datas;
  77.         }
  78.  
  79.     }
  80.     //-------------------------------------------------------------- 读取文件解析监听类 end ----------------------------------------------------
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.     //-------------------------------------------------------------- 导出excel表格，设置自适应列宽配置类 start ----------------------------------------------------
  88.     /**
  89.      * <p>ClassName：Custemhandler</p >
  90.      * <p>Description：设置自适应列宽配置类</p >
  91.      * <p>Date：2021/10/14</p >
  92.      */
  93.     public static class Custemhandler extends AbstractColumnWidthStyleStrategy {
  94.  
  95.         private static final int MAX_COLUMN_WIDTH = 255;
  96.         //因为在自动列宽的过程中，有些设置地方让列宽显得紧凑，所以做出了个判断
  97.         private static final int COLUMN_WIDTH = 20;
  98.         private  Map<Integer, Map<Integer, Integer>> CACHE = new HashMap(8);
  99.  
  100.         @Override
  101.         protected void setColumnWidth(WriteSheetHolder writeSheetHolder, List<CellData> cellDataList, Cell cell, Head head, Integer relativeRowIndex, Boolean isHead) {
  102.             boolean needSetWidth = isHead || !CollectionUtils.isEmpty(cellDataList);
  103.             if (needSetWidth) {
  104.                 Map<Integer, Integer> maxColumnWidthMap = (Map)CACHE.get(writeSheetHolder.getSheetNo());
  105.                 if (maxColumnWidthMap == null) {
  106.                     maxColumnWidthMap = new HashMap(16);
  107.                     CACHE.put(writeSheetHolder.getSheetNo(), maxColumnWidthMap);
  108.                 }
  109.  
  110.                 Integer columnWidth = this.dataLength(cellDataList, cell, isHead);
  111.                 if (columnWidth >= 0) {
  112.                     if (columnWidth > MAX_COLUMN_WIDTH) {
  113.                         columnWidth = MAX_COLUMN_WIDTH;
  114.                     }else {
  115.                         if(columnWidth<COLUMN_WIDTH){
  116.                             columnWidth =columnWidth*2;
  117.                         }
  118.                     }
  119.  
  120.                     Integer maxColumnWidth = (Integer)((Map)maxColumnWidthMap).get(cell.getColumnIndex());
  121.                     if (maxColumnWidth == null || columnWidth > maxColumnWidth) {
  122.                         ((Map)maxColumnWidthMap).put(cell.getColumnIndex(), columnWidth);
  123.                         writeSheetHolder.getSheet().setColumnWidth(cell.getColumnIndex(),  columnWidth* 256);
  124.                     }
  125.                 }
  126.             }
  127.         }
  128.  
  129.  
  130.         private  Integer dataLength(List<CellData> cellDataList, Cell cell, Boolean isHead) {
  131.             if (isHead) {
  132.                 return cell.getStringCellValue().getBytes().length;
  133.             } else {
  134.                 CellData cellData = (CellData)cellDataList.get(0);
  135.                 CellDataTypeEnum type = cellData.getType();
  136.                 if (type == null) {
  137.                     return -1;
  138.                 } else {
  139.                     switch(type) {
  140.                         case STRING:
  141.                             return cellData.getStringValue().getBytes().length;
  142.                         case BOOLEAN:
  143.                             return cellData.getBooleanValue().toString().getBytes().length;
  144.                         case NUMBER:
  145.                             return cellData.getNumberValue().toString().getBytes().length;
  146.                         default:
  147.                             return -1;
  148.                     }
  149.                 }
  150.             }
  151.         }
  152.     }
  153.     //-------------------------------------------------------------- 导出excel表格，设置自适应列宽配置类 end -----------------------------------------------------
  154.  
  155.  
  156.  
  157.  
  158.  
  159.  
  160.     /**
  161.      * <p> 读取Excel文件返回数据集合，不包含表头，默认读取第一个sheet数据 </p >
  162.      * @date 2021/9/2 0:17
  163.      * @param inputStream 输入流
  164.      * @param tClass 数据映射类
  165.      * @param excelListener 读取监听类
  166.      * @return List 结果集
  167.     */
  168.     public static <T> List<T> readExcel(InputStream inputStream, Class<T> tClass, ExcelListener<T> excelListener){
  169.         if(ObjectUtil.isNull(inputStream) || ObjectUtil.isNull(tClass) || ObjectUtil.isNull(excelListener)){
  170.             return null;
  171.         }
  172.         ExcelReaderBuilder read = EasyExcel.read(inputStream, tClass, excelListener);
  173.         read.sheet().doRead();
  174.         return excelListener.getDatas();
  175.     }
  176.  
  177.     /**
  178.      * <p> 读取Excel文件返回数据集合，不包含表头，读取第x个sheet数据，不设置sheet就读取全部 </p >
  179.      * @date 2021/9/2 0:17
  180.      * @param inputStream 输入流
  181.      * @param tClass 数据映射类
  182.      * @param excelListener 读取监听类
  183.      * @return List 结果集
  184.      */
  185.     public static <T> List<T> readExcel(InputStream inputStream, Integer sheetNo, Class<T> tClass, ExcelListener<T> excelListener){
  186.         if(ObjectUtil.isNull(inputStream) || ObjectUtil.isNull(tClass) || ObjectUtil.isNull(excelListener)){
  187.             return null;
  188.         }
  189.         ExcelReaderBuilder read = EasyExcel.read(inputStream, tClass, excelListener);
  190.         if(ObjectUtil.isNotNull(sheetNo)){
  191.             read.sheet(sheetNo).doRead();
  192.         }else{
  193.             ExcelReader excelReader = read.build();
  194.             excelReader.readAll();
  195.             excelReader.finish();
  196.         }
  197.         return excelListener.getDatas();
  198.     }
  199.  
  200.     /**
  201.      * <p>不带模板输出数据到Excel，数据传输类属性用 @ExcelProperty("") 标注</p >
  202.      * @date 2021/9/2 0:32
  203.      * @param response 响应对象
  204.      * @param tClass 输出格式
  205.      * @param datas 输出的数据
  206.      * @return：
  207.     */
  208.     public static <T> void writeEasyExcel(HttpServletResponse response, Class<T> tClass, List<T> datas, String fileName) throws IOException {
  209.         TimeInterval timer = DateUtil.timer();
  210.         if(ObjectUtil.isNull(response) || ObjectUtil.isNull(tClass)){
  211.             return;
  212.         }
  213.  
  214.         if(StrUtil.isBlank(fileName)){
  215.             fileName = "excel.xlsx";
  216.         }else{
  217.             if(!fileName.contains(".xlsx")){
  218.                 fileName = fileName+".xlsx";
  219.             }
  220.         }
  221.         response.setStatus(HttpServletResponse.SC_OK);
  222.         response.setContentType("application/x-msdownload");
  223.         response.setHeader("Content-Disposition", "attachment; filename="+ URLEncoder.encode(fileName, "utf-8"));
  224.         EasyExcel.write(response.getOutputStream(), tClass)
  225.                 .registerWriteHandler(new Custemhandler())
  226.                 .excelType(ExcelTypeEnum.XLSX)
  227.                 .sheet("sheet")
  228.                 .doWrite(datas);
  229.         log.info("导出exlce数据：{}条，耗时：{}秒！", datas.size(), timer.intervalSecond());
  230.     }
  231.  
  232.     /**
  233.      * <p>带模板输出数据到Excel，数据传输类属性用 @ExcelProperty("") 标注</p >
  234.      * @date 2021/9/2 0:32
  235.      * @param outputStream 输出流
  236.      * @param tClass 输出格式
  237.      * @param datas 输出的数据
  238.      * @return：
  239.      */
  240.     public static <T> void writeExcel(InputStream inputStream ,OutputStream outputStream, Class<T> tClass, List<T> datas){
  241.         TimeInterval timer = DateUtil.timer();
  242.         if(ObjectUtil.isNull(outputStream) || ObjectUtil.isNull(tClass)){
  243.             return;
  244.         }
  245. //        EasyExcel.write(outputStream, tClass).withTemplate(inputStream).sheet("sheet").doWrite(datas);
  246.         EasyExcel.write(outputStream, tClass).excelType(ExcelTypeEnum.XLSX).withTemplate(inputStream).sheet("sheet").doFill(datas);
  247.         log.info("导出exlce数据：{}条，耗时：{}秒！", datas.size(), timer.intervalSecond());
  248.     }
  249.  
  250.  
  251.     /**
  252.      * <p>不带模板输出数据到Excel，数据传输类属性用 @ExcelProperty("") 标注</p >
  253.      * @date 2021/9/2 0:32
  254.      * @param response 响应对象
  255.      * @param tClass 输出格式
  256.      * @param datas 输出的数据
  257.      * @return：
  258.      */
  259.     public static <T> void writeExcel(HttpServletResponse response, Class<T> tClass, List<T> datas, String fileName) throws IOException, IllegalAccessException, NoSuchFieldException {
  260.         TimeInterval timer = DateUtil.timer();
  261.         if(ObjectUtil.isNull(response) || ObjectUtil.isNull(tClass)){
  262.             return;
  263.         }
  264.  
  265.         if(StrUtil.isBlank(fileName)){
  266.             fileName = "excel.xlsx";
  267.         }else{
  268.             if(!fileName.contains(".xlsx")){
  269.                 fileName = fileName+".xlsx";
  270.             }
  271.         }
  272.  
  273.         //编码设置成UTF-8，excel文件格式为.xlsx
  274.         response.setContentType("application/vnd.ms-excel");
  275.         response.setCharacterEncoding("UTF-8");
  276.         // 这里URLEncoder.encode可以防止中文乱码 和easyexcel本身没有关系
  277.         fileName = URLEncoder.encode(fileName, "UTF-8");
  278.         response.setHeader("Content-disposition", "attachment;filename=" + fileName);
  279.  
  280.         //处理注解转换
  281. //        if(CollUtil.isNotEmpty(datas)){
  282. //            for (T dataObj : datas) {
  283. //                AnnotationUtil.resolveAnnotation(tClass, dataObj);
  284. //            }
  285. //        }
  286.         ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), tClass).build();
  287.         WriteSheet writeSheet = new WriteSheet();
  288.         writeSheet.setSheetName("sheet");
  289.         excelWriter.write(datas, writeSheet);
  290.         excelWriter.finish();
  291.         log.info("导出exlce数据：{}条，耗时：{}秒！", datas.size(), timer.intervalSecond());
  292.     }
  293.  
  294. }

工具类代码中， ExcelListener 为定义的内部监听类，需要继承 AnalysisEventListener，读取和写入方法分别为 readExcel 和 writeExcel，详见方法注释说明，直接复制到项目中即可使用

三、使用示例

1. 实体类

  1. package com.hkl.modules.dto;
  2.  
  3. import com.alibaba.excel.annotation.ExcelProperty;
  4. import io.swagger.annotations.ApiModelProperty;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  8.  
  9. import java.io.Serializable;
  10. import java.math.BigDecimal;
  11. import java.util.Date;
  12.  
  13. /**
  14.  * <p>ClassName：ImportTestDatasReq</p >
  15.  * <p>Description：</p >
  16.  * <p>Date：2021/9/2</p >
  17.  */
  18. @Data
  19. @AllArgsConstructor
  20. @NoArgsConstructor
  21. public class ImportTestDatasReq implements Serializable {
  22.     @ExcelProperty(value = "userName")
  23.     @ApiModelProperty("用户姓名")
  24.     private String userName;
  25.  
  26.     @ExcelProperty(value = "address")
  27.     @ApiModelProperty("地址")
  28.     private String address;
  29.  
  30.     @ExcelProperty(value = "price")
  31.     @ApiModelProperty("价格")
  32.     private BigDecimal price;
  33.  
  34.     @ExcelProperty(value = "createDate")
  35.     @ApiModelProperty("创建时间")
  36.     private Date createDate;
  37. }

注意：实体类中不能使用链式写法注解 @Accessors(chain = true)，否则会读取不到数据

2. 控制层

  1. @Slf4j
  2. @Api(tags = "Excel文件操作管理")
  3. @RestController
  4. @RequestMapping("/excel")
  5. public class ExcelController extends BaseController {
  6.  
  7.  
  8.     /**
  9.      * <p> MultipartFile 这个类一般是用来接收前台传过来的文件信息 </p >
  10.     */
  11.     @ApiOperation(value = "导入数据")
  12.     @PostMapping("/importTestDatas")
  13.     public CommonResult importTestDatas(@RequestParam("multipartFile") MultipartFile multipartFile) throws BizException, IOException {
  14.         isBlank(multipartFile, "参数");
  15.  
  16.         List<ImportTestDatasReq> ImportTestDatasReqList = EasyExcelUtil.readExcel(multipartFile.getInputStream(), ImportTestDatasReq.class, new EasyExcelUtil.ExcelListener<>());
  17.         ImportTestDatasReqList.forEach(System.out::println);
  18.         return success(null);
  19.     }
  20.  
  21.     @ApiOperation("导出")
  22.     @GetMapping("/testExport")
  23.     public void testExport(HttpServletResponse response) {
  24.         try {
  25.             List<ImportTestDatasReq> entities = 查询数据接口;
  26.             EasyExcelUtil.writeEasyExcel(response, ImportTestDatasReq.class, entities, "列表导出");
  27.         } catch (Exception e) {
  28.             e.printStackTrace();
  29.         }
  30.     }
  31. }

注解说明：

1、@HeadRowHeight：设置表头高度，作用域在类

2、@ExcelIgnoreUnannotated：忽略没有注解标记的字段，作用域在类

3、@ExcelIgnore：忽略指定的字段，作用域在字段

4、@ExcelProperty：指定导出列名和索引，作用域在字段

5、@ColumnWidth：设置列的宽度，作用域在字段

6、@NumberFormat：设置数值精度，作用域在字段，例：@NumberFormat(value = "#.00")

7、@DateTimeFormat：格式化日期，作用域在字段，例：@DateTimeFormat(value = "yyyy-MM-dd")

注意：

1、我们可以使用 EasyExcel.write().registerWriteHandler(new Custemhandler()) 设置导出列的宽度为自适应，但是使用 registerWriteHandler(new Custemhandler()) 方法之后不能再使用注解@ColumnWidth，否则会导致自适应宽度不生效

2、BigDecimal 格式化标准模板为：#0.00。带千分位符为：,###,##0.00

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/cp456/article/detail/61054
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号