EasyExcel实现批量导入

已于 2023-05-04 01:11:30 修改
阅读量645 收藏 1
点赞数
文章标签： excel java 开发语言
于 2023-05-04 01:10:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miaoo_/article/details/130479505
版权

pom引入

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

异步导入接口

controller层

    @ApiOperation(value = "1.0版本-客户信息导入")
    @PostMapping("/clubImport")
    public Result<Map<String, String>> clubImport(@RequestParam("file") MultipartFile file, @ApiParam("业务渠道") @RequestParam("businessChannel") Integer businessChannel
            , @RequestParam("shopCode") String shopCode, @RequestParam("shopName") String shopName,@ApiParam("导入模版类型：1-普通模版，2-抖音模版") @RequestParam("importType") Integer importType) {
        ImportClueParam importClueParam = new ImportClueParam();
        importClueParam.setFile(file);
        importClueParam.setShopCode(shopCode);
        importClueParam.setBusinessChannel(businessChannel);
        importClueParam.setShopName(shopName);
        importClueParam.setImportType(importType);
        importClueParam.setTest(AuthNHolderUtils.isTest());
        String batchNo = LocalDateTime.now().format(DateTimeFormatter.ofPattern(DateUtils.DATE_NO_CHAR_PATTERN));
        log.info("开始导入客户信息，本次导入批次号：{}，店铺code：{}，店铺名称：{}，业务渠道：{},模版类型：{}", batchNo, shopCode, shopName, businessChannel,importType);
        try {
            //加锁，同一时间只有一个导入任务在进行
            boolean tryLock = redisLock.tryLock(ImportConstant.IMPORT_LOCK_KEY + batchNo, 10);
            if (!tryLock) {
                return Result.fail("500", "存在其他正在进行的导入任务");
            }
            //数据解析和校验
            List<ClueImportTemporaryDO> covertList = clueImportService.handleExcel(importClueParam);
            log.info("批次号：{} 客户信息解析完成，本次导入的客户手机号：[{}]",batchNo, covertList.stream().map(ClueImportTemporaryDO::getPhone).collect(Collectors.joining(",")));
            //异步完成校验数据及导入任务
            clueImportService.asynHandleList(covertList, batchNo, importType);

            log.info("clubImport结束:{},batchNo:{}", LocalDateTime.now(), batchNo);
            //返回批次号
            HashMap<String, String> batchMap = new HashMap<>();
            batchMap.put("batchNo", batchNo);
            return Result.success(batchMap);
        } catch (DccCrmException e) {
            log.error("error_clueImport_DccCrmException异常:{}", e.getMessage());
            throw e;
        } catch (Exception e) {
            log.error("error_clueImport_Exception异常:{}", e.getMessage());
            if (e.getCause() instanceof DccCrmException) {
                throw (DccCrmException) e.getCause();
            }
            throw new DccCrmException(ErrorCodeEnum.EXCEL_ERROR);
        } finally {
            //释放锁
            redisLock.unlock(ImportConstant.IMPORT_LOCK_KEY + batchNo);
        }
    }

返回实体对象

@Data
@ApiModel(value = "ImportCustomerEchoVO", description = "导入数据回显")
public class ImportCustomerEchoVO {

    @ApiModelProperty("列表数据")
    private List<ImportCustomerVO> importCustomerVOS;
    @ApiModelProperty("一共识别数据")
    private Integer total;
    @ApiModelProperty("新增成功客户数量")
    private Integer successNum;
    @ApiModelProperty("新增失败客户数据数量")
    private Integer failNum;
    @ApiModelProperty("批次号")
    private String batchUid;
}

service层–clueImportService数据解析和校验

    @SneakyThrows
    @Override
    public List<ClueImportTemporaryDO> handleExcel(ImportClueParam importClueParam) {
        ExcelImportSimpleListener simpleListener = new ExcelImportSimpleListener();
        ExcelImportDouyinListener douyinListener = new ExcelImportDouyinListener();
        List<ClueImportTemporaryDO> voList = new ArrayList<>();
        //根据输入的来源渠道调用对应的模版进行导入
        if (importClueParam.getImportType().equals(ImportTypeEnum.DOUYIN.getCode())) {
            log.info("开始解析抖音excel模板的客户导入信息，导入批次号：{}", importClueParam.getBatchNo());
            EasyExcel.read(importClueParam.getFile().getInputStream(), ImportClueDouyinVO.class, douyinListener).sheet().doRead();
            voList = douyinListener.getList();
            if (voList.size() > 1000) {
                throw new DccCrmException(ErrorCodeEnum.MAX_1000);
            }
            voList.forEach(x -> {
                x.setLastOperator(AuthNHolder.displayName());
                x.setTemplateType(TemplateTypeEnum.DOUYIN.getType());
                x.setShopCode(importClueParam.getShopCode());
                x.setBusinessChannel(importClueParam.getBusinessChannel());
                x.setShopName(importClueParam.getShopName());
                x.setIsTest(importClueParam.isTest() ? 1 : 0);
            });
        } else if (importClueParam.getImportType().equals(ImportTypeEnum.SIMPLE.getCode())) {
            log.info("开始解析通用excel模板的客户导入信息，导入批次号：{}", importClueParam.getBatchNo());
            EasyExcel.read(importClueParam.getFile().getInputStream(), ImportClueSimpleVO.class, simpleListener).sheet().doRead();
            voList = simpleListener.getList();
            if (voList.size() > 1000) {
                throw new DccCrmException(ErrorCodeEnum.MAX_1000);
            }
            voList.forEach(x -> {
                x.setLastOperator(AuthNHolder.displayName());
                x.setTemplateType(TemplateTypeEnum.SIMPLE.getType());
                x.setShopCode(importClueParam.getShopCode());
                x.setBusinessChannel(importClueParam.getBusinessChannel());
                x.setShopName(importClueParam.getShopName());
                x.setIsTest(importClueParam.isTest() ? 1 : 0);
            });
        } else {
            throw new DccCrmException(ErrorCodeEnum.IMPORT_TYPE_ERROR);
        }
        return voList;
    }

		//异步完成校验及导入
		@Override
    @Async
    public void asynHandleList(List<ClueImportTemporaryDO> voList, String batchNo, Integer importType) {
        log.info("开始异步处理解析出的客户信息，批次号：{}", batchNo);
        if (CollectionUtils.isEmpty(voList)) {
            redisTemplate.opsForValue().set(ImportConstant.PROGRESS_BAR_KEY + batchNo, new ImportRedisVO().setFlag(1).setDesc("导入成功"));
            return;
        }
        ImportRedisVO importRedisVO = new ImportRedisVO();
        //在redis中存入重复数据
        //封装phones
        List<String> phones = voList.stream().map(ClueImportTemporaryDO::getPhone).collect(Collectors.toList());
        String shopCode = voList.get(0).getShopCode();
        List<String> existPhones = new ArrayList<>();
        if (StringUtils.isNotBlank(shopCode) && CollectionUtils.isNotEmpty(phones)) {
            existPhones = customerSPI.getExistCustomerByShopAndPhone(shopCode, phones);
        }
        importRedisVO.setRepeatNum(existPhones.size());
        List<ClueImportTemporaryDO> failInsertList = new ArrayList<>();
        importRedisVO.setFlag(0);
        //校验数据
        List<ClueImportTemporaryDO> list = checkList(voList, batchNo, importRedisVO, importType);
        //插入临时表
        importRedisVO.setDesc("正在插入数据");
        redisTemplate.opsForValue().set(ImportConstant.PROGRESS_BAR_KEY + batchNo, importRedisVO);
        //分批处理插入，异常数据存入redis
        List<List<ClueImportTemporaryDO>> partition = Lists.partition(list, 100);
        partition.stream().forEach(page -> {
            try {
                clueImportTemporaryMapper.insertList(page);
            } catch (Exception e) {
                //插入失败，则单条插入，异常数据存入redis
                page.forEach(p -> {
                    try {
                        basicDao.insert(p, ClueImportTemporaryDO.class);
                    } catch (Exception exception) {
                        p.setRemark(StringUtils.isNotBlank(p.getRemark()) ? p.getRemark() : "" + " 数据入库异常，请检查字段长度");
                        failInsertList.add(p);
                    }
                });
            }

        });
        importRedisVO.setFailInsertList(failInsertList);
        //导入成功的调用线索服务
        importRedisVO.setDesc("正在传入线索服务");
        redisTemplate.opsForValue().set(ImportConstant.PROGRESS_BAR_KEY + batchNo, importRedisVO);
        List<ClueImportTemporaryDO> successList = list.stream().filter(x -> x.getImportState() == 1).collect(Collectors.toList());
        successList.removeAll(failInsertList);
        List<AddClueRequest> clues = convertClueData(successList);
        //调用线索dubbo接口，线索中心要求每次最多传500条
        List<List<AddClueRequest>> kozukiList = Lists.partition(clues, 500);
        kozukiList.forEach(clueSPI::batchAddClue);
        log.info("异步处理解析出的客户信息完成，批次号：{}", batchNo);
        importRedisVO.setFlag(1);
        importRedisVO.setDesc("导入成功");
        redisTemplate.opsForValue().set(ImportConstant.PROGRESS_BAR_KEY + batchNo, importRedisVO);
    }

ExcelImportSimpleListener

@Slf4j
public class ExcelImportSimpleListener extends AnalysisEventListener<ImportClueSimpleVO> {

    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */


    private static final int BATCH_COUNT = 3000;
    List<ClueImportTemporaryDO> list = new ArrayList<>();
    private static int count = 1;

    @Override
    public void invoke(ImportClueSimpleVO data, AnalysisContext context) {
        try {
            boolean isNullObject = BeanUtils.checkFieldAllNull(data);
            if(isNullObject){
                return;
            }
        } catch (IllegalAccessException e) {
            log.error("invoke 判空异常:{}",data,e);
        }
        ClueImportTemporaryDO clue = BeanUtils.convert(data, ClueImportTemporaryDO.class);
        String errorRemark = String.format("时间：%s 不符合标准，请输入标准格式yyyy-MM-dd HH:mm:dd;", data.getClueCollectionTime());
        if (StringUtils.isBlank(data.getClueCollectionTime())) {
            clue.setImportState(ImportStateEnum.FAIL.getType());
            clue.setRemark("线索收集日期为空");
            list.add(clue);
            return;
        }
        // 判断时间格式
        String timeStr = ExcelUtils.convertTime(data.getClueCollectionTime());
        clue.setImportState(ImportStateEnum.SUCCESS.getType());
        if (StringUtils.isBlank(timeStr)) {
            // 时间格式不符合，记录错误日志
            data.setErrorRemark(errorRemark);
            clue.setImportState(ImportStateEnum.FAIL.getType());
        } else {
            data.setClueCollectionTime(timeStr);
            boolean matches = Pattern.matches(DateUtils.TIME_PATTERN, timeStr);
            if (!matches) {
                data.setErrorRemark(errorRemark);
                clue.setImportState(ImportStateEnum.FAIL.getType());
            } else {
                SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.DATE_TIME_PATTERN_SLASH);
                try {
                    clue.setClueCollectionTime(sdf.parse(timeStr).toInstant().atZone(ZoneOffset.ofHours(8)).toLocalDateTime());
                } catch (ParseException e) {
                    data.setErrorRemark(errorRemark);
                    clue.setImportState(ImportStateEnum.FAIL.getType());
                    log.error("导入时间转化错误：时间：{},错误：{}", data.getClueCollectionTime(), e.getMessage());
                }
            }
        }
        clue.setSourceChannel(Objects.nonNull(SourceChannelEnum.getByDesc(data.getInteractionSource())) ?
                SourceChannelEnum.getByDesc(data.getInteractionSource()).getCode() : null);
        clue.setRemark(StringUtils.isNotBlank(data.getErrorRemark()) ? data.getErrorRemark() : "");
        clue.setClueCollectionTimeStr(data.getClueCollectionTime());
        list.add(clue);
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        saveData(count);
        System.out.println("所有数据解析完成！");
        System.out.println(" count ：" + count);
    }

    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        if (headMap.size() != 13 || !headMap.values().contains("客户姓名")) {
            throw new DccCrmException(ErrorCodeEnum.SIMPLE_TEMPORARY_ERROR);
        }
    }

    /**
     * 加上存储数据库
     */
    private void saveData(int count) {
        System.out.println("存储数据库成功！");
    }

    public List<ClueImportTemporaryDO> getList() {
        return this.list;
    }
}

前端轮询查看导入结果接口

controller层

    @ApiOperation(value = "1.0版本-根据批次号获取导入结果")
    @GetMapping("/getResult")
    public Result<ImportClueEchoVO> getResult(@RequestParam String batchNo) {
        try {
            ImportClueEchoVO importClueEchoVO = clueImportService.getResult(batchNo);
            return Result.success(importClueEchoVO);
        } catch (Exception e) {
            log.error("error_getResult", e);
            return Result.fail("500", e.getMessage());
        }
    }

service层–clueImportService

@Override
    public ImportClueEchoVO getResult(String batchNo) {
        ImportClueEchoVO importClueEchoVO = new ImportClueEchoVO();
        List<ClueImportTemporaryDO> listAll = clueImportTemporaryMapper.selectListByBatchNo(new QueryClueParam().setBatchNo(batchNo));
        List<ClueImportTemporaryDO> failList = listAll.stream().filter(x -> x.getImportState().equals(ImportStateEnum.FAIL.getType())).collect(Collectors.toList());
        //合并redis中的失败数据
        ImportRedisVO bar = (ImportRedisVO) redisTemplate.opsForValue().get(ImportConstant.PROGRESS_BAR_KEY + batchNo);
        if (CollectionUtils.isNotEmpty(failList)) {
            failList.addAll(bar.getFailInsertList());
        } else {
            failList = CollectionUtils.isNotEmpty(bar.getFailInsertList()) ? bar.getFailInsertList() : Collections.EMPTY_LIST;
        }
        if (CollectionUtils.isNotEmpty(listAll)) {
            listAll.addAll(bar.getFailInsertList());
        } else {
            listAll = CollectionUtils.isNotEmpty(bar.getFailInsertList()) ? bar.getFailInsertList() : Collections.EMPTY_LIST;
        }

        //数据Mapstruct复制
        List<ImportClueVO> importClueVOS = ClueExportConvert.INSTANCE.do2ClueVoList(failList);
        importClueEchoVO.setImportClueVOS(importClueVOS);
        importClueEchoVO.setTotal(listAll.size());
        importClueEchoVO.setFailNum(failList.size());
        importClueEchoVO.setSuccessNum(importClueEchoVO.getTotal() - failList.size());
        importClueEchoVO.setBatchNo(batchNo);
        //从redis中获取重复数
        importClueEchoVO.setRepeatNum(bar.getRepeatNum());
        return importClueEchoVO;
    }

前端轮询查看导入进度条接口

controller层

    @ApiOperation(value = "1.0版本-根据批次号获取进度条信息")
    @GetMapping("/getProcessBar")
    public Result<ImportRedisVO> getProcessBar(@RequestParam String batchNo) {
        try {
            ImportRedisVO bar = (ImportRedisVO) redisTemplate.opsForValue().get(ImportConstant.PROGRESS_BAR_KEY + batchNo);
            return Result.success(bar);
        } catch (Exception e) {
            log.error("error_getResult", e);
            return Result.fail("500", e.getMessage());
        }
    }

确认导入–从临时表落库

controller层

    @ApiOperation(value = "客户信息-确认导入")
    @PostMapping("/confirmImport")
    public Result confirmCustomerImport(@RequestParam("batchUid") String batchUid, @RequestParam(value = "addClueFlag", required = false) Integer addClueFlag) {
        return Result.success(customerService.confirmCustomerImport(batchUid, addClueFlag));
    }

service层

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<ImportCustomerVO> confirmCustomerImport(String batchUid, Integer addClueFlag) {
        //1,通过批次号获取临时表数据
        List<CustomerImportTemporaryDO> customerImportTemporaryDOList = customerImportTemporaryDao.queryCustomerImportTemporaraByBatchUid(batchUid);
        if (CollectionUtils.isEmpty(customerImportTemporaryDOList)) {
            return new ArrayList<>();
        }
        //2,组装线索接口需要的数据  待修改
        //数据库customer转map
        Map<String, CustomerDO> customerDOMap = new HashMap<>();
        //数据库customer存在的code
        List<String> customerCodes = new ArrayList<>();
        List<String> phones = customerImportTemporaryDOList.stream().map(CustomerImportTemporaryDO::getPhone).collect(Collectors.toList());
        getCustomerInfo(phones, customerDOMap, customerCodes);

        //临时表数据分组
        Map<String, List<CustomerImportTemporaryDO>> customerImportTemporaryDOMap = customerImportTemporaryDOList.stream()
                .sorted(Comparator.comparing(CustomerImportTemporaryDO::getId))
                .collect(Collectors.groupingBy(CustomerImportTemporaryDO::getPhone, LinkedHashMap::new, Collectors.toList()));
        //意向周期分组
        List<Integer> cycleIds = new ArrayList<>();
        Map<String, CustomerIntentionCycleDO> customerIntentionCycleDOMap = getCustomerIntentionCycleDOMap(customerCodes, cycleIds);

        //意向车型
        Map<Integer, CustomerIntentionCarDO> customerIntentionCarDOMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(cycleIds)) {
            List<CustomerIntentionCarDO> customerIntentionCarDOS = customerIntentionCarDao.getByCycleIds(cycleIds);
            customerIntentionCarDOMap = customerIntentionCarDOS.stream().collect(Collectors.toMap(CustomerIntentionCarDO::getCycleId, Function.identity(), (o, n) -> n));
        }

        //跟进
        Map<Integer, List<CustomerFollowUpDO>> customerFollowUpDOMap;
        if (CollectionUtils.isNotEmpty(cycleIds)) {
            List<CustomerFollowUpDO> customerFollowUpDOS = customerFollowUpDao.queryByCycleIds(cycleIds);
            customerFollowUpDOMap = customerFollowUpDOS.stream().collect(Collectors.groupingBy(CustomerFollowUpDO::getCycleId));
        } else {
            customerFollowUpDOMap = new HashMap<>();
        }

        List<CustomerImportTemporaryDO> customerImportTemporaryDOListAdd = new ArrayList<>();
        customerImportTemporaryDOMap.forEach((phone, customerImportTemporaryDOS) -> {
            CustomerDO customerDO = customerDOMap.get(phone);
            CustomerImportTemporaryDO customerImportTemporaryDO = customerImportTemporaryDOS.get(customerImportTemporaryDOS.size() - 1);
            List<CustomerImportTemporaryDO> stroeList = customerImportTemporaryDOS.stream().
                    filter(item -> StringUtils.isNotBlank(item.getDeliverTheStoreCode())).sorted(Comparator.comparing(CustomerImportTemporaryDO::getId)).collect(Collectors.toList());
            if (customerDO == null) {
//                String storeCode = customerImportTemporaryDO.getDeliverTheStoreCode();
                if (CollectionUtils.isNotEmpty(stroeList)) {
                    customerImportTemporaryDOListAdd.add(stroeList.get(stroeList.size() - 1));
                }
            } else {
                if (customerDO.getIssuedFlag() == 0) {
                    if (CollectionUtils.isNotEmpty(stroeList)) {
                        customerImportTemporaryDOListAdd.add(stroeList.get(stroeList.size() - 1));
                    }
                }
            }
        });
        if (CollectionUtils.isNotEmpty(customerImportTemporaryDOListAdd)) {
            List<AddClueRequest> clues = convertClueData(customerImportTemporaryDOListAdd);
            //3,调用线索dubbo接口
            if (addClueFlag == null || 1 != addClueFlag) {//传入1时 不调线索
                clueSPI.batchAddClue(clues);
            }
        }
        //4，数据处理到新表里
        List<Integer> ids = customerImportTemporaryDOList.stream().map(CustomerImportTemporaryDO::getId).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(ids)) {
            customerImportTemporaryMapper.updateIsImport(ids);
        }
        customerServiceUtil.sureCustomersByImport(customerImportTemporaryDOMap, customerDOMap,
                customerIntentionCycleDOMap, customerIntentionCarDOMap, customerFollowUpDOMap, AuthNHolder.userId(), AuthNHolder.userName(), batchUid);
        return BeanUtils.convert(customerImportTemporaryDOList, ImportCustomerVO.class);
    }
不二吖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
eaasyexcel批量导入+校验
12-13
EasyExcel重写了POI对07Excel的解析，解决一部分了内存消耗特大的问题03版本任依赖POI的SAX模式 EasyExcel特点 1.数据模型层面进行了封装，使用简单 2.重写了07版本的Excel解析代码，减低内存消耗，可以有效避免OOM ...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
EasyExcel 百万级别数据高效率导入/导出
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
07-25 2万+
在日常的开发中，用的比较多的方式就是 Apache 下的 POI 框架了，但在目前数据量大的时代下，这种方式显得已经不适合了编写该篇文章主要是公司中实际上用到了这种场景，将它作为文章分享出来，如果这种方式的导入/导出能帮助到大家也挺开心的，或者大家也可以发表自己在这方面的看法，提出来，做为更好的一种方式去呈现节点分以下几步走，先是介绍原始 Apache POI 以及由阿里巴巴开源的一框 POI 框架做对比，再是提出解决这方面问题上的思路，然后进行案例演示，最后记录一下在使用中遇到的错误点.
EasyExcel 批量导入并校验数据
Mr_Wanter
06-12 4133
EasyExcel 批量导入并校验数据。
EasyExcel实现导入导出
最新发布
薛三岁
05-28 1734
EasyExcel实现导入导出
EasyExcel实现百万级数据的导入导出
qq_42553489的博客
08-08 5208
EasyExcel实现百万级数据的导入导出
【EasyExcel&Hutool】excel表格的导入和导出，csv文件的导入导出
weixin_44823875的博客
09-22 5994
EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel。
教您如何三分钟搞定EasyExcel导入与导出功能
qq_35222186的博客
04-23 7067
该文章主要是介绍如何快速实现导入与导出功能以上就是使用EasyExcel时限导入与导出功能的实现步骤,鄙人才疏学浅,本文章仅供参考,有不对之处,还望各位大佬提醒与指教.
easyexcel+validation excel导入导出下载
01-19
本文将深入探讨如何结合EasyExcel和Validation实现高效且准确的Excel导入导出与数据校验。 EasyExcel的优势在于其简洁的API设计和对内存的高效利用。它无需预先加载整个Excel文件到内存，而是采用流式读写，降低了...
easyExcel实现大数据导出
11-13
例如，你可以实现批量写入，防止数据量过大导致内存溢出。 ```java public class MyBatchWriteHandler<T> implements WriteHandler { @Override public void beforeWrite(int sheetNo, int headLineNum, int ...
SpringBoot整合EasyExcel+MyBatis-Plus实现Excel批量导入和导出
05-03
本文将详细介绍如何使用SpringBoot框架结合EasyExcel和MyBatis-Plus来实现Excel的批量导入和导出，从而提高数据处理效率。 首先，SpringBoot是一个轻量级的Java开发框架，它简化了Spring应用的初始搭建以及开发过程...
easy-excel 完成Excel导入
04-01
导入数据 支持,复杂对象导航,支持自定义(单元格宽度) 标题样式(背景色,对齐方式,字体颜色) 导出测试使用时,运行org.easy.excel.test.ExportTest类的测试方法,观察具体生成的excel文件 导入测试使用时,运行org.easy.excel.test.ImportTest,观察org.easy.excel.vo.ExcelImportResult
EasyExcel的导入导出使用
weimenglala的博客
01-18 9251
EasyExcel导入导出的使用
SpringBoot+Mybatis-plus整合easyExcel批量导入Excel到数据库+导出Excel
小王博客基地
12-05 3424
今天小编带大家一起整合一下，之所以用这个，是因为性能比较好，不会报！市面上常见的导入导出Excel分为三种：和都是对的封装，使用起来更加方便！ 如果想使用和导出的可以看一下小编的之前写的文章：使用POI+hutool导入Excel 使用POI把查询到的数据表数据导出到Excel中,一个表一个sheet导出的话看一下这篇，下面主要以导入来展开介绍！ EasyExcel导出Excel表格到浏览器，并通过Postman测试导出Excel小编这里是版本的，版本不同可能导致部分有出入，如果大家版本是，可以去官方文档看
easyexcel的导入和导出
qq_44813770的博客
05-08 553
easyexcel的导入和导出的实际运用
SpringBoot中使用Easyexcel实现Excel导入导出功能（一）
热门推荐
凡夫编程
12-08 2万+
excel表格的导入与导出，可以说是业务系统里比较常见的功能了，早些时候相信很多人都是使用POI实现excel的导入与导出功能，后来出现了easyexcel，从我自己的使用感受来说，我更喜欢使用easyexcel，除了封装的比较好外，最重要的是对超级大excel导入有了更好的方案，与POI相比，速度更快，占用内存更少。
easyExcel批量导入数据
Cassiel717的博客
01-12 1234
java 使用easyExcel批量导入数据
EasyExcel批量导入excel文档
qq_45932382的博客
09-25 522
EasyExcel批量导入
一文带你彻底玩转EasyExcel：导入导出excel数据起飞
竹林幽深
04-30 698
在日常的开发工作中，Excel 文件的读取和写入是非常常见的需求，特别是在后台管理系统中更为频繁，基于传统的方式操作excel通常比较繁琐，EasyExcel 库的出现为我们带来了更简单、更高效的解决方案。本文将介绍 EasyExcel 库的基本用法和一些常见应用场景，帮助开发者更好地利用 EasyExcel 提高工作效率。官网地址：https://github.com/alibaba/easyexcel青出于蓝而胜于蓝Java解析、生成Excel比较有名的框架有Apache poi、jxl。
如何使用easyExcel实现批量导入
09-19
如果你想使用EasyExcel实现批量导入，你可以使用以下步骤： 1. 引入EasyExcel依赖：在项目的pom.xml文件中加入如下代码： ``` <groupId>com.alibaba</groupId> <artifactId>easyexcel <version>2.2.8 ``` 2. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值