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

java实现excel的导入导出（带参数校验:非空校验、数据格式校验）_easyexcel导入校验字段非空

作者：笔触狂放9 | 2024-06-16 09:07:54

赞

踩

easyexcel导入校验字段非空

一、简单说明

本次封装引入阿里开源框架EasyExcel，EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel。 github地址:GitHub - alibaba/easyexcel: 快速、简洁、解决大文件内存溢出的java处理Excel工具 。64M内存20秒读取75M(46W行25列)的Excel（3.0.2+版本）

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

结构图如下：

1.1结构说明：

1.annotation:注解

@ExcelPropertyCheck（自己写的注解用作导入数据校验）

  1. @Target({ElementType.FIELD, ElementType.TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Inherited
  4. @Documented
  5. public @interface ExcelPropertyCheck {
  6.     boolean required() default true; ----是否为空，默认不为空。
  7.  
  8.     boolean checkFormat() default false; ----是否进行格式检验，默认不进行。
  9.  
  10.     int type() default -1; ----格式检验类型，int 已经支持的类型有 0->ip、1->端口、2->时间日期格式
  11.  
  12.     int length() default -1; ----长度校验， int 字符串的长度，-1不进行校验
  13.  
  14. }

@ExcelProperty(框架自带的，用于标记excel传输类和一些通用的导入导出配置)

  1. @Target(ElementType.FIELD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Inherited
  4. public @interface ExcelProperty {
  5.  
  6.     String[] value() default {""}; ----导出时对应字段的表头名称
  7.  
  8.     int index() default -1;----排列顺序，最好不要配默认按字段顺序。
  9.  
  10.     int order() default Integer.MAX_VALUE; ----同上
  11.  
  12.     Class<? extends Converter<?>> converter() default AutoConverter.class; ----转换器
  13.  
  14.     String format() default ""; ----格式划输出
  15. }

特别提醒：！！！

@ExcelPropertyCheck该注解作用类上时只支持required,其余属性无效。字段上的注解配置会覆盖类上的配置。  

2.constant：常量类，格式校验的类型定义，如电话号码、日期、IP地址等。

  1. /**
  2.  * excel导入字段类型常量
  3.  */
  4. public class ExcelPropertyType {
  5.     //时间日期格式校验
  6.     public static final int DATE_TIME = 0;
  7. }

3.converter：转换器

读写均可使用，实现Converter重写方法即可。

如将excel 中的日期转为 LocalDateTime 或者将LocalDateTime 转为excel表中的日期

或者将数据库的枚举值0，1，2，3导入到excel文件变成对应的中文汉字

  1. /**
  2.  * String and string converter
  3.  *
  4.  */
  5. public class CustomStringStringConverter implements Converter<String> {
  6.     /**
  7.      * 这里读的时候会调用
  8.      *
  9.      * @param context
  10.      * @return
  11.      */
  12.     @Override
  13.     public String convertToJavaData(ReadConverterContext<?> context) {
  14.         return "自定义：" + context.getReadCellData().getStringValue();
  15.     }
  16.  
  17.     /**
  18.      * 这里是写的时候会调用 不用管
  19.      *
  20.      * @return
  21.      */
  22.     @Override
  23.     public WriteCellData<?> convertToExcelData(WriteConverterContext<String> context) {
  24.         return new WriteCellData<>(context.getValue());
  25.     }
  26.  
  27. }

上述代码中泛型为String 表示此字段经过处理后最后返回的类型为String 

4.listener:监听器

ReadListener<T>(EasyExcel提供的)

  1. ReadListener<T>读监听器，框架提供。提供读取excel不同时期的监听方法。
  2. 分别为：
  3. onException()-------------->“读取发生异常时监听”、
  4. invokeHead()----------------->“读取表头信息监听”、
  5. invoke()--------------------->“读取每行数据监听”、
  6. doAfterAllAnalysed()----------->“所有数据读取完毕监听”。

BaseListener<T>我们自己封装的读监听器,在里面结合注解配置完成数据校验。

  1. BaseListener<T>我们自己封装的读监听器,在里面结合注解配置完成数据校验。
  2. 对外提供的字段：
  3.     private final List<Map<String, Object>> mapData = new ArrayList<>();
  4.     private final List<T> data = new ArrayList<>();
  5.     private final Map<Integer, String> errorMessageMap = new HashMap<>();
  6.     //非空校验map
  7.     private final Map<String, Boolean> nullAbleFieldMap = new HashMap<>();
  8.     //格式校验map
  9.     private final Map<String, String> checkFormatFieldMap = new HashMap<>();
  10.     //长度校验map    
  11.     private final Map<String, Integer> checkLengthFieldMap = new HashMap<>();
  12.     //枚举值校验map
  13.     private final Map<String, String[]> checkEnumFieldMap = new HashMap<>();
字段描述备注       
mapDataexcel读取完毕的Map数据Map<String,Object>
dataexcel读取完毕的对于实体ListList<T>
errorMessageMap错误信息mapMap<Integer,String>;key为错误行号，value为描述。
nullAbleFieldMap
非空校验map 
Map<String, Boolean>
checkFormatFieldMap
格式校验map：电话号码，ip,日期 
Map<String, String>
checkLengthFieldMap
长度校验map 
Map<String, Integer>
checkEnumFieldMap
枚举值检验map 
Map<String, String[]>

  

结合注解做参数校验或者格式校验的实现思路（反射加泛型）

 步骤一：在表头读取的监听方法里利用反射判断检验注解ExcelPropertyCheck加在了那些ExcelDTO哪些属性上，并且ExcelPropertyCheck注解的具体属性是什么将这些存入分门别类的map里面。

步骤二：在读取每行数据的时候，结合步骤一的map，判断数据是否需要校验，并且从map中取出校验的类型是什么，再去完成校验，如果校验失败则将错误信息放入errorMessageMap，当前读取的excel这一行数据全部校验通过则数据放入data 里面

完整的BaseListener<T>代码如下：

  1. import com.alibaba.excel.context.AnalysisContext;
  2. import com.alibaba.excel.metadata.data.ReadCellData;
  3. import com.alibaba.excel.read.listener.ReadListener;
  4. import com.alibaba.excel.read.metadata.holder.ReadSheetHolder;
  5. import com.baomidou.mybatisplus.core.toolkit.BeanUtils;
  6.  
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.util.StringUtils;
  10.  
  11. import java.lang.reflect.Field;
  12. import java.util.*;
  13.  
  14.  
  15. public class BaseListener<T> implements ReadListener<T> {
  16.  
  17.     private final Logger logger = LoggerFactory.getLogger(BaseListener.class);
  18.     private Class<?> headClazz;
  19.     //读取数据map形式
  20.     private final List<Map<String, Object>> mapData = new ArrayList<>();
  21.     //读取数据实体类泛型形式
  22.     private final List<T> data = new ArrayList<>();
  23.     //非空校验map
  24.     private final Map<String, Boolean> nullAbleFieldMap = new HashMap<>();
  25.     //格式校验map
  26.     private final Map<String, String> checkFormatFieldMap = new HashMap<>();
  27.     //长度校验map    
  28.     private final Map<String, Integer> checkLengthFieldMap = new HashMap<>();
  29.     //枚举值校验map
  30.     private final Map<String, String[]> checkEnumFieldMap = new HashMap<>();
  31.     //数据校验错误信息map key:错误的行号  value:错误信息描述
  32.     private final Map<Integer, String> errorMessageMap = new HashMap<>();
  33.  
  34.     public List<Map<String, Object>> getMapData() {
  35.         return mapData;
  36.     }
  37.  
  38.     public List<T> getData() {
  39.         return data;
  40.     }
  41.  
  42.     public Map<Integer, String> getErrorMessageMap() {
  43.         return errorMessageMap;
  44.     }
  45.  
  46.     public BaseListener() {
  47.     }
  48.  
  49.     /**
  50.      * @param headClazz excel model 类对象
  51.      */
  52.     public BaseListener(Class<?> headClazz) {
  53.         this.headClazz = headClazz;
  54.     }
  55.  
  56.     /**
  57.      * 读取发生异常时的方法
  58.      *
  59.      * @param exception
  60.      * @param context
  61.      * @throws Exception
  62.      */
  63.     @Override
  64.     public void onException(Exception exception, AnalysisContext context) throws Exception {
  65.         logger.debug("发生了异常");
  66.     }
  67.  
  68.     /**
  69.      * 读取头信息
  70.      *
  71.      * @param headMap
  72.      * @param context
  73.      */
  74.     @Override
  75.     public void invokeHead(Map<Integer, ReadCellData<?>> headMap, AnalysisContext context) {
  76.         ExcelPropertyCheck clazzHeadAnno = this.headClazz.getAnnotation(ExcelPropertyCheck.class);
  77.         Field[] declaredFields = headClazz.getDeclaredFields();
  78.         if (clazzHeadAnno != null && clazzHeadAnno.required()) {
  79.             for (Field declaredField : declaredFields) {
  80.                 nullAbleFieldMap.put(declaredField.getName(), true);
  81.             }
  82.         }
  83.  
  84.         for (Field declaredField : declaredFields) {
  85.             ExcelPropertyCheck annotation = declaredField.getAnnotation(ExcelPropertyCheck.class);
  86.             if (annotation != null) {
  87.                 if (annotation.checkFormat()) {
  88.                     checkFormatFieldMap.put(declaredField.getName(), annotation.type() + "");
  89.                 }
  90.                 if (annotation.required()) {
  91.                     nullAbleFieldMap.put(declaredField.getName(), true);
  92.                 } else {
  93.                     nullAbleFieldMap.remove(declaredField.getName());
  94.                 }
  95.                 if (annotation.required() && annotation.length() != -1) {
  96.                     checkLengthFieldMap.put(declaredField.getName(), annotation.length());
  97.                 }
  98.                 if (annotation.required() && annotation.value().length != 0) {
  99.                     checkEnumFieldMap.put(declaredField.getName(), annotation.value());
  100.                 }
  101.  
  102.             }
  103.         }
  104.     }
  105.  
  106.     /**
  107.      * 读取每一行数据
  108.      *
  109.      * @param t
  110.      * @param analysisContext
  111.      */
  112.     @Override
  113.     public void invoke(T t, AnalysisContext analysisContext) {
  114.         int rowIndex = ((ReadSheetHolder) analysisContext.currentReadHolder()).getRowIndex() + 1;
  115.         StringBuilder error = new StringBuilder();
  116.         Field[] declaredFields = t.getClass().getDeclaredFields();
  117.         //必填校验和格式校验
  118.         for (Field declaredField : declaredFields) {
  119.             try {
  120.                 declaredField.setAccessible(true);
  121.                 if (nullAbleFieldMap.get(declaredField.getName()) != null) {
  122.                     if (nullAbleFieldMap.get(declaredField.getName())) {
  123.                         Object o = declaredField.get(t);
  124.                         if (!Objects.nonNull(o)) {
  125.                             error.append(declaredField.getName()).append("为空;");
  126.                         } else {
  127.                             //字段不为空进行长度校验
  128.                             if (checkLengthFieldMap.get(declaredField.getName()) != null) {
  129.                                 if (String.valueOf(o).length() > checkLengthFieldMap.get(declaredField.getName())) {
  130.                                     error.append(declaredField.getName()).append("长度错误;");
  131.                                 }
  132.                             }
  133.                             if (checkEnumFieldMap.get(declaredField.getName()) != null) {
  134.                                 if (Integer.parseInt(String.valueOf(o)) == -1) {
  135.                                     error.append(declaredField.getName()).append("枚举值错误;");
  136.                                 }
  137.                             }
  138.                         }
  139.                     }
  140.                 }
  141.                 //是否需要进行格式校验
  142.                 if (checkFormatFieldMap.get(declaredField.getName()) != null) {
  143.                     String res = check(String.valueOf(declaredField.get(t)), Integer.valueOf(checkFormatFieldMap.get(declaredField.getName())));
  144.                     if (StringUtils.hasText(res)) {
  145.                         error.append(res);
  146.                     }
  147.                 }
  148.             } catch (IllegalAccessException e) {
  149.                 e.printStackTrace();
  150.             }
  151.         }
  152.         if (StringUtils.hasText(error.toString())) {
  153.             errorMessageMap.put(rowIndex, error.toString());
  154.         }
  155.         mapData.add(BeanUtils.beanToMap(t));
  156.         data.add(t);
  157.     }
  158.  
  159.  
  160.     @Override
  161.     public void doAfterAllAnalysed(AnalysisContext analysisContext) {
  162.         logger.info("excel解析完毕,共解析{}条数据,错误数据{}条，错误详情{}", data.size(), errorMessageMap.size(), errorMessageMap);
  163.     }
  164.  
  165.     private String check(String str, Integer checkType) {
  166.         switch (checkType) {
  167.             case 0:
  168.                 return DateUtil.isDateTimeFormat(str) ? "" : "日期格式错误;";
  169.             default:
  170.                 return "";
  171.         }
  172.     }
  173. }

如果导入时除了简单校验还需要特色校验如数据库去重，业务判断等，请另外写一个xxxReadListener 来继承BaseListener<T> 泛型为对应excel传输对象。重写监听方法时请务必super()一下，否则基本校验就没了！

5.model:excel传输对象

注解配置

为了不污染实体类和字段冗余请在这里定义excel传输对象加注解。

  1. @Data
  2. @EqualsAndHashCode
  3. @ExcelPropertyCheck
  4. public class DemoExcelDto {
  5.     @ExcelProperty("id")
  6.     @ExcelPropertyCheck(required = false)
  7.     private Long id;         //记录标识
  8.     @ExcelProperty("导入时间")
  9.     @ExcelPropertyCheck(required = true, checkFormat = true, type = ExcelPropertyType.DATE_TIME)
  10.     private LocalDateTime importTime;
  11. }

二、使用说明

1.读Excel

EasyExcelUtils.importExcel(file, IpDepartsExcelDto.class, listener)

  1. @RequestMapping("importExcel")
  2. @ResponseBody
  3. public Result importIps(MultipartFile file) {
  4.     //XXXReadListener listener = new XXXReadListener (XXXExcelDto.class);
  5.     //没有复杂的校验就用BaseListener
  6.     BaseListener<DemoExcelDto> listener = new BaseListener<>();
  7.     //获取校验错误信息
  8.     Map errorMap = EasyExcelUtils.importExcel(file, IpDepartsExcelDto.class, listener);
  9.     //获取读取完毕的数据,即使发生校验错误也会继续读取
  10.     List<IpDeparts> ipDeparts = EasyExcelUtils.dto2model(listener.getData() ,new IpDeparts());
  11.     if (errorMap.size() != 0) {
  12.         //errorMap校验数据不为空就是excel数据校验有不通过的数据。
  13.         return Result.failure(CommonResultStatus.IMPORT_FAIL, errorMap.toString());
  14.     } else {
  15.         //mapper保存数据库。
  16.         mapper.saveAll(ipDeparts);
  17.         return Result.success(CommonResultStatus.OK);
  18.     }
  19. }

2.写Excel

EasyExcelUtils.downloadExcel(response, fileName, ipDepartsExcelDtoList, IpDepartsExcelDto.class)

  1.     @GetMapping("download")
  2.     public void download(HttpServletResponse response) throws UnsupportedEncodingException {
  3.         String fileName = URLEncoder.encode("test", "utf-8");
  4.         List<DemoExcelDto> demoExcelDtos = new ArrayList<>();
  5.         for (int i = 0; i < 5; i++) {
  6.             DemoExcelDto demoExcelDto = new DemoExcelDto(i, "2020-08-01");
  7.             demoExcelDtos.add(demoExcelDto);
  8.         }
  9.         try {
  10.             EasyExcelUtils.downloadExcel(response, fileName, demoExcelDtos, DemoExcelDto.class);
  11.         } catch (IOException e) {
  12.             e.printStackTrace();
  13.         }
  14.     }

三、EasyExcelUtils（简单的导入导出工具类）

  1. import com.alibaba.excel.EasyExcel;
  2. import com.alibaba.excel.util.MapUtils;
  3. import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
  4. import com.alibaba.fastjson.JSON;
  5. import org.springframework.beans.BeanUtils;
  6. import org.springframework.web.multipart.MultipartFile;
  7.  
  8. import javax.servlet.http.HttpServletResponse;
  9. import java.io.IOException;
  10. import java.util.Collection;
  11. import java.util.List;
  12. import java.util.Map;
  13. import java.util.stream.Collectors;
  14.  
  15. public class EasyExcelUtils {
  16.     /**
  17.      * 导出excel
  18.      *
  19.      * @param response
  20.      * @param fileName 文件名
  21.      * @param data     List<数据集合>
  22.      * @throws IOException
  23.      */
  24.     public static <T> void downloadExcel(HttpServletResponse response, String fileName, List<T> data, Class<?> clazz) throws IOException {
  25.         try {
  26.             response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
  27.             response.setCharacterEncoding("utf-8");
  28.             response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
  29.             // 这里需要设置不关闭流
  30.             EasyExcel.write(response.getOutputStream(), clazz).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).autoCloseStream(Boolean.FALSE).sheet("sheet1")
  31.                     .doWrite(data);
  32.         } catch (Exception e) {
  33.             // 重置response
  34.             response.reset();
  35.             response.setContentType("application/json");
  36.             response.setCharacterEncoding("utf-8");
  37.             Map<String, String> map = MapUtils.newHashMap();
  38.             map.put("status", "failure");
  39.             map.put("message", "下载文件失败" + e.getMessage());
  40.             response.getWriter().println(JSON.toJSONString(map));
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 读取excel 文件
  46.      *
  47.      * @param file     文件
  48.      * @param cl       类对象
  49.      * @param listener 参数校验监听器
  50.      */
  51.     public static <T> Map importExcel(MultipartFile file, Class<T> cl, BaseListener<T> listener) {
  52.         try {
  53.             EasyExcel.read(file.getInputStream(), cl, listener).sheet().doRead();
  54.             return listener.getErrorMessageMap();
  55.         } catch (IOException e) {
  56.             return null;
  57.         }
  58.     }
  59.  
  60.     /**
  61.      * excleDto 转为对应model实体类
  62.      *
  63.      * @param data
  64.      * @param t
  65.      * @param <T>
  66.      * @return
  67.      */
  68.     public static <T> List<T> dto2model(Collection<?> data, T t) {
  69.         return data.stream().map(e -> {
  70.             T t1 = null;
  71.             try {
  72.                 t1 = (T) t.getClass().newInstance();
  73.             } catch (Exception exception) {
  74.                 exception.printStackTrace();
  75.             }
  76.             BeanUtils.copyProperties(e, t1);
  77.             return t1;
  78.         }).collect(Collectors.toList());
  79.     }
  80. }

四、总结：

经过简单的封装完成了一个带参数校验的简单使用案例，直接引入项目后在controller直接调用EasyExcelUtils的 "importExcel"方法和"downloadExcel"就能实现excel的导入导出，是不是很方便呢。

有问题留言大家一起交流学习。

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

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

  

闽ICP备14008679号