【SpringBoot集成EasyExcel】

于 2024-06-14 16:34:26 发布
阅读量246 收藏
点赞数 2
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36858666/article/details/139684432
版权

前言

一、什么是EasyExcel？

EasyExcel是阿里巴巴开发的一款开源Java库，专门用于处理Excel文件。与传统的POI相比，EasyExcel拥有更简洁、高效的API，使得开发者可以更轻松地实现Excel文件的读取和写入操作。无论是处理小型还是大型Excel文件，EasyExcel都能提供出色的性能和稳定性。

二、使用步骤

1.引入库

代码如下（示例）：

<!-- https://mvnrepository.com/artifact/com.alibaba/easyexcel -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>easyexcel</artifactId>
			<version>3.1.0</version>
		</dependency>

2.导入数据

代码如下（示例）：

    /**
     * 导入自然人数据
     *
     * @param files 文件
     * @return {@link JsonResponse}<{@link List}<{@link String}>>
     * @throws Exception 例外
     */
    @ApiOperation(value = "关联自然人导入", httpMethod = "POST")
    @PostMapping("/importNaturalPersonData")
    public JsonResponse<List<String>> importNaturalPersonData(@RequestParam("files") List<MultipartFile> files) throws Exception {
        JsonResponse<List<String>> response = new JsonResponse<>();
        response.setResult(relatedpartyService.importNaturalPersonData(files.get(0)));
        return response;
    }

 @Transactional
    public List<String> importNaturalPersonData(MultipartFile file) throws IOException {
        NaturalPersonListener naturalPersonListener = new NaturalPersonListener(codeMapper, relatedPartyIdentityRelationshipBizMapper, relatedPartyReportedService, naturalPersonService, relatedPartyMapper, relatedPartyRecordMapper, relatedPartyReportedBizMapper);
        EasyExcel.read(file.getInputStream(), NaturalPersonImportDto.class, naturalPersonListener).sheet().doRead();
        return naturalPersonListener.getErrorMsgList();
    }

package com.stock.mr.enterprise.components.listener;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.ListUtils;
import com.stock.core.exception.ApplicationException;
import com.stock.core.util.BeanUtil;
import com.stock.core.util.JsonUtil;
import com.stock.mr.enterprise.categoryconfig.dao.RelatedPartyIdentityRelationshipBizMapper;
import com.stock.mr.enterprise.common.constant.CodeTableConstant;
import com.stock.mr.enterprise.common.constant.LogicConstant;
import com.stock.mr.enterprise.common.dao.CodeMapper;
import com.stock.mr.enterprise.common.dao.RelatedPartyMapper;
import com.stock.mr.enterprise.common.dao.RelatedPartyRecordMapper;
import com.stock.mr.enterprise.common.entity.*;
import com.stock.mr.enterprise.components.dto.NaturalPersonImportDto;
import com.stock.mr.enterprise.insideKnowledge.dao.RelatedPartyReportedBizMapper;
import com.stock.mr.enterprise.insideKnowledge.dto.RelatedPartyDto;
import com.stock.mr.enterprise.insideKnowledge.dto.RelatedPartyIdentityRelaDto;
import com.stock.mr.enterprise.insideKnowledge.dto.RelatedPartyParamDto;
import com.stock.mr.enterprise.insideKnowledge.dto.RelatedPartyResultDto;
import com.stock.mr.enterprise.insideKnowledge.service.NaturalPersonService;
import com.stock.mr.enterprise.insideKnowledge.service.RelatedPartyReportedService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/*
 * @author: LiuKeXin
 * @description: 模板的读取类-自然人
 * @date: 2022/11/6 10:03
 */
public class NaturalPersonListener implements ReadListener<NaturalPersonImportDto> {

    private static final Logger log = LoggerFactory.getLogger(NaturalPersonListener.class);


    private List<String> errorMsgList = new ArrayList<>();

    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private CodeMapper codeMapper;

    private RelatedPartyIdentityRelationshipBizMapper relatedPartyIdentityRelationshipBizMapper;

    private RelatedPartyReportedService relatedPartyReportedService;

    private NaturalPersonService naturalPersonService;

    private RelatedPartyMapper relatedPartyMapper;

    private RelatedPartyRecordMapper relatedPartyRecordMapper;

    private RelatedPartyReportedBizMapper relatedPartyReportedBizMapper;

    /**
     * 使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param codeMapper,relatedPartyIdentityRelationshipBizMapper
     */
    public NaturalPersonListener(CodeMapper codeMapper, RelatedPartyIdentityRelationshipBizMapper relatedPartyIdentityRelationshipBizMapper, RelatedPartyReportedService relatedPartyReportedService, NaturalPersonService naturalPersonService, RelatedPartyMapper relatedPartyMapper, RelatedPartyRecordMapper relatedPartyRecordMapper, RelatedPartyReportedBizMapper relatedPartyReportedBizMapper) {
        this.codeMapper = codeMapper;
        this.relatedPartyIdentityRelationshipBizMapper = relatedPartyIdentityRelationshipBizMapper;
        this.relatedPartyReportedService = relatedPartyReportedService;
        this.naturalPersonService = naturalPersonService;
        this.relatedPartyMapper = relatedPartyMapper;
        this.relatedPartyRecordMapper = relatedPartyRecordMapper;
        this.relatedPartyReportedBizMapper = relatedPartyReportedBizMapper;
    }


    /**
     * 每隔500条存储数据库,然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 500;
    private List<RelatedParty> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);


    @Override
    public void invoke(NaturalPersonImportDto naturalPersonImportDto, AnalysisContext analysisContext) {

        if (!LogicConstant.NATRURAL_PERSON_FILE_NAME.equals(analysisContext.readSheetHolder().getSheetName())) {
            throw new ApplicationException("error.990016");
        }

        log.debug("关联自然人导入解析到一条数据:{}", JsonUtil.toJson(naturalPersonImportDto));

        if (Objects.nonNull(naturalPersonImportDto)) {
            Integer rowIndex = analysisContext.readRowHolder().getRowIndex() + 1;

            //必填和合法性校验
            RelatedPartyDto relatedPartyDto = null;
            //错误消息
            List<String> errorMsg  = new ArrayList<>();

            //2023-2-1 适用范围仅会计准则跳过校验
            if (!"会计准则".equals(naturalPersonImportDto.getApplicableGuidelines())) {
                if (StringUtils.isBlank(naturalPersonImportDto.getSerialNumber()) || !naturalPersonImportDto.getSerialNumber().contains("注")) {
                    relatedPartyDto = legalityCheck(rowIndex, naturalPersonImportDto, errorMsg);
                }
            } else {
                //会计准则名称重复跳过
                RelatedPartyExample example = new RelatedPartyExample();
                example.createCriteria().andPersonNameEqualTo(naturalPersonImportDto.getPersonName()).andStatusEqualTo(CodeTableConstant.YES);
                List<RelatedParty> relatedParties = relatedPartyMapper.selectByExample(example);
                if (CollectionUtils.isEmpty(relatedParties)) {
                    relatedPartyDto = new RelatedPartyDto();
                    relatedPartyDto.setStandardAFlag(CodeTableConstant.DATA_STATUS_0);
                    relatedPartyDto.setAccountingStandardsFlag(CodeTableConstant.DATA_STATUS_1);
                } else {
                    //103145添加错误信息
                    errorMsg.add("第" + rowIndex + "行【该对象已经审核通过，无法新增保存!】");
                    errorMsgList.addAll(errorMsg);
                }
            }

            if (errorMsg.isEmpty() && Objects.nonNull(relatedPartyDto)) {
                RelatedParty relatedParty = new RelatedParty();
                BeanUtil.copy(naturalPersonImportDto, relatedParty);

                relatedParty.setLegalPersonFlag(CodeTableConstant.PERSON_TYPE_ZERO);
                //有效
                relatedParty.setStatus(CodeTableConstant.YES);
                //审核通过
                relatedParty.setProcessStatus(CodeTableConstant.PROCESS_STATUS.approved.value());
                relatedParty.setListedFlag("1");
                //主体身份
                relatedParty.setIndentitytypeId(relatedPartyDto.getIndentitytypeId());
                //关联关系
                relatedParty.setRelationshipId(relatedPartyDto.getRelationshipId());
                //从属主体id
                relatedParty.setSubordinatePrincipalId(relatedPartyDto.getSubordinatePrincipalId());

                //证件类型
                if (!StringUtils.isEmpty(naturalPersonImportDto.getCertificateType())) {
                    relatedParty.setIdTypeCode(certificateTypeConversion(naturalPersonImportDto.getCertificateType()));
                }

                //适用准则范围
                relatedParty.setStandardAFlag(relatedPartyDto.getStandardAFlag());
                relatedParty.setStandardHFlag(relatedPartyDto.getStandardHFlag());
                relatedParty.setAccountingStandardsFlag(relatedPartyDto.getAccountingStandardsFlag());
                //是否主体(会计准则默认为主体其余根据关联关系是否本人判断是否主体)
                relatedParty.setPrincipalFlag("会计准则".equals(naturalPersonImportDto.getApplicableGuidelines()) ? CodeTableConstant.DATA_STATUS_1 : "本人".equals(naturalPersonImportDto.getRelation()) ? "1" : "0");
                saveData(relatedParty);

                //cachedDataList.add(relatedParty);
                //
                 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
                //if (cachedDataList.size() >= BATCH_COUNT) {
                //    saveData();
                //    // 存储完成清理 list
                //    cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
                //}
            }
        }
    }


    /*
     * @author: LiuKeXin
     * @description: 证件类型转换
     * @date: 2022/11/4 10:20
     */
    public String certificateTypeConversion(String certificateType) {
        CodeExample example = new CodeExample();
        example.createCriteria().andCodeNoEqualTo("CERTIFICATE").andCodeNameEqualTo(certificateType);
        List<Code> codes = codeMapper.selectByExample(example);
        if (!CollectionUtils.isEmpty(codes)) {
            return codes.get(0).getCodeValue();
        }
        return null;
    }


    private RelatedPartyDto legalityCheck(Integer rowIndex, NaturalPersonImportDto naturalPersonImportDto, List<String> errorMsg) {

        //必填校验
        if (StringUtils.isBlank(naturalPersonImportDto.getPersonName())) {
            errorMsg.add("第" + rowIndex + "行【姓名】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getCertificateType())) {
            errorMsg.add("第" + rowIndex + "行【证件类型】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getIdNo())) {
            errorMsg.add("第" + rowIndex + "行【证件号】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getSubordinateSubject())) {
            errorMsg.add("第" + rowIndex + "行【从属主体】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getSubjectIdentity())) {
            errorMsg.add("第" + rowIndex + "行【主体身份】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getRelation())) {
            errorMsg.add("第" + rowIndex + "行【关联关系】为空，请核实。");
        }
        if (StringUtils.isBlank(naturalPersonImportDto.getPublishRelatePartyName())) {
            errorMsg.add("第" + rowIndex + "行【披露关联方名称】为空，请核实。");
        }
        //适用准则范围
        if (StringUtils.isBlank(naturalPersonImportDto.getApplicableGuidelines())) {
            errorMsg.add("第" + rowIndex + "行【适用准则范围】为空，请核实。");
        }
        //if (StringUtils.isBlank(naturalPersonImportDto.getBirthday())) {
        //    errorMsg.add("第" + rowIndex + "行【出生日期】为空，请核实。");
        //}

        Map<String, Object> map = BeanUtil.map(naturalPersonImportDto, Map.class);
        RelatedPartyDto relatedPartyDto = relatedPartyIdentityRelationshipBizMapper.selectCommonRelatedParty(map);
        if (Objects.nonNull(relatedPartyDto)) {
            //非本人不允许为空
            //if (StringUtils.isBlank(relatedPartyDto.getSubordinatePrincipalId()) && !"本人".equals(naturalPersonImportDto.getRelation())) {
            //    errorMsg.add("第" + rowIndex + "行【从属主体】不合法，请核实。");
            //}
            if (StringUtils.isBlank(relatedPartyDto.getIndentitytypeId())) {
                errorMsg.add("第" + rowIndex + "行【主体身份】不合法，请核实。");
            }
            //关联关系
            if (StringUtils.isBlank(relatedPartyDto.getRelationshipId())) {
                errorMsg.add("第" + rowIndex + "行【关联关系】不合法，请核实。");
            } else {
                RelatedPartyIdentityRelaDto inputParams = new RelatedPartyIdentityRelaDto();
                inputParams.setIdentityTypeId(relatedPartyDto.getIndentitytypeId());
                inputParams.setRelatedPartyFlag(CodeTableConstant.PERSON_TYPE_ZERO);
                RelatedPartyIdentityRelaDto relatedPartyIdentityRelaDto = relatedPartyReportedService.queryRelationshipList(inputParams);
                //关联关系集合
                List<String> list = relatedPartyIdentityRelaDto.getRelatedList().stream().map(RelatedPartyIdentityRelaDto::getId).collect(Collectors.toList());
                if (!list.contains(relatedPartyDto.getRelationshipId())) {
                    //页面不可选的关联关系
                    errorMsg.add("第" + rowIndex + "行【关联关系】不在可选范围，请核实。");
                } else {
                    inputParams.setRelationshipId(relatedPartyDto.getRelationshipId());
                    List<RelatedPartyIdentityRelaDto> resultList = relatedPartyReportedBizMapper.queryRelationshipList(inputParams);
                    if (StringUtils.isNotBlank(naturalPersonImportDto.getApplicableGuidelines())) {
                        for (String relationShipId : list) {
                            String standardAFlag = resultList.get(0).getStandardAFlag();
                            String accountingStandardsFlag = resultList.get(0).getAccountingStandardsFlag();
                            if (relationShipId.equals(relatedPartyDto.getRelationshipId())) {
                                relatedPartyDto.setStandardHFlag(CodeTableConstant.DATA_STATUS_0);
                                switch (naturalPersonImportDto.getApplicableGuidelines()) {
                                    case "全部":
                                        if (CodeTableConstant.DATA_STATUS_1.equals(standardAFlag) && CodeTableConstant.DATA_STATUS_1.equals(accountingStandardsFlag)) {
                                            relatedPartyDto.setStandardAFlag(CodeTableConstant.DATA_STATUS_1);
                                            relatedPartyDto.setAccountingStandardsFlag(CodeTableConstant.DATA_STATUS_1);
                                        } else {
                                            errorMsg.add("第" + rowIndex + "行【适用准则范围】与关联方配置中的适用范围不一致");
                                        }
                                        break;
                                    case "会计准则":
                                        if (CodeTableConstant.DATA_STATUS_1.equals(accountingStandardsFlag)) {
                                            relatedPartyDto.setStandardAFlag(CodeTableConstant.DATA_STATUS_0);
                                            relatedPartyDto.setAccountingStandardsFlag(CodeTableConstant.DATA_STATUS_1);
                                        } else {
                                            errorMsg.add("第" + rowIndex + "行【适用准则范围】与关联方配置中的适用范围不一致");
                                        }
                                        break;
                                    case "A股":
                                        if (CodeTableConstant.DATA_STATUS_1.equals(standardAFlag)) {
                                            relatedPartyDto.setStandardAFlag(CodeTableConstant.DATA_STATUS_1);
                                            relatedPartyDto.setAccountingStandardsFlag(CodeTableConstant.DATA_STATUS_0);
                                        } else {
                                            errorMsg.add("第" + rowIndex + "行【适用准则范围】与关联方配置中的适用范围不一致");
                                        }
                                        break;
                                    default:
                                        relatedPartyDto.setStandardAFlag(CodeTableConstant.DATA_STATUS_0);
                                        relatedPartyDto.setAccountingStandardsFlag(CodeTableConstant.DATA_STATUS_0);
                                        break;
                                }
                                break;
                            }
                        }
                    }
                }
            }

            if (!"本人".equals(naturalPersonImportDto.getRelation())) {
                //从属主体校验
                RelatedPartyParamDto queryInfo = new RelatedPartyParamDto();
                queryInfo.setIndentitytypeId(relatedPartyDto.getIndentitytypeId());
                queryInfo.setStatus("1");
                queryInfo.setProcessStatus("3");
                queryInfo.setPrincipalFlag("1");
                List<RelatedPartyResultDto> relatedPartyResultDtos = naturalPersonService.queryNaturalPrincipal(queryInfo);
                if (CollectionUtils.isEmpty(relatedPartyResultDtos)) {
                    //页面没有可选的从属主体
                    errorMsg.add("第" + rowIndex + "行【没有可选的从属主体】");
                } else {
                    List<String> list = relatedPartyResultDtos.stream().map(RelatedPartyResultDto::getId).collect(Collectors.toList());
                    if (!list.contains(relatedPartyDto.getSubordinatePrincipalId())) {
                        errorMsg.add("第" + rowIndex + "行【从属主体】不在可选的范围");
                    }
                }
            }

            if (StringUtils.isNotBlank(naturalPersonImportDto.getIdNo()) &&
                    StringUtils.isNotBlank(naturalPersonImportDto.getCertificateType())
                    && StringUtils.isNotBlank(naturalPersonImportDto.getPersonName())
                    && StringUtils.isNotBlank(relatedPartyDto.getRelationshipId())
                    && StringUtils.isNotBlank(relatedPartyDto.getIndentitytypeId())
                    && StringUtils.isNotBlank(naturalPersonImportDto.getPersonName())) {
                RelatedPartyExample relatedPartyExample = new RelatedPartyExample();
                relatedPartyExample.createCriteria()
                        .andIndentitytypeIdEqualTo(relatedPartyDto.getIndentitytypeId())
                        .andRelationshipIdEqualTo(relatedPartyDto.getRelationshipId())
                        .andPersonNameEqualTo(naturalPersonImportDto.getPersonName())
                        .andIdTypeCodeEqualTo(certificateTypeConversion(naturalPersonImportDto.getCertificateType()))
                        .andIdNoEqualTo(naturalPersonImportDto.getIdNo())
                        .andStatusEqualTo(CodeTableConstant.YES);
                List<RelatedParty> list = relatedPartyMapper.selectByExample(relatedPartyExample);
                if (list.size() != 0) {
                    log.debug("该对象已经审核通过，无法新增保存!");
                    errorMsg.add("第" + rowIndex + "行【该对象已经审核通过，无法新增保存!】");
                } else {
                    RelatedPartyRecordExample relatedPartyRecordExample = new RelatedPartyRecordExample();
                    relatedPartyRecordExample.createCriteria()
                            .andIndentitytypeIdEqualTo(relatedPartyDto.getIndentitytypeId())
                            .andRelationshipIdEqualTo(relatedPartyDto.getRelationshipId())
                            .andPersonNameEqualTo(naturalPersonImportDto.getPersonName())
                            .andIdTypeCodeEqualTo(certificateTypeConversion(naturalPersonImportDto.getCertificateType()))
                            .andIdNoEqualTo(naturalPersonImportDto.getIdNo())
                            .andProcessStatusEqualTo(CodeTableConstant.PROCESS_STATUS.review.value())
                            .andStatusEqualTo(CodeTableConstant.YES);
                    List<RelatedPartyRecord> rprList = relatedPartyRecordMapper.selectByExample(relatedPartyRecordExample);
                    if (rprList.size() != 0) {
                        errorMsg.add("第" + rowIndex + "行【该对象有正在审核中的事项，无法编辑保存!】");
                    }
                }
            }
            errorMsgList.addAll(errorMsg);
        } else {
            errorMsgList.addAll(errorMsg);
        }
        return relatedPartyDto;
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
    }


    /**
     * 加上存储数据库
     * @return
     */
    private void saveData(RelatedParty relatedParty) {
        log.debug("开始存储数据库！{}", JsonUtil.toJson(relatedParty));
        relatedPartyMapper.insertSelective(relatedParty);
        log.debug("存储数据库成功！");
    }


    /**
     * 加上存储数据库
     */
    private void saveData() {
        log.debug("{}条数据，开始存储数据库！{}", cachedDataList.size(), JsonUtil.toJson(cachedDataList));
        if (!CollectionUtils.isEmpty(cachedDataList)) {
            relatedPartyIdentityRelationshipBizMapper.bulkInsertRelatedParty(cachedDataList);
        }
        log.info("存储数据库成功！");
    }

    public List<String> getErrorMsgList() {
        return errorMsgList;
    }
}

3.导出数据（分sheet）

  ExcelWriter excelWriter = null;

        String fileName = String.valueOf(System.currentTimeMillis()).concat("_监测数据");
        try {
            excelWriter = EasyExcel.write(ExcelUtil.getOutputStream(fileName, response)).registerWriteHandler(ExcelUtil.getHorizontalCellStyleStrategy()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
            //Map<String, Map<String, String>> key 是 flag值 value 是 chName 和 unitName
            Map<String, Object> flagMap = new HashMap<>();
            //判断开始时间和结束时间
            //如果开始时间和结束时间相差不到一个星期，直接返回数据
            //86400L=一天的秒数
            Long weekMills = 86400L*7;
            if((endTime - startTime) <= weekMills){
                historicalDataExport(deviceIds, deviceNames, startTime, endTime, response);
                return;
            }

            for (int i = 0; i < deviceIds.size(); i++) {

                String deviceId = deviceIds.get(i);
                //查询单个设备的属性快照
                ResponseBean responseBean = apiService.queryDeviceParamStatus(Long.parseLong(deviceId));
                if (StringUtils.equals(BaseCode.API_SUCCESS_CODE.code(), String.valueOf(responseBean.getCode())) && null != responseBean.getData()) {
                    getFlagMapByDevParams(responseBean, flagMap);
                }

                List<LinkedHashMap<String, Object>> maps = new ArrayList<>();
                DevParamHistoryDataEntity devParamHistoryDataEntity = new DevParamHistoryDataEntity();

                while (endTime > startTime){
                    //6.批量查询属性的历史数据接口调整

                    devParamHistoryDataEntity.setStartTime(startTime);
                    if(endTime > (startTime+weekMills)){
                        devParamHistoryDataEntity.setEndTime(startTime+weekMills);
                    }else{
                        devParamHistoryDataEntity.setEndTime(endTime);
                    }
                    devParamHistoryDataEntity.setDeviceId(Long.parseLong(deviceId));
                    ResponseBean result = apiService.queryDeviceParamHistoryData(devParamHistoryDataEntity);

                    if (StringUtils.equals(BaseCode.API_SUCCESS_CODE.code(), String.valueOf(result.getCode())) && null != result.getData()) {
                        maps.addAll((List) JSON.parseArray(result.getData().toString(), LinkedHashMap.class));
                    }
                    startTime += weekMills;
                }

                //头内容
                LinkedHashMap headMap = getHeadMap(flagMap, maps.get(0));

                // 每次都要创建writeSheet 这里注意必须指定sheetNo 而且sheetName必须不一样
                WriteSheet writeSheet = EasyExcel.writerSheet(i, deviceNames.get(i)).head(head(headMap)).build();

                //内容
                List<List<Object>> lists = dataList(maps);
                excelWriter.write(lists, writeSheet);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new InterfaceException(INTERFACE_EXCEPTION, "历史数据导出失败！");
        } finally {
            // 千万别忘记finish 会帮忙关闭流
            if (excelWriter != null) {
                excelWriter.finish();
            }
        }
码农刘刘
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVAWeb上传,下载Excel文件_easyexcel的使用3
hjl21的博客
08-10 785
看了一下demo,没什么需要再解释了.直接上个springboot的demo.先运行下载,再把下载的文件上传,试了一下.没啥问题.真心好用.给easyexcel100分.感谢阿里的各位大佬. demo下载地址:https://download.csdn.net/download/hjl21/12701838 直接用官网的demo /** * 文件下载（失败了会返回一个有部分数据的Excel） * <p>1. 创建excel对应的实体对象 参照{@link Do...
SpringBoot整合EasyExcel+MyBatis-Plus实现Excel批量导入和导出
05-03
它是一个轻量级的持久层框架，能够与SpringBoot无缝集成，使得数据库操作变得更加便捷。 EasyExcel是阿里巴巴开源的一个处理Excel的Java库，特别适合大数据量的读写操作，因为它采用了流式处理，避免了大量数据一次...
Springboot集成EasyExcel
最新发布
南秋同学的博客
05-19 554
本文主要介绍Springboot集成EasyExcel实现Excel文件导入导出。
SpringBoot中使用Easyexcel实现Excel导入导出功能（一）
热门推荐
凡夫编程
12-08 2万+
excel表格的导入与导出，可以说是业务系统里比较常见的功能了，早些时候相信很多人都是使用POI实现excel的导入与导出功能，后来出现了easyexcel，从我自己的使用感受来说，我更喜欢使用easyexcel，除了封装的比较好外，最重要的是对超级大excel导入有了更好的方案，与POI相比，速度更快，占用内存更少。
SpringBoot整合EasyExcel
2401_83412087的博客
05-07 1093
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
SpringBoot集成EasyExcel
liuerchong的博客
07-10 495
SpringBoot集成EasyExcel 文章目录SpringBoot集成EasyExcelEasyExcel简介特点：应用场景应用依赖监听类controller类 EasyExcel简介 官网地址：https://www.yuque.com/easyexcel EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel。 github地址:https://github.com/alibaba/easyexcel 特点： 1、Java领域
springboot集成easyExcel
qq_27081015的博客
08-20 761
1.excel的上传下载，我们调用普通的解析excel的jar包比较复杂而且使用非常不方便，集成easyexcel之后在 springboot中如鱼得水，开发时长大大缩短时间 集成首先导入maven包 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <versio
SpringBoot集成EasyExcel快速入门Demo
04-07
在SpringBoot项目中集成EasyExcel，首先需要添加EasyExcel的依赖到项目的pom.xml文件中。在`<dependencies>`标签内，添加以下代码： ```xml <groupId>com.alibaba</groupId> <artifactId>easyexcel 最新版本号...
springboot结合Easyexcel的使用（详细介绍Easyexcel）小白入门到精通
12-21
三、SpringBoot集成EasyExcel的步骤： 1. 创建SpringBoot项目：使用IDEA创建一个新的SpringBoot项目，配置pom.xml文件，引入EasyExcel的依赖。例如： ```xml <groupId>org.springframework.boot <artifactId>...
JAVA超级简单的excel导入导出，springboot使用easypoi
05-30
使用easypoi实现excel的导入导出，代码结合项目简单，同时对word和pdf支持，完美接入springboot项目与springmvc项目
案例实战-SpringBoot整合EasyExcel实现列表导出功能
06-03
首先，SpringBoot是基于Spring框架的快速开发工具，它简化了配置，集成了大量的常用功能，如自动配置、内嵌Web服务器等，使得开发Java Web应用变得更加便捷。在SpringBoot项目中整合EasyExcel，我们首先需要在项目的...
SpringBoot：集成EasyExcel实现EasyExcel
GIS摆渡人
08-04 8900
当使用 EasyExcel 时，实体类需要按照以下规则进行定义。实体类需要添加 @ExcelIgnoreUnannotated 注解，以确保未被 @ExcelProperty 注解标记的字段被忽略。使用 @ExcelProperty 注解标记需要在 Excel 中读写的字段，可以指定字段在 Excel 中的列索引或列名。可以使用其他注解（如 @ExcelDateTimeFormat、@ExcelNumberFormat 等）来进一步定义字段的格式化规则。
Springboot整合easyExcel
qq_37400096的博客
08-28 1557
平时工作中，我们经常都会用到excel文件上传或者下载的问题，比如将表数据导出为excel表格或者进行数据导入数据库等，本篇我们就介绍一下easyExcel进行操作Excel进行web的上传或者下载
springboot集成EasyExcel
yangjia0916的博客
06-02 449
esayexcel使用
SpringBoot项目EasyExcel使用
Oaklkm的博客
02-17 798
EasyExcel是一个基于Java的、快速、简洁、解决大文件内存溢出的Excel处理工具。他能让你在不用考虑性能、内存的等因素的情况下，快速完成Excel的读、写等功能。将表头写入excel并通过浏览器下载
springboot集成easyexcel
05-20
好的，很高兴回答您的问题。SpringBoot集成EasyExcel可以大大简化Excel文件的读写操作。您可以按照以下步骤进行集成： 1. 添加EasyExcel依赖 在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.2.6</version> </dependency> ``` 2. 添加EasyExcel配置 您可以添加以下配置来启用EasyExcel： ```java @Configuration public class EasyExcelConfig { @Bean public EasyExcelTemplate easyExcelTemplate() { // 设置读取文件的最大行数 EasyExcelTemplate easyExcelTemplate = new EasyExcelTemplate(); ReaderOption readerOption = new ReaderOption(); readerOption.setCount(10000); easyExcelTemplate.setReaderOption(readerOption); return easyExcelTemplate; } } ``` 3. 编写Excel文件读写代码 您可以按照以下代码编写读取和写入Excel文件的代码： ```java @Component public class ExcelService { @Autowired private EasyExcelTemplate easyExcelTemplate; /** * 写出数据到Excel文件 */ public void writeExcel(List<Object> data, String filePath) { ExcelWriter excelWriter = easyExcelTemplate.getWriter(filePath); WriteSheet writeSheet = EasyExcel.writerSheet(0).build(); // 设置表头和数据 excelWriter.write(data, writeSheet); // 输出文件 excelWriter.finish(); } /** * 读取Excel文件 */ public void readExcel(String filePath) { ExcelReader excelReader = easyExcelTemplate.getReader(filePath); List<Object> data = new ArrayList<>(); ReadSheet readSheet = EasyExcel.readerSheet(0).build(); excelReader.read(readSheet).forEach(object -> data.add(object)); // 输出数据 System.out.println(data); } } ``` 通过这样的方式，您就可以很方便地读写Excel文件了。希望能对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值