下面案例代码请参考:源码地址

背景

:::tips 后台管理系统有很多处理excel导入,导出的功能.(比如,批量新增功能),这时候就需要有工具来处理excel文件.常见的有Apache POI以及Alibaba EasyExcel.下面针对easyexcel进行工具类的封装 :::

依赖

  1. <dependency>
  2.   <groupId>com.alibaba</groupId>
  3.   <artifactId>easyexcel</artifactId>
  4.   <version>2.1.6</version>
  5. </dependency>

工具类

文件地址

  1. /**
  2.  * 太阳当空照,花儿对我笑
  3.  * <p>
  4.  * Create by M ChangKe 2022/7/6 11:56
  5.  **/
  6. @Slf4j
  7. public class EasyExcelUtil {
  9.     /**
  10.      * 同步无模型读（指定sheet和表头占的行数）
  11.      *
  12.      * @param inputStream
  13.      * @param sheetNo     sheet页号，从0开始
  14.      * @param headRowNum  表头占的行数，从0开始（如果要连表头一起读出来则传0）
  15.      */
  16.     public static List<Map<Integer, String>> syncRead(InputStream inputStream, Integer sheetNo, Integer headRowNum) {
  17.         return EasyExcelFactory
  18.                 .read(inputStream)
  19.                 .sheet(sheetNo)
  20.                 .headRowNumber(headRowNum)
  21.                 .doReadSync();
  22.     }
  24.     /**
  25.      * 同步无模型读（指定sheet和表头占的行数）
  26.      *
  27.      * @param file
  28.      * @param sheetNo    sheet页号，从0开始
  29.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
  30.      */
  31.     public static List<Map<Integer, String>> syncRead(File file, Integer sheetNo, Integer headRowNum) {
  32.         return EasyExcelFactory.read(file).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
  33.     }
  36.     /**
  37.      * 同步按模型读（指定sheet和表头占的行数）
  38.      *
  39.      * @param inputStream
  40.      * @param clazz       模型的类类型（excel数据会按该类型转换成对象）
  41.      * @param sheetNo     sheet页号，从0开始
  42.      * @param headRowNum  表头占的行数，从0开始（如果要连表头一起读出来则传0）
  43.      */
  44.     public static <T> List<T> syncReadModel(InputStream inputStream, Class<T> clazz, Integer sheetNo, Integer headRowNum) {
  45.         return EasyExcelFactory
  46.                 .read(inputStream)
  47.                 .sheet(sheetNo)
  48.                 .headRowNumber(headRowNum)
  49.                 .head(clazz)
  50.                 .doReadSync();
  51.     }
  53.     /**
  54.      * 同步按模型读（指定sheet和表头占的行数）
  55.      *
  56.      * @param file
  57.      * @param clazz      模型的类类型（excel数据会按该类型转换成对象）
  58.      * @param sheetNo    sheet页号，从0开始
  59.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
  60.      */
  61.     public static <T> List<T> syncReadModel(File file, Class<T> clazz, Integer sheetNo, Integer headRowNum) {
  62.         return EasyExcelFactory
  63.                 .read(file)
  64.                 .sheet(sheetNo)
  65.                 .headRowNumber(headRowNum)
  66.                 .head(clazz).doReadSync();
  67.     }
  70.     /**
  71.      * 异步无模型读（指定sheet和表头占的行数）
  72.      *
  73.      * @param inputStream
  74.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  75.      */
  76.     public static void asyncRead(InputStream inputStream, ReadListener<T> excelListener) {
  77.         EasyExcelUtil.asyncRead(inputStream, excelListener, 0, 1);
  78.     }
  81.     /**
  82.      * 异步无模型读（指定sheet和表头占的行数）
  83.      *
  84.      * @param inputStream
  85.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  86.      * @param sheetNo       sheet页号，从0开始
  87.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
  88.      */
  89.     public static void asyncRead(InputStream inputStream, ReadListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
  90.         EasyExcelFactory
  91.                 .read(inputStream, excelListener)
  92.                 .sheet(sheetNo)
  93.                 .headRowNumber(headRowNum)
  94.                 .doRead();
  95.     }
  98.     /**
  99.      * 异步无模型读（指定sheet和表头占的行数）
  100.      *
  101.      * @param file
  102.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  103.      * @param sheetNo       sheet页号，从0开始
  104.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
  105.      */
  106.     public static void asyncRead(File file, ReadListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
  107.         EasyExcelFactory.read(file, excelListener)
  108.                 .sheet(sheetNo)
  109.                 .headRowNumber(headRowNum)
  110.                 .doRead();
  111.     }
  114.     /**
  115.      * 异步按模型读取, sheet页号，从0开始,读取数据(排除第一行表头)
  116.      *
  117.      * @param inputStream
  118.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  119.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
  120.      * @param <T>
  121.      */
  122.     public static <T> void asyncReadModel(InputStream inputStream, ReadListener<T> excelListener, Class<T> clazz) {
  123.         EasyExcelUtil.asyncReadModel(inputStream, excelListener, clazz, 0, 1);
  124.     }
  127.     /**
  128.      * 异步按模型读取
  129.      *
  130.      * @param inputStream
  131.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  132.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
  133.      * @param sheetNo       sheet页号，从0开始
  134.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
  135.      */
  136.     public static <T> void asyncReadModel(InputStream inputStream, ReadListener<T> excelListener, Class<T> clazz, Integer sheetNo, Integer headRowNum) {
  137.         EasyExcelFactory.read(inputStream, clazz, excelListener)
  138.                 .sheet(sheetNo)
  139.                 .headRowNumber(headRowNum)
  140.                 .doRead();
  141.     }
  144.     /**
  145.      * 异步按模型读取
  146.      *
  147.      * @param file
  148.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
  149.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
  150.      * @param sheetNo       sheet页号，从0开始
  151.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
  152.      */
  153.     public static <T> void asyncReadModel(File file, ReadListener<T> excelListener, Class<T> clazz, Integer sheetNo, Integer headRowNum) {
  154.         EasyExcelFactory.read(file, clazz, excelListener)
  155.                 .sheet(sheetNo)
  156.                 .headRowNumber(headRowNum)
  157.                 .doRead();
  158.     }
  160.     /**
  161.      * 导出Excel到文件
  162.      *
  163.      * @param filePath  文件地址
  164.      * @param clazz     泛型类
  165.      * @param data      待导出数据列表
  166.      * @param sheetName sheetName
  167.      */
  168.     public static <T> void write(String filePath, Class<T> clazz, List<T> data, String sheetName) {
  169.         EasyExcel.write(filePath, clazz)
  170.                 .sheet(sheetName)
  171.                 .doWrite(data);
  172.     }
  175.     /**
  176.      * 导出excel到response响应流
  177.      *
  178.      * @param response       response响应流
  179.      * @param clazz          泛型类
  180.      * @param data           待导出数据列表
  181.      * @param exportFileName 导出的excel文件名
  182.      * @param sheetName      sheetName
  183.      * @param <T>            泛型
  184.      */
  185.     public static <T> void writeWeb(HttpServletResponse response, Class<T> clazz, List<T> data, String exportFileName, String sheetName) {
  187.         response.setContentType("application/vnd.ms-excel");
  188.         response.setCharacterEncoding("utf-8");
  189.         try (ServletOutputStream outputStream = response.getOutputStream()) {
  190.             // 这里URLEncoder.encode可以防止中文乱码
  191.             String fileName = URLEncoder.encode(exportFileName, "UTF-8");
  192.             response.setHeader("Content-disposition", "attachment;filename=" + fileName + ExcelTypeEnum.XLSX.getValue());
  193.             EasyExcel.write(outputStream, clazz)
  194.                     .sheet(sheetName)
  195.                     .doWrite(data);
  196.         } catch (Exception e) {
  197.             e.printStackTrace();
  198.         }
  199.     }
  200. }

案例

待读取的Excel模板如下:
image.png
根据上述模板,创建UserExcel 模板类用于excel的读取与导出

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class UserExcel {
  6.     @ExcelProperty(value = "编号",index = 0)
  7.     private String serialNo;
  9.     @ExcelProperty(value = "地址",index = 1)
  10.     private String quickCodeUrl;
  12. }

UploadDownController控制器

  2. @Slf4j
  3. @RestController
  4. @Api(value = "UploadDownController", tags = "上传下载教程")
  5. public class UploadDownController {
  7.     @Resource
  8.     private ExcelService excelService;
  11.     @ApiOperation(value = "异步读取excel进行入库操作", notes = "异步读取excel进行入库操作", consumes = "multipart/form-data")
  12.     @PostMapping("read")
  13.     public ApiResponse<String> read(@RequestParam("file") MultipartFile file) {
  15.         try (
  16.                 InputStream inputStream = file.getInputStream()
  17.         ) {
  18.             EasyExcelUtil.asyncReadModel(inputStream, new MyExcelReadListener(excelService), UserExcel.class);
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.         return ApiResponse.ok("my name is:" + file.getName());
  23.     }
  25. }

MyExcelReadListener

  1. /**
  2.  * 读取用户excel进行批量导入操作监听器
  3.  */
  4. @Slf4j
  5. public class MyExcelReadListener extends AnalysisEventListener<UserExcel> {
  7.     /**
  8.      * 单次缓存的数据量
  9.      */
  10.     public static final int BATCH_COUNT = 100;
  11.     /**
  12.      * 临时存储
  13.      */
  14.     private List<UserExcel> cachedDataList = Lists.newArrayListWithExpectedSize(BATCH_COUNT);
  16.     /**
  17.      *
  18.      */
  19.     private ExcelService excelService;
  21.     public MyExcelReadListener(ExcelService excelService) {
  23.         this.excelService = excelService;
  25.     }
  28.     @Override
  29.     public void invoke(UserExcel data, AnalysisContext context) {
  30.         cachedDataList.add(data);
  31.         if (cachedDataList.size() >= BATCH_COUNT) {
  32.             // 存储完成清理 list
  33.             cachedDataList = Lists.newArrayListWithExpectedSize(BATCH_COUNT);
  34.         }
  35.     }
  37.     @Override
  38.     public void doAfterAllAnalysed(AnalysisContext context) {
  39.         excelService.saveData(cachedDataList);
  40.     }
  42. }
  1. public interface ExcelService {
  2.     /**
  3.      * 存储数据
  4.      * @param cachedDataList
  5.      */
  6.     void saveData(List<UserExcel> cachedDataList);
  7. }
  1. @Slf4j
  2. @Component
  3. public class ExcelServiceImpl implements ExcelService {
  5.     @Override
  6.     public void saveData(List<UserExcel> cachedDataList) {
  8.         log.info("{}条数据，开始存储数据库！", cachedDataList.size());
  9.         log.info("存储数据库成功！");
  11.         cachedDataList.forEach(dto -> System.out.println(JSON.toJSONString(dto)));
  12.     }
  13. }