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
    评论
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
eaasyexcel批量导入+校验
12-13
EasyExcel重写了POI对07Excel的解析，解决一部分了内存消耗特大的问题03版本任依赖POI的SAX模式 EasyExcel特点 1.数据模型层面进行了封装，使用简单 2.重写了07版本的Excel解析代码，减低内存消耗，可以有效避免OOM ...
EasyExcel实现批量导入数据库
程序员Forlan的博客
12-07 1480
EasyExcel实现定制化，高效读取Excel文件内容
EasyExcel批量导入数据
qq_41311379的博客
06-09 279
1、easyexcel完成大批量数据导入； 2、根据sheet页多线程解析数据；
Springboot + oracle + easyExcel 实现批量导入导出
qq_47701945的博客
03-13 990
Springboot oracle easyExcel dubbo 主键自增 批量导入导出
Java使用EasyExcel实现批量导入
qq_35771266的博客
09-25 7051
EasyExcel是阿里下的开源产品，基于poi进行的开发，相比于其他的解析方式不要太6。接下来就是使用的方式 第一步：引入jar包 <!--easyexcel解析excell--> <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexce...
JAVA实现easyExcel批量导入
m0_46300599的博客
04-26 933
注解 类型 描述 ExcelProperty 导入 指定当前字段对应excel中的那一列。可以根据名字或者Index去匹配。当然也可以不写，默认第一个字段就是index=0，以此类推。千万注意，要么全部不写，要么全部用index，要么全部用名字去匹配。千万别三个混着用，除非你非常了解源代码中三个混着用怎么去排序的。 ExcelIgnore 导入 默认所有字段都会和excel去匹配，加了这个注解会忽略该字段 DateTimeFormat 导入 日期转换，用String去接收excel日
通过easyexcel实现数据导入功能
沐雨橙风ιε的博客
11-20 1571
上一篇文章已经实现了简单的数据导出功能，这篇文章也介绍一下怎么通过从easyexcel中导入数据。首先，需要在实体类中添加需要导出的字段，@ExcelIgnore注解表示该字段不会被导出到excel，当然，导入的时候也不会读这个字段。
EasyExcel实现批量导入，校验导入模板是否匹配
MiaoJ94的博客
06-21 577
null。
SpringBoot 整合阿里EasyExcel实现表格批量导入
qxl288882的博客
05-12 1139
springBoot 整合easyExcel 实现业务逻辑
Java使用easyExcel批量导入数据
流苏打的博客
02-17 3382
WMS、ERP等管理系统经常涉及库存、人员信息的管理，通常我们会提供一个模板，此模块我们可以使用easyExcel导出数据生成的一个Excel文件当作模板，提供下载链接。用户在该文件内填入规定的数据格式以后可以批量导入数据到数据库中。 controller层： //excel批量导入用户数据 @PostMapping("/user/import") public Object addUserList(@RequestParam("file") MultipartFil
EasyExcel数据批量导入
庭前云落的博客
06-23 1437
需求：生成Excel模板，指定用户录入的数据，用户填好后，上传读取，存入数据库中。 EasyExcel官网 1. 生成Excel模板 首先是Excel的实体...
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应用的初始搭建以及开发过程...
091、Python 写Excel文件（使用openpyxl库）
不在同一频道上的呆子的博客
07-24 459
Python 写Excel文件（使用openpyxl库）
Linux Vim教程：多文件编辑与窗口管理
07-25 856
Vim作为一款功能强大的文本编辑器，支持多文件编辑和窗口管理。掌握这些高级技巧可以大大提高工作效率和文件处理能力。本文将详细介绍Vim中多文件编辑与窗口管理的各种方法和技巧，包括缓冲区、标签页、分屏、快速切换等。通过这些实用技巧，您可以更高效地在Vim中进行复杂的文本编辑任务。
EXCEL自动公式计算始终为0
最新发布
zixingcai的博客
07-25 214
此时就可以进行公式计算了。
如何使用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、付费专栏及课程。

余额充值