工具篇-EasyExcel-web行列合并导入

最新推荐文章于 2024-10-17 11:42:02 发布
最新推荐文章于 2024-10-17 11:42:02 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： java基础篇 java工具篇 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l123lgx/article/details/131594989
版权
本文介绍了如何使用阿里巴巴的EasyExcel库处理包含行列合并数据的Excel文件导入，特别是维护数据的层级结构。通过定义数据实体、监听器和数据处理逻辑，实现了导入时自动平铺合并单元格数据，并保持父子级关系。方法包括在监听器中维护层级关系，然后在控制器和实现类中处理数据并进行数据库操作。
摘要由CSDN通过智能技术生成

文章目录

前言

本文介绍excel 存在行列合并项的数据，进行web导入。

一、准备工作：

pom引入jar：

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>easyexcel</artifactId>
   <version>3.1.4</version>
</dependency>

二、数据导入：

1.导入思路：

在excel 中的数据是有层级结构的，那么导入的时候就需要通过一种方式将数据的上下级关系进行维护，由于正常导入时，被合并的单元格数据只会在某一条数据中出现，即使多条数据的父类都是一个，但多条数据中改单元格的值只会被放入到第一条数据，后续的数据都为null ，本文通过以下思路进行导入；

  • 将合并单元格的数据完全进行平铺展示，并且一个单元的父类只能有一个：
    在这里插入图片描述

  • 在导入时从第二个指标开始，填充该指标的父类指标值，如上图中 总平面 下的 机动车停车 指标，归属于 机动车停车，设置原则 则归属于总平面_机动车停车,将其层级关系进行字段维护；

  • 导入时通过遍历获取层级关系为 总平面 层级关系进行字段 则可以得到 总平面下的所以子级指标，同理，只要遍历 总平面_机动车停车 层级关系进行字段 则可以得到 机动车停车 下的子级指标；

2. 实现：

2.1 定义excel 导入数据实体：

根据自身业务完成定义


import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

import java.io.Serializable;
import java.util.List;

@Data
public class ProductAdaptExcelDictQuatoDto implements Serializable {

    @ExcelProperty(value = "序号")
    private Integer rowNum;
    @ExcelProperty(value = "指标类型")
    private String dictType;
    @ExcelProperty(value = "指标所属航道")
    private String channel;
    @ExcelProperty(value = "指标1",converter = CustomStringStringConverter.class)
    private String quato1;
    @ExcelProperty(value = "指标2",converter = CustomStringStringConverter.class)
    private String quato2;
    private String quato2Below;
    @ExcelProperty(value = "指标3",converter = CustomStringStringConverter.class)
    private String quato3;
    private String quato3Below;
    @ExcelProperty(value = "指标4",converter = CustomStringStringConverter.class)
    private String quato4;
    private String quato4Below;
    @ExcelProperty(value = "指标5",converter = CustomStringStringConverter.class)
    private String quato5;
    private String quato5Below;

//    @ExcelProperty(value = "指标6",converter = CustomStringStringConverter.class)
//    private String quato6;
//    private String quato6Below;

    @ExcelProperty(value = "单位")
    private String unit;
    @ExcelProperty(value = "输入方式")
    private String inputType;
    @ExcelProperty(value = "值域")
    private String inputValue;
    @ExcelProperty(value = "指标排序")
    private String order;
    @ExcelProperty(value = "指标备注")
    private String remark;


    private List<ProductAdaptExcelDictQuatoDto> childQuato;





}
  • @ExcelProperty 中 value 对应 excel 表头；
    在这里插入图片描述
  • converter 可以进行数据转换，本例将数据转为字符串，并去掉回车，换行，及前后空格；

import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.converters.ReadConverterContext;
import com.alibaba.excel.converters.WriteConverterContext;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.data.WriteCellData;

public class CustomStringStringConverter implements Converter<String> {
    @Override
    public Class<?> supportJavaTypeKey() {
        return String.class;
    }

    @Override
    public CellDataTypeEnum supportExcelTypeKey() {
        return CellDataTypeEnum.STRING;
    }

    /**
     * 这里读的时候会调用
     *
     * @param context
     * @return
     */
    @Override
    public String convertToJavaData(ReadConverterContext<?> context) {
        return context.getReadCellData().getStringValue().trim().replaceAll("[\r\n]", "");
    }

    /**
     * 这里是写的时候会调用 不用管
     *
     * @return
     */
    @Override
    public WriteCellData<?> convertToExcelData(WriteConverterContext<String> context) {
        return new WriteCellData<>(context.getValue());
    }

}
  • quato2Below,quato3Below … 用来维护层级关系

2.2 定义excel 导入listener：


import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.cric.zhongjian.common.core.utils.StringUtils;
import com.cric.zhongjian.system.dto.ProductAdaptExcelDictQuatoDto;

import java.util.ArrayList;
import java.util.List;

public class ProductAdaptDictQuatoExcelListener extends AnalysisEventListener<ProductAdaptExcelDictQuatoDto> {
    private List<ProductAdaptExcelDictQuatoDto> fileDatas = new ArrayList<>(1 << 5);

    @Override
    public void invoke(ProductAdaptExcelDictQuatoDto data, AnalysisContext context) {
       // 层级关系维护
        if (StringUtils.hasText(data.getQuato2())){
            data.setQuato2Below(String.format("%s_child",data.getQuato1()));
        }
        if (StringUtils.hasText(data.getQuato3())){
            data.setQuato3Below(String.format("%s_%s_child",data.getQuato1(),data.getQuato2()));
        }
        if (StringUtils.hasText(data.getQuato4())){
            data.setQuato4Below(String.format("%s_%s_%s_child",data.getQuato1(),data.getQuato2(),data.getQuato3()));
        }
        if (StringUtils.hasText(data.getQuato5())){
            data.setQuato5Below(String.format("%s_%s_%s_%s_child",data.getQuato1(),data.getQuato2(),data.getQuato3(),data.getQuato4()));
        }
//        if (StringUtils.hasText(data.getQuato6())){
//            data.setQuato6Below(String.format("%s_%s_%s_%s__%s_child",data.getQuato1(),data.getQuato2(),data.getQuato3(),data.getQuato4(),data.getQuato5()));
//        }
        fileDatas.add(data);
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 解析完成后的操作
    }

    public List<ProductAdaptExcelDictQuatoDto> getFileDatas() {
        return fileDatas;
    }
}

2.3 数据导入处理：

2.3.1 controller：
/**
 * 初始化指标字典
 *
 * @param file
 * @return
 */
@ResponseBody
@PostMapping("dictQuato")
public AjaxResult initDictQuato(@RequestParam("file") MultipartFile file,
                                     @RequestParam("tentCode") @Valid @NotEmpty String tentCode,
                                @RequestParam("lastQuatoLevel") @Valid @NotEmpty String  lastQuatoLevel) {

    InitProductAdaptDataReqDto reqDto = new InitProductAdaptDataReqDto();
    reqDto.setFile(file).setTentCode(tentCode).setLastQuatoLevel(lastQuatoLevel);
    return AjaxResult.success(initDataService.initDictQuato(reqDto));
}
2.3.1 impl：
@Override
public Map initDictQuato(InitProductAdaptDataReqDto reqDto) {
   MultipartFile file = reqDto.getFile();
   Map<String, Object> mapData = new HashMap<>(1 << 2);
   mapData.put("success", true);
   mapData.put("msg", "");
   if (ilegalFile(file)) {
       mapData.put("success", false);
       mapData.put("msg", "文件非法");
       return mapData;
   }

   // read
   List<ProductAdaptExcelDictQuatoDto> fileData = null;
   try {
       fileData = getDictQuatoFileData(file);
   } catch (Exception e) {
       mapData.put("success", false);
       mapData.put("msg", "文件数据读取异常:" + ExceptionFormatUtil.buildErrorMessage(e));
       return mapData;
   }
   List<Map<String, Object>> listMap = new ArrayList<>(1 << 8);
   fileData.stream().forEach(e -> {
       listMap.add(JSONObject.parseObject(JSONObject.toJSONString(e), Map.class));
   });

   // deal 对读取到的数据进行处理，根据自身业务处理
   Map<String, List<ProductAdaptExcelDictQuatoDto>> mapLeve1 = fileData.stream().collect(Collectors.groupingBy(ProductAdaptExcelDictQuatoDto::getQuato1, LinkedHashMap::new, Collectors.toList()));
   // 获取一级 指标
   List<ProductAdaptExcelDictQuatoDto> leve1 = new ArrayList<>(1 << 8);
   mapLeve1.entrySet().stream().forEach(e -> {
       e.getValue().sort(Comparator.comparingInt(ProductAdaptExcelDictQuatoDto::getRowNum));
       leve1.add(e.getValue().get(0));
   });
   // 按照一级 指标读取的顺序排序，保证和excel 指标顺序一直
   leve1.sort(Comparator.comparingInt(ProductAdaptExcelDictQuatoDto::getRowNum));
   // 指标排序
   AtomicInteger sort = new AtomicInteger(5);
   // 指标id
   AtomicInteger idAtomic = new AtomicInteger(1);
   List<QuatoDto> currentRow = leve1.stream().map(e ->
           new QuatoDto(e.getRowNum(), idAtomic.getAndIncrement(), null, e.getQuato1(), new ArrayList<>(1 << 6), 1, e.getQuato1(), sort.getAndAdd(5))).collect(Collectors.toList());

	// 递归数据处理
   dealDictQuatoFileData(currentRow, listMap, fileData, reqDto, idAtomic);
	// 处理完成则 currentRow 保存了所有层级数据,根据自身业务对currentRow 数据的数据库导入
	// 根据自身业务自行处理
	// 处理思路：
	// 1 递归遍历currentRow 
	// 2 插入和更新的判断：数据通过 QuatoDto 下的quatoNameAppend（层级指标汇总值） 和 原有数据对比如果存在则更新，否则插入
	// 3 当有数据需要插入后，在对子级数据 父级id 进行更新
	
   return mapData;
}

// 递归遍历--父子级指标处理
private void dealDictQuatoFileData(List<QuatoDto> currentData, List<Map<String, Object>> listMap, List<ProductAdaptExcelDictQuatoDto> allData,
                             InitProductAdaptDataReqDto reqDto, AtomicInteger idAtomic) {

   if (CollectionUtils.isEmpty(currentData)) {
       return;
   }
   for (QuatoDto e : currentData) {
       // 当前指标
       Map<String, Object> mapData = listMap.get(e.getRowNum() - 1);
		// 当前指标--下级指标属性
       String childQuatoBelow = getChildQuatoBelow(mapData, e.getCurrentQuatoIndex());

       Integer finalCurrentQuatoIndex = e.getCurrentQuatoIndex() + 1;
       // 获取当前指标的--下级指标
       List<QuatoDto> nextChildRow = listMap.stream().filter(f -> {
           if (null == f.get(String.format("quato%dBelow", finalCurrentQuatoIndex))) {
               return false;
           }
           String q1 = f.get(String.format("quato%dBelow", finalCurrentQuatoIndex)).toString();
           return q1.equals(childQuatoBelow);

       }).map(ff -> {
           QuatoDto oneDto = new QuatoDto((Integer) ff.get("rowNum"), null, null, ff.get(String.format("quato%d", finalCurrentQuatoIndex)) + ""
                   , new ArrayList<>(1 << 6), e.getCurrentQuatoIndex() + 1, getQuatoNameAppend(ff, finalCurrentQuatoIndex), 0);
           return oneDto;
       }).collect(Collectors.toList());
       if (CollectionUtils.isEmpty(nextChildRow)) {
           continue;
       }


       // 下级指标如果有重复，需要去重
       Map<String, List<QuatoDto>> map1 = nextChildRow.stream().collect(Collectors.groupingBy(QuatoDto::getQuatoName, LinkedHashMap::new, Collectors.toList()));
       List<QuatoDto> nextChild = new ArrayList<>(map1.keySet().size());
       AtomicInteger sort = new AtomicInteger(5);
       map1.entrySet().stream().forEach(gg -> {
           if (CollectionUtils.isEmpty(gg.getValue())) {
               return;
           }
           gg.getValue().get(0).setSort(sort.getAndAdd(5));
           nextChild.add(gg.getValue().get(0));

       });
       // 子级指标id 及父级id 设置
       nextChild.stream().forEach(gg -> {
           gg.setId(idAtomic.getAndIncrement()).setParentId(e.getId());
       });
       // 子级指标设置
       e.setChild(nextChild);
       // 递归处理
       dealDictQuatoFileData(nextChild, listMap, allData, reqDto, idAtomic);
   }

}
private String getQuatoNameAppend(Map<String, Object> ff, Integer finalCurrentQuatoIndex) {
    StringBuilder quatoName = new StringBuilder();
    for (Integer i = 1; i < finalCurrentQuatoIndex + 1; i++) {
        quatoName.append(ff.get(String.format("quato%d", i)));
        if (i < finalCurrentQuatoIndex) {
            quatoName.append("_");
        }
    }
    return quatoName.toString();
}

@Data
@AllArgsConstructor
static class QuatoDto {
	// 指标对应excel 的行号
   private Integer rowNum;
   //  指标的id
   private Integer id;
   // 指标的父级id
   private Integer parentId;
   // 指标名称
   private String quatoName;
   // 子级指标
   private List<QuatoDto> child;
   // 当前指标的层级  
   private Integer currentQuatoIndex;
   // 当前指标 父子级指标：父指标_子指标_子指标。。。
   private String quatoNameAppend;
   // 当前指标的排序号
   private Integer sort;
}


private String getChildQuatoBelow(Map<String, Object> mapData, Integer currentQuatoIndex) {
    if (1 == currentQuatoIndex) {
        return String.format("%s_%s", mapData.get("quato" + currentQuatoIndex), "child");
    }
    if (2 == currentQuatoIndex) {
        return String.format("%s_%s_%s", mapData.get("quato1"), mapData.get("quato2"), "child");
    }
    if (3 == currentQuatoIndex) {
        return String.format("%s_%s_%s_%s", mapData.get("quato1"), mapData.get("quato2"), mapData.get("quato3"), "child");
    }
    if (4 == currentQuatoIndex) {
        return String.format("%s_%s_%s_%s_%s", mapData.get("quato1"), mapData.get("quato2"), mapData.get("quato3")
                , mapData.get("quato4"), "child");
    }
    if (5 == currentQuatoIndex) {
        return String.format("%s_%s_%s_%s_%s_%s", mapData.get("quato1"), mapData.get("quato2"), mapData.get("quato3")
                , mapData.get("quato4"), mapData.get("quato5"), "child");
    }
    return "";
}


private List<ProductAdaptExcelDictQuatoDto> getDictQuatoFileData(MultipartFile file) throws IOException {
   // 创建 Excel 读取监听器
   ProductAdaptDictQuatoExcelListener listener = new ProductAdaptDictQuatoExcelListener();
   // 读取 Excel 文件
   EasyExcel.read(file.getInputStream(), ProductAdaptExcelDictQuatoDto.class, listener).extraRead(CellExtraTypeEnum.MERGE).sheet().doRead();
   return listener.getFileDatas();
}

总结

本文通过EasyExcel将有层级关系的Excel 数据进行导入；

拽着尾巴的鱼儿
关注
专栏目录
poi导入/导出Excel表格，合并单元格的读取和设置
03-25
poi导入/导出Excel表格，合并单元格的读取和设置
asyExcel导入存在合并单元格的Excel
Ztw_bb的博客
05-24 1312
Excel表格 下面是Excel表格，成果简介前可以作为主表数据存储(存在合并)，成果简介后的数据作为从表数据存储。 实现思路 通过EasyExcel读取Excel数据，用List<AwardsDetailField> list接收 因为POI/EasyExcel对合并单元格的数据只读取一次，需要把为空的单元格也赋值，这是核心技术难点。 循环使用hibernate-validator对数据进行校验 存在校验不通过的数据返回给前端,所有数据校验通过才写入数据库 封装然后写入数据库 用
使用 EasyExcel 相邻数据相同时行和列的合并,包括动态表头、数据
最新发布
dream_snow2012的专栏
10-17 592
在处理 Excel 文件时，经常会遇到需要对表格中的某些单元格进行合并的情况，例如合并相同的行或列。Apache POI 是一个强大的工具，但它使用起来相对复杂。相比之下，EasyExcel 是一个基于 Apache POI 的轻量级 Excel 处理库，它提供了更简单易用的 API，使得处理 Excel 文件变得更加方便。本文将介绍如何使用 EasyExcel 进行列和列的合并，并提供一个完整的示例代码。通过上述步骤，我们成功地使用 EasyExcel 实现了 Excel 文件中行和列的合并。
EasyExcel合并行处理并优化
CloudX的专栏
07-20 5273
本来打算调整为异步导出解决此问题，但是经过测试发现10000条数据如果不合并直接生成excel只要十几秒，但是使用合并自定义合并策略就非常慢，需要一二十分钟，这个时间差大的太离谱了，于是查看合并策略代码有哪些地方可以优化的。于是先简单的写一个工具类实现根据数据自定义合并单元行，基本思路是获取当前单元格内容和上一行的单元格内容比对，如果相同则添加合并区域，如果不同则不处理，如果上一个单元格在合并区域中，则先移除合并区域再将当前单元格添加到合并区域中。3次删除，大大的影响了效率。
EasyExcel导出自定义列，合并列，合并行，动态表格表头
qq_33763772的博客
06-06 8557
EasyExcel导出按列顺序排序，合并列，合并行，动态表格
easyexcel导入合并单元格解析（纵向合并，横向合并都支持）
wuesr的博客
01-23 4191
easyexcel导入合并单元格解析（纵向合并，横向合并都支持）
easyExcel-读取合并单元格
xhmico的博客
03-21 8142
之前有介绍过如何使用easyExcel，以及写了两个入门的demo，这两个demo能应付在开发中大多数的导入和导出需求，不过有时候面对一些复杂的表格，就会有点不够用，该篇就是关于我如何处理表格中的合并单元格的一个开发过程记录以下内容是结合Java-easyExcel入门教程中的案例代码去实现的，可能与你项目中所使用的会有点不同假如说你有一个表格的数据想要导入到系统中，在通常情况下，面对标准的表格文件，比如：表头和内容都比较工整，每个单元格对应一个数据，通过Java-easyExcel入门教程。
java导出excel-easyExceljava导出excel-easyExcel
08-02
java导出excel
easyexcel-阿里导入导出工具类
03-12
easyexcel 阿里导入导出工具类
EasyExcel-合并单元格.doc
07-10
EasyExcel-合并单元格技术详解 EasyExcel 是一个功能强大的 Excel 处理库，提供了许多便捷的 API 来处理 Excel 文件。在实际应用中，我们经常需要合并单元格，以便更好地展示数据。在本文中，我们将详细介绍如何...
POI-EasyExcel笔记1
08-03
本文将深入探讨这两个工具，并介绍如何使用它们进行Excel数据的导入与导出。 首先，Apache POI是一个开源的API，它允许Java程序创建、修改和显示MS Office格式的文件，包括Excel。Apache POI提供了广泛的API，可以...
基于java的poi-easyexcel-Demo
12-13
6. 响应式编程：EasyExcel也支持响应式编程模式，能够更好地适应现代Web开发的需求。 在实际开发中，Apache POI和EasyExcel结合使用，可以应对各种复杂的Excel处理场景。例如，POI用于复杂的格式控制和高级功能，而...
Ruoyi框架使用easyExcel实现单元格合并
wuhuangji的博客
07-12 5707
/ 你也可以在创建行的时候进行拦截，也可以在创建单元格的时候拦截，不同功能实现不同的接口 public class TableHeadHandler implements SheetWriteHandler {// 基础的excel操作，可以在此处添加表头的样式 Workbook workbook = writeWorkbookHolder . getWorkbook();row0 . createCell(0) . setCellValue("第一行");
【EasyExcel】EasyExcel导入合并单元格的数据
tl101120的博客
03-30 1142
【代码】【EasyExcel】EasyExcel导入合并单元格的数据。
EasyExcel导入数据（合并单元格）
m0_61662029的博客
12-04 3187
EasyExcel导入数据合并单元格处理
EasyExcel导出多列相同合并处理以及单列相同合并处理
weixin_50348837的博客
09-09 9783
Data@HeadRowHeight(60) //设置表头行高度@ContentRowHeight(25) //设置内容行高度@ColumnWidth(15) //指定列宽大小为15@HeadStyle(fillForegroundColor = 44) //设置表头背景颜色@ExcelProperty({"仓库"})@ExcelProperty({"入库类型"})@ExcelProperty({"入库日期"})@ExcelProperty({"入库单号"})
easyexcel复杂模板导出（合并行列，列统计汇总）
weixin_39172079的博客
03-14 8858
easyexcel复杂模板导出
EasyExcel合并行（纵向合并）
weixin_46114883的博客
02-14 1098
合并行（纵向合并）
实战演练，如何用Easyexcel合并单元格，设置字体、边框样式，并在尾行加入备注
热门推荐
Su7148的博客
09-18 1万+
，实现效果如下：1、多级表头合并2、表头底纹+表格边框3、合并相同数据单元格4、尾行加入备注。
java - easyexcel 实现excel导出下拉多选框 模板
09-04
使用EasyExcel实现excel导出下拉多选框模板的方法如下： 1. 首先，引入EasyExcel依赖。在pom.xml文件中加入以下依赖： ```xml <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.2.11</version> </dependency> ``` 2. 创建一个Java类作为数据的模型。例如： ```java public class DataModel { private String name; private List<String> options; // 省略getters和setters } ``` 3. 创建一个Controller类，用于处理请求和导出Excel文件。例如： ```java @Controller public class ExcelController { @GetMapping("/export") public void export(HttpServletResponse response) throws IOException { // 创建excel写入器 EasyExcel.write(response.getOutputStream(), DataModel.class).sheet("Sheet1").doWrite(getData()); } private List<DataModel> getData() { // 返回要导出的数据列表 List<DataModel> data = new ArrayList<>(); DataModel model = new DataModel(); model.setName("张三"); model.setOptions(Arrays.asList("选项1", "选项2", "选项3")); data.add(model); // 添加更多的数据 return data; } } ``` 4. 在前端页面中创建一个链接，点击该链接即可触发导出Excel文件的操作。例如： ```html <a href="/export">导出Excel</a> ``` 5. 运行程序，点击前端页面中的导出链接，即可下载一个包含下拉多选框的Excel文件。 以上就是使用EasyExcel实现excel导出下拉多选框模板的步骤和代码示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值