导入excel复杂校验加异常信息返回

最新推荐文章于 2024-07-30 17:33:09 发布
最新推荐文章于 2024-07-30 17:33:09 发布
阅读量503 收藏 1
点赞数 2
分类专栏： Java 文章标签： excel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33816292/article/details/136903478
版权

1.导出实现类

package com.dst.steed.fulfillment.modules.business.resourceplan.serviceimport;


import com.alibaba.excel.EasyExcelFactory;
import com.dst.steed.common.domain.response.Response;
import com.dst.steed.common.util.*;
import com.dst.steed.fulfillment.common.constant.DictTypeConstant;
import com.dst.steed.fulfillment.common.constant.vehicle.VehicleAttributeConstant;
import com.dst.steed.fulfillment.common.domain.acl.vehicle.attribute.AttributeValueInherit;
import com.dst.steed.fulfillment.common.domain.acl.vehicle.attribute.AttributeValueOut;
import com.dst.steed.fulfillment.common.domain.biz.resourceplan.InsertSituationRequireImportEO;
import com.dst.steed.fulfillment.common.domain.biz.resourceplan.InsertSituationRequireImportMap;
import com.dst.steed.fulfillment.common.domain.biz.resourceplan.ResourcePlanResult;
import com.dst.steed.fulfillment.common.domain.biz.resourceplan.inner.ResourceSituationInsertInnerDTO;
import com.dst.steed.fulfillment.common.enums.resourceplan.ResourceSituationSourceEnum;
import com.dst.steed.fulfillment.common.enums.resourceplan.ResourceSituationStatusEnum;
import com.dst.steed.fulfillment.common.enums.resourceplan.ResourceSituationTypeEnum;
import com.dst.steed.fulfillment.common.utils.CodeUtils;
import com.dst.steed.fulfillment.common.utils.string.StringUtil;
import com.dst.steed.fulfillment.infrastructure.acl.goods.AttributeValueServiceImpl;
import com.dst.steed.fulfillment.infrastructure.acl.goods.api.GoodsCenterServiceImpl;
import com.dst.steed.fulfillment.infrastructure.acl.operatecore.DictServiceImpl;
import com.dst.steed.fulfillment.infrastructure.acl.org.OrgServiceImpl;
import com.dst.steed.fulfillment.infrastructure.biz.resourceplan.entity.ReplaceModel;
import com.dst.steed.fulfillment.infrastructure.biz.resourceplan.entity.ResourceSituation;
import com.dst.steed.fulfillment.infrastructure.biz.resourceplan.entity.SituationRequire;
import com.dst.steed.fulfillment.infrastructure.core.resourceplan.ResourceSituationCoreService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 月资源计划-新增资源需求导入业务类
 */
@Slf4j
@Service
public class InsertSituationRequireImportService {

    @Autowired
    private ResourceSituationCoreService resourceSituationCoreService;
    @Autowired
    private AttributeValueServiceImpl attributeValueService;
    @Autowired
    private OrgServiceImpl orgService;
    @Autowired
    private DictServiceImpl dictService;
    @Autowired
    private GoodsCenterServiceImpl goodsCenterService;
    @Autowired
    private CodeUtils codeUtils;
    private final  static  String  YYYY_MM_DD = "yyyy/mm/dd";

    /**
     * 月资源计划-新增资源需求导入
     * @param file
     * @return
     */
    public Response importInsertSituationRequireTemplate(MultipartFile file,String regionCode,String beginTime,String endTime) {
        if (null == file || file.isEmpty()) {
            return Response.error("参数验证不通过");
        }
        try{
            List<InsertSituationRequireImportEO> eoList = EasyExcelFactory.read(file.getInputStream()).sheet(0).headRowNumber(2).head(InsertSituationRequireImportEO.class).doReadSync();
            if (CollectionUtils.isEmpty(eoList) || eoList.size() < 1) {
                return Response.error("导入数据为空");
            }
            if(eoList.size() > 1000) {
                return Response.error("导入的数量不能超过1000条！");
            }
            InsertSituationRequireImportMap importMap = initImportMap(eoList);
            List<ResourcePlanResult> validateResults = validateImport(eoList,regionCode,importMap);
            if(!CollectionUtils.isEmpty(validateResults)){
                return Response.succeed(validateResults);
            }
            //转换对应实体
            packResourceSituationList(eoList,importMap,beginTime,endTime);
            return Response.succeed();
        } catch (Exception e) {
            log.error("资源计划-新增资源需求导入错误", e);
        }
        return Response.error("导入失败");
    }

    private InsertSituationRequireImportMap initImportMap(List<InsertSituationRequireImportEO> eoList) {
        InsertSituationRequireImportMap importMap = new InsertSituationRequireImportMap();
        //城市名称和编码
        List<String> cityNames = eoList.stream().filter(e -> StringUtil.isNotNullorEmpty(e.getCityName())).map(InsertSituationRequireImportEO::getCityName).distinct().collect(Collectors.toList());
        Map<String, String> cityMap = orgService.getCityMap(cityNames);
        importMap.setCityMap(cityMap);
        //高中低顶要求
        Map<String, String> topRequireMap = dictService.getDictNameValueMapByType(DictTypeConstant.BUSINESS_RESOURCE_PLAN_TOP_REQUIRE);
        importMap.setTopRequireMap(topRequireMap);
        //车辆性质
        Map<String, String> carNoNatureMap = dictService.getDictNameValueMapByType(DictTypeConstant.BUSINESS_CARNO_NATURE);
        importMap.setCarNoNatureMap(carNoNatureMap);
        //是否可替换(0 否 1 是 )
        Map<String, String> canReplaceCarModelMap = new HashMap<>();
        canReplaceCarModelMap.put("否","0");
        canReplaceCarModelMap.put("是","1");
        importMap.setCanReplaceCarModelMap(canReplaceCarModelMap);
        return importMap;
    }

    private Boolean packResourceSituationList(List<InsertSituationRequireImportEO> eoList,InsertSituationRequireImportMap importMap,String beginTime,String endTime) {
        if (!CollectionUtils.isEmpty(eoList)) {
            List<SituationRequire> situationRequires = new ArrayList<>();
            List<ResourceSituation> resourceSituations = new ArrayList<>();
            for (InsertSituationRequireImportEO eo : eoList) {
                String situationResourceId = DstIdUtil.stringId();
                SituationRequire situationRequire = new SituationRequire();
                situationRequire.setId(situationResourceId);
                DstBeanUtil.copy(eo, situationRequire);
                situationRequire.setRequireSource(ResourceSituationSourceEnum.HANDLER_ADD.getSource());
                situationRequire.setReplaceModel(eo.getReplaceModel());
                if (StringUtil.isNotNullorEmpty(eo.getLastDeliverTime())) {
                    situationRequire.setLastDeliverTime(DstDateUtil.parse(eo.getLastDeliverTime(), YYYY_MM_DD));
                }
                situationRequire.setCreatorId((DstUserUtil.getUserId().isPresent()) ? String.valueOf(DstUserUtil.getUserId().get()):  String.valueOf(DstUserUtil.ADMIN_ID));
                situationRequire.setCreatorName((DstUserUtil.getRealName().isPresent()) ? DstUserUtil.getRealName().get():  DstUserUtil.ADMIN_REAL_NAME);
                situationRequires.add(situationRequire);
                // 资源情况
                ResourceSituation resourceSituation = new ResourceSituation();
                resourceSituation.setId(DstIdUtil.stringId());
                resourceSituation.setResourceSituationCode(codeUtils.generateResourceSituationCode(ResourceSituationTypeEnum.MONTH));
                resourceSituation.setSituationRequireId(situationResourceId);
                resourceSituation.setCityCode(eo.getCityCode());
                resourceSituation.setBeginTime(DstDateUtil.parse(beginTime,DstDateUtil.Y_M_D));
                resourceSituation.setEndTime(DstDateUtil.parse(endTime,DstDateUtil.Y_M_D));
                resourceSituation.setType(ResourceSituationTypeEnum.MONTH.getType());
                resourceSituation.setStatus(ResourceSituationStatusEnum.MONTH_WAIT_CITY_DECISION.getStatus());
                resourceSituation.setCreatorId((DstUserUtil.getUserId().isPresent()) ? String.valueOf(DstUserUtil.getUserId().get()): String.valueOf(DstUserUtil.ADMIN_ID));
                resourceSituation.setCreatorName((DstUserUtil.getRealName().isPresent()) ? DstUserUtil.getRealName().get():  DstUserUtil.ADMIN_REAL_NAME);
                resourceSituations.add(resourceSituation);
            }
            if (!CollectionUtils.isEmpty(situationRequires) && !CollectionUtils.isEmpty(situationRequires)) {
                resourceSituationCoreService.batchSaveSituationInsertInnerDTO(new ResourceSituationInsertInnerDTO(resourceSituations,null,situationRequires));
                return true;
            }
        }
        return false;
    }

    /**
     * 校验导入信息
     * @param eoList
     * @return
     */
    private List<ResourcePlanResult> validateImport(List<InsertSituationRequireImportEO> eoList,String regionCode,InsertSituationRequireImportMap importMap) {
        List<ResourcePlanResult> validateResults = new ArrayList<>();
        Set<String> insertSituationRequireSet = new HashSet<>();
        Map<String, List<AttributeValueOut>> valueMap = attributeValueService.getAttrValueMapByAttrKeys(VehicleAttributeConstant.exportAttrKey);
        List<AttributeValueInherit> attrValueInheritList = goodsCenterService.getAttrValueInheritList();
        List<String> cityCodesByRegionCode = orgService.getCityCodesByRegionCode(regionCode);
        for (int i = 0; i < eoList.size() ; i++) {
            StringBuffer lineError = new StringBuffer();
            int lineNum = i + 3;
            InsertSituationRequireImportEO data = eoList.get(i);
            //非空校验
            validateImportIsNull(data, lineNum, lineError);
            //字典值校验
            validateDict(data,lineNum,lineError,importMap,cityCodesByRegionCode);
            //属性值校验
            validateAttrValue(data,lineNum,lineError,valueMap,attrValueInheritList);
            //校验唯一性
            validateUnique(data,lineNum,lineError,insertSituationRequireSet);
            if(lineError.length() > 0){
                validateResults.add(new ResourcePlanResult(String.format("第%d行",lineNum),lineError.toString()));
            }
        }
        return validateResults;
    }

    /**
     * 校验唯一性
     * @param data
     * @param lineNum
     * @param lineError
     * @param insertSituationRequireSet
     */
    private void validateUnique(InsertSituationRequireImportEO data, int lineNum, StringBuffer lineError,  Set<String> insertSituationRequireSet) {
         if (insertSituationRequireSet.contains(DstJsonUtil.toString(data))) {
             lineError.append(String.format("第%d行表格中不能有完全重复的数据！",lineNum));
         }
         insertSituationRequireSet.add(DstJsonUtil.toString(data));
    }

    /**
     * 属性值校验
     * @param data
     * @param lineNum
     * @param lineError
     * @param valueMap
     */
    private void validateAttrValue(InsertSituationRequireImportEO data, int lineNum, StringBuffer lineError, Map<String, List<AttributeValueOut>> valueMap,List<AttributeValueInherit> attrValueInheritList) {
        if (StringUtil.isNotNullorEmpty(data.getCarBrandName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_G_CAR_BRAND, data.getCarBrandName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getCarBrandName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【车辆品牌】【%s】在系统中不存在的属性值！",lineNum,data.getCarBrandName()));
            } else {
                data.setCarBrand(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getCarModelName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_G_CAR_MODEL, data.getCarModelName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getCarModelName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【车辆型号】【%s】在系统中不存在的属性值！",lineNum,data.getCarModelName()));
            } else {
                data.setCarModel(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getCarBrandName()) && StringUtil.isNotNullorEmpty(data.getCarModelName())){
            if (!goodsCenterService.checkBranAndModeInherit(attrValueInheritList,data.getCarBrandName(),data.getCarModelName())) {
                lineError.append(String.format("第%d行【车辆品牌-型号】【%s】【%s】只可填写车辆品牌下的型号！",lineNum,data.getCarBrandName(),data.getCarModelName()));
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getCarModelGroupName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_A_CAR_MODEL_GROUP, data.getCarModelGroupName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getCarModelGroupName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【车辆族群】【%s】在系统中不存在的属性值！",lineNum,data.getCarModelGroupName()));
            } else {
                data.setCarModelGroup(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getEsdTotalPowerName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_A_ESD_TOTAL_POWER, data.getEsdTotalPowerName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getEsdTotalPowerName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【电池包度数】【%s】在系统中不存在的属性值！",lineNum,data.getEsdTotalPowerName()));
            } else {
                data.setEsdTotalPower(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getEsdCompanyName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_A_ESD_COMPANY, data.getEsdCompanyName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getEsdCompanyName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【电池包厂商】【%s】在系统中不存在的属性值！",lineNum,data.getEsdCompanyName()));
            } else {
                data.setEsdCompany(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getVehicleUseName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.A_OPT_VEHICLE_USE, data.getVehicleUseName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getVehicleUseName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【车辆用途】【%s】在系统中不存在的属性值！",lineNum,data.getVehicleUseName()));
            } else {
                data.setVehicleUse(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getAssetClassifyName())) {
            Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.A_OPT_ASSET_CLASSIFY, data.getAssetClassifyName());
            String valueId = attrValueMapByAttrKeyMap.get(data.getAssetClassifyName());
            if (StringUtil.isBlank(valueId)) {
                lineError.append(String.format("第%d行【资产分类】【%s】在系统中不存在的属性值！",lineNum,data.getAssetClassifyName()));
            } else {
                data.setAssetClassify(valueId);
            }
        }
        if (StringUtil.isNotNullorEmpty(data.getReplaceCarModelMame())) {
            try {
                List<ReplaceModel> replaceModels = new ArrayList<>();
                String[] brandAndMode = data.getReplaceCarModelMame().split("、");
                for (String item : brandAndMode) {
                    String[] brandAndModeSplit = item.split("/");
                    String brand = brandAndModeSplit[0];
                    String model = brandAndModeSplit[1];
                    ReplaceModel replaceModel = new ReplaceModel();
                    Map<String, String> attrBrandValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_G_CAR_BRAND, brand);
                    String valueId = attrBrandValueMapByAttrKeyMap.get(brand);
                    if (StringUtil.isBlank(valueId)) {
                        lineError.append(String.format("第%d行【替换车型-车辆品牌】【%s】在系统中不存在的属性值！", lineNum, brand));
                    } else {
                        replaceModel.setBrandId(valueId);
                        replaceModel.setBrandName(brand);
                    }
                    Map<String, String> attrValueMapByAttrKeyMap = attributeValueService.getAttrValueMapByAttrKeyMap(valueMap, VehicleAttributeConstant.AK_G_CAR_MODEL, model);
                    String modelValueId = attrValueMapByAttrKeyMap.get(model);
                    if (StringUtil.isBlank(modelValueId)) {
                        lineError.append(String.format("第%d行【替换车型-车辆型号】【%s】在系统中不存在的属性值！", lineNum, model));
                    } else {
                        replaceModel.setModelId(modelValueId);
                        replaceModel.setModelName(model);
                    }
                    if (StringUtil.isNotNullorEmpty(brand) && StringUtil.isNotNullorEmpty(model)){
                        if (!goodsCenterService.checkBranAndModeInherit(attrValueInheritList,brand,model)) {
                            lineError.append(String.format("第%d行【替换车型-车辆品牌-型号】【%s】【%s】只可填写车辆品牌下的型号！",lineNum,brand,model));
                        }
                    }
                    replaceModels.add(replaceModel);
                }
                data.setReplaceModel(replaceModels);
            } catch (Exception e) {
                log.error(String.format("替换车型%s输入有误",data.getReplaceCarModelMame()));
                lineError.append(String.format("第%d行【替换车型】【%s】输入有误,请检查！", lineNum, data.getReplaceCarModelMame()));
            }
        }
    }

    private void validateImportIsNull(InsertSituationRequireImportEO data, int lineNum, StringBuffer lineError) {
        if (StringUtil.isBlank(data.getCityName())) {
            lineError.append(String.format("第%d行【城市】为空！",lineNum));
        }
        if(StringUtils.isBlank(data.getCarBrandName())) {
            lineError.append(String.format("第%d行【车辆品牌】为空！",lineNum));
        }
        if(StringUtils.isBlank(data.getCarModelName())) {
            lineError.append(String.format("第%d行【车辆型号】为空！",lineNum));
        }
        if(StringUtils.isBlank(data.getCarModelGroupName())) {
            lineError.append(String.format("第%d行【车辆族群】为空！",lineNum));
        }
        if(StringUtils.isBlank(data.getCanReplaceCarModelMame())) {
            lineError.append(String.format("第%d行【是否可替换车型】为空！",lineNum));
        }else if (data.getCanReplaceCarModelMame().equals("是")) {
            if (StringUtil.isBlank(data.getReplaceCarModelMame())) {
                lineError.append(String.format("第%d行【可替换车型】是否可替换车型为是则为必填！",lineNum));
            }
        }
        if(StringUtils.isBlank(data.getCarNoNatureName())) {
            lineError.append(String.format("第%d行【车牌性质】为空！",lineNum));
        }
        if (!StringUtil.isBlank(data.getLastDeliverTime())) {
            try {
                DstDateUtil.parse(data.getLastDeliverTime(), YYYY_MM_DD);
            } catch (Exception e) {
                log.error("时间格式解析异常:{}",e.getMessage());
                lineError.append(String.format("第%d行【最后交付时间】请输入yyyy/mm/dd格式",lineNum));
            }
        }
        if(Objects.isNull(data.getRequireVehicleCount())) {
            lineError.append(String.format("第%d行【需求数量】为空！",lineNum));
        } else if (data.getRequireVehicleCount() <=0 ){
            lineError.append(String.format("第%d行【需求数量】只可填写大于0的整数，最大可输入99999！",lineNum));
        }
        if (!StringUtil.isBlank(data.getNeedColor())) {
            if (data.getNeedColor().length() > 50) {
                lineError.append(String.format("第%d行【车身颜色】最多可填写50字符！", lineNum));
            }
        }
        if (!StringUtil.isBlank(data.getTransformRequire())) {
            if (data.getTransformRequire().length() > 50) {
                lineError.append(String.format("第%d行【技改要求】最多可填写50字符！", lineNum));
            }
        }
    }

    private void validateDict(InsertSituationRequireImportEO data, int lineNum, StringBuffer lineError,InsertSituationRequireImportMap importMap,List<String> cityCodesByRegionCode) {
        if (!importMap.getCityMap().containsKey(data.getCityName())) {
            lineError.append(String.format("第%d行 城市:【%s】输入有误,在系统不存在，请检查！", lineNum, data.getCityName()));
        } else {
            data.setCityCode(importMap.getCityMap().get(data.getCityName()));
        }
        if (!cityCodesByRegionCode.contains(data.getCityCode())) {
            lineError.append(String.format("第%d行【%s】只可填写当前大区下的城市！",lineNum,data.getCityName()));
        }
        if (StringUtil.isNotNullorEmpty(data.getTopRequireName())) {
            if (!importMap.getTopRequireMap().containsKey(data.getTopRequireName())) {
                lineError.append(String.format("第%d行 高中低顶要求:【%s】输入有误！", lineNum, data.getTopRequireName()));
            } else {
                data.setTopRequire(Integer.valueOf(importMap.getTopRequireMap().get(data.getTopRequireName())));
            }
        }
        if (!importMap.getCarNoNatureMap().containsKey(data.getCarNoNatureName())) {
            lineError.append(String.format("第%d行 车牌性质:【%s】输入有误！", lineNum, data.getCarNoNatureName()));
        } else {
            data.setCarNoNature(Integer.valueOf(importMap.getCarNoNatureMap().get(data.getCarNoNatureName())));
        }
        if (!importMap.getCanReplaceCarModelMap().containsKey(data.getCanReplaceCarModelMame())) {
            lineError.append(String.format("第%d行 是否可替换车型:【%s】输入有误！", lineNum, data.getCanReplaceCarModelMame()));
        } else {
            data.setCanReplaceCarModel(importMap.getCanReplaceCarModelMap().get(data.getCanReplaceCarModelMame()));
        }
    }



}

2.导出异常信息类

package com.dst.steed.fulfillment.common.domain.biz.resourceplan;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
*@ClassName ResourcePlanResult
*@Description 资源计划导入结果类
*@Author lwp
*@Date 2024/3/6 14:09
*/
@Getter
@Setter
@ToString
@NoArgsConstructor
public class ResourcePlanResult {

	/** 资源情况编码**/
	private String index;

	/** 错误信息**/
	private String message;

	public ResourcePlanResult(String index, String message) {
		this.index = index;
		this.message = message;
	}



}

3.字段组装map类

package com.dst.steed.fulfillment.common.domain.biz.resourceplan;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

import java.util.Map;

/**
 * @Description: 月资源计划-新增资源需求导入常量透传类
 * @author lwp
 * @date 2024/3/7 18:06
 */
@Getter
@Setter
@ToString
@NoArgsConstructor
public class InsertSituationRequireImportMap {

	/** 高低顶要求(dst_base.marketing_interior_height)**/
	private Map<String, String> topRequireMap;

	/** 车辆性质(dst_base.business_carno_nature)**/
	private Map<String, String>  carNoNatureMap;

	/** 是否可替换(0 否 1 是 )**/
	private Map<String, String>  canReplaceCarModelMap;
	/** 城市名称和编码 **/
	private Map<String, String>  cityMap;


}

4.导入类

package com.dst.steed.fulfillment.common.domain.biz.resourceplan;


import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
import com.dst.steed.common.convert.translation.Translation;
import com.dst.steed.fulfillment.common.constant.DictTypeConstant;
import com.dst.steed.fulfillment.infrastructure.biz.resourceplan.entity.ReplaceModel;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

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

/**
 * 月资源计划-新增资源需求导入类
 */
@Data
public class InsertSituationRequireImportEO implements Serializable {

    /**
     * 资源情况编码
     */
    @ExcelProperty(index = 0)
    private  String  cityName;
    private  String  cityCode;

    /**
     * 车辆品牌
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-carBrandName")
    private String carBrand;
    @ExcelProperty(index = 1)
    private String carBrandName;

    /**
     * 车辆型号
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-carModelName")
    private String carModel;
    @ExcelProperty(index = 2)
    private String carModelName;

    /**
     * 车型族群
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-carModelGroupName")
    private String carModelGroup;
    @ExcelProperty(index = 3)
    private String carModelGroupName;

    /**
     * 动力电池包电量
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-carModelGroupName")
    private String esdTotalPower;
    @ExcelProperty(index = 4)
    private String esdTotalPowerName;

    /**
     * 电池包厂商
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-esdCompanyName")
    private String esdCompany;
    @ExcelProperty(index = 5)
    private String esdCompanyName;

    /**
     * 车辆用途
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-vehicleUseName")
    private String vehicleUse;
    @ExcelProperty(index = 6)
    private String vehicleUseName;

    /**
     * 资产分类
     */
    @Translation(convertName = "commonConvertAttrValueIdMapValue",convertTo = "attrValueName-assetClassifyName")
    private String assetClassify;
    @ExcelProperty(index = 7)
    private String assetClassifyName;

    /**
     * 高中低顶要求(字典：marketing_interior_height)
     */
    @Translation(dictType = DictTypeConstant.BUSINESS_RESOURCE_PLAN_TOP_REQUIRE)
    private Integer topRequire;
    @ExcelProperty(index = 8)
    private String topRequireName;
    /**
     * 车身颜色要求
     */
    @ExcelProperty(index = 9)
    private String needColor;
    /**
     * 技改要求
     */
    @ExcelProperty(index = 10)
    private String transformRequire;
    /**
     * 是否可替换车型，0.不可替换 1.可替换
     */
    @ExcelProperty(index = 11)
    private String canReplaceCarModelMame;
    private String canReplaceCarModel;


    /**
     * 替换车型
     */
    @ExcelProperty(index = 12)
    private String replaceCarModelMame;

    /**
     * 车牌性质(字典：business_carno_nature)
     */
    @Translation(dictType = DictTypeConstant.BUSINESS_CARNO_NATURE)
    private Integer carNoNature;
    @ExcelProperty(index = 13)
    private String carNoNatureName;

    /**
     * 最后交付时间
     */
    @JsonFormat(pattern = "yyyy/MM/dd", timezone = "GMT+8")
    @ExcelProperty(index = 14)
    private String lastDeliverTime;

    /**
     * 需求数量
     */
    @ExcelProperty(index = 15)
    private Integer requireVehicleCount;

    /**
     * 可替换车型(jons数组字符串)
     */
    @TableField(value = "replace_model", typeHandler = JacksonTypeHandler.class)
    private List<ReplaceModel> replaceModel;
}

5.前端请求接口控制层

/**
     * 月资源计划-新增资源需求导入
     * @author: lwp
     * @date: 2024/03/04 13:50
     **/
    @PostMapping(value = "/importInsertSituationRequireTemplate")
    public Response importInsertSituationRequireTemplate(@RequestParam(value = "file",required = true) MultipartFile file,
                                                         @RequestParam(value = "regionCode", required = true) String regionCode,
                                                         @RequestParam(value = "beginTime", required = true) String beginTime,
                                                         @RequestParam(value = "endTime", required = true) String endTime) {
        return situationRequireService.importInsertSituationRequireTemplate(file,regionCode,beginTime,endTime);

6.总结

这种写法主要是代码结构清晰，再复杂的校验只要往其中填充即可

孰能生巧-LWP
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里-EasyExcel导入校验
兴趣是最好的老师
06-23 1423
可以看出只需要在实体对象使用@ExcelProperty注解，读取时指定该class，即可读取，并且自动。过滤了空行，对于excel的读取及其简单。不过此时发现一个问题，这样我如果要校验字段该怎么。不必担心，我们可以想到的问题，作者肯定也考虑到了，下面来一个Demo。要将字段类型转换成另外一个类型呢？
EasyExcel实现导入并校验
王华春_Jason
12-07 1万+
总结公司业务中需要用户导入Excel数据，并且每次几万条，要求速度快，用户操作方便灵活，有些非必填字段的数据可以为空。当然目前有很多成熟的框架都可以实现该功能，在这里就不详细的描述我们是如何选择这些框架的过程，我们选择的是阿里的easyExcel框架，号称操作简单、省内存、性能稳定等。导入功能本身并没什么复杂的，这里主要想分享下我在
通过easyexcel导入数据，添加表格参数的校验，同表格内校验以及和已有数据的校验
myStyle的博客
07-03 812
导入的表格要个浏览器对应上。
EasyExcel实现导入+各种数据校验
qq_43759721的博客
03-02 1万+
1.导入非xls和xlsx格式的文件 2.导入空数据的excel文件 3.数据缺失 4.导入的excel文件中有重复的数据 5.导入的excel文件数据错误 6.导入的模板不是正确模板
EasyExcel导入导出excel 复杂表头 表头校验 数据校验
热门推荐
ZHANGLIZENG的博客
05-19 1万+
EasyExcel特点 Java领域解析，生成Excel比较有名的框架有Apache poi,jxl等，但他们都存在一个严重的问题就是非常的耗内存，如果你的系统并发量不大的话可能还行，但是一旦并发上来后一定会OOM或者JVM频繁的full gc. EasyExcel是阿里巴巴开源的一个excel处理框架，以使用简单，节省内存著称，EasyExcel能大大减少占用内存的主要原因是在解析Excel时没有将文件数据一次性全部加载到内存中，而是从磁盘上一行行读取数据，逐个解析。 EasyExcel采用一行一行
EasyExcel 批量导入并校验数据
Mr_Wanter
06-12 4243
EasyExcel 批量导入并校验数据。
EasyExcel导入数据校验
如无必要勿增实体
12-30 1198
【代码】EasyExcel导入数据校验。
POI导入Excel并返回校验后的错误文件（原样）下载以及校验错误信息，同时加进度条
01-22
POI导入Excel并返回校验后的错误文件（原样数据文件，并添加批注，注：由于批注只能加1000条，会在Excel后面添加一栏错误信息）下载以及页面展示校验错误信息，同时添加导入进度条，提供页面js和css代码，后端...
我的导入校验项目excel导入校验
08-31
"我的导入校验项目excel导入校验"这个标题揭示了一个专注于使用Excel文件进行数据导入，并对数据进行复杂校验的项目。在这个过程中，用户或系统会将Excel表格中的数据提取出来，经过一系列验证规则的检查，然后将...
excel导入动态校验，自定义注解动态校验
06-09
总之，"Excel导入动态校验，自定义注解动态校验"是一种高效且灵活的数据验证方法，它使得在导入大量Excel数据时能确保数据质量，防止潜在的错误和异常，从而提升系统的稳定性和数据的准确性。通过深入理解并实践这一...
excel导入动态校验
07-18
excel导入动态校验
eaasyexcel批量导入+校验
12-13
EasyExcel重写了POI对07Excel的解析，解决一部分了内存消耗特大的问题03版本任依赖POI的SAX模式 EasyExcel特点 1.数据模型层面进行了封装，使用简单 2.重写了07版本的Excel解析代码，减低内存消耗，可以有效避免OOM 3.只能操作Excel 4.不能读取图片 5.读写Excel，数据在excel文件，程序两个载体之间 互相流转
excel通过配置实现导入导出和校验
02-02
本主题聚焦于如何通过配置实现Excel的导入、导出及校验功能，这在许多业务系统中是非常常见的需求。这样的方法可以极大地提高开发效率，避免重复编写相同的代码逻辑，并确保数据的一致性和准确性。 首先，我们需要...
EasyExcel导入Excel文件，并对文件内容作校验
帅帅的困哒哒
03-23 4074
其中value中的值跟Excel中的表头名称对应，index与excel中的表头位置对应。重点在这个监听类中，我们如果需要校验数据，则在invoke方法中作数据校验。首页是pom文件导入EasyExcel的依赖。postman测试，选择文件。@Slf4j的依赖可自行百度导入。mysql中添加三个字段做测试。controller中。
easyExcel实现导入，关于每行数据的处理异常信息返回到前端
旋转丶木马的博客
05-24 5542
文章目录前言一、EasyExcel二、背景及解决主要问题导入excel校验返回文件导出总结 前言 JAVA解析Excel工具EasyExcel的初次使用 easyExcel git地址：https://github.com/alibaba/easyexcel 一、EasyExcel Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Exc
基于EasyExcel的读取exl并返回成功/失败数量及原因,并将导入失败exl的导出到系统路径中
qq_37361535的博客
04-22 1万+
首先,这个是读取和导出exl都需要用到的实体类的基类,这个是可以扩展的,读取失败的exl想要加入其它列的字段都可以加在这里 pom <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> ...
基于EasyExcel实现导入数据校验,生成错误信息Excel
最新发布
u014135956的博客
07-30 655
导入的第一步就是处理字段类型错误，因为如果出现类型转换错误，会直接导致程序异常，这里通过try,catch捕获ExcelAnalysisException异常来获取出现错误的列和行。基于EasyExcel封装，由于项目中本身使用的EasyExcel，考虑到不改动项目的技术组成，还是基于EasyExcel开发。EasyExcel做的工作其实很简单，就是把文件中的内容映射到我们实体类的字段上，我们要做的就是在映射前和映射后做校验。而我们需要将数据的错误内容提交给用户，所以如下的报错是不可取的。
EasyExcel导入前验证数据后再选择覆盖导入或新增导入
Hkemp的博客
07-24 457
导入前验证数据，之后选择覆盖导入或新增导入
EasyExcel使用Validator进行读取校验,批量处理数据,返回处理异常的行以及列
Memory_loss的博客
03-12 1764
使用EasyExcel读取Excel文件.使用Validator进行数据校验,并批量处理数据,以及返回处理错误行数
Java导入 excel 返回错误信息excel
10-06
要实现Java导入Excel并返回错误信息的功能，可以使用POI库进行操作。以下是一种可能的实现方式： 1. 首先，导入POI库，以便在Java代码中进行Excel文件的读取和写入操作。 2. 使用POI库提供的API，打开要导入的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值