代码更新：

1. 修复叫料bug。

src/main/java/com/wms/controller/ExcelController.java

@@ -65,6 +65,7 @@ public class ExcelController {
     private final WorkStationConfigService workStationConfigService;// 工站配置服务
     private final WorkSummaryService workSummaryService;// 工作分析服务
     private final KanbanService kanbanService;// 看板服务
+    private final WorkFlowService workFlowService;// 工作流服务
 
     private final List<String> uploadFileHashStringList = new ArrayList<>();
 
@@ -224,6 +225,63 @@ public class ExcelController {
         }
     }
 
+    /**
+     * 导入工作流
+     *
+     * @param file 文件
+     * @return 导入结果
+     */
+    @PostMapping("/uploadWorkFlow")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    public String uploadWorkFlow(@RequestPart("file") MultipartFile file, @RequestPart("obj") FileVo fileVo) {
+        logger.info("导入工作流，请求ip：{}，文件详情：{}", getIpAddr(servletRequest), convertJsonString(fileVo));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            // 判断是否重复导入
+            if (uploadFileHashStringList.contains(fileVo.getHash())) {
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("请勿导入相同文件。");
+                return convertJsonString(response);
+            }
+            uploadFileHashStringList.add(fileVo.getHash());
+            // 获取之前工单表的内容
+            List<WorkFlow> workFlows = workFlowService.list();
+            Map<String, WorkFlow> oldWorkFlowMap = workFlows.stream().collect(Collectors.toMap(workFlow -> workFlow.getWorkOrder() + workFlow.getGoodsId() + workFlow.getWorkCenter(), workFlow -> workFlow));
+            // 已经有任务的工作流
+            List<String> workStationList = workFlows.stream().map(WorkFlow::getWorkStation).distinct().toList();
+            // 导入excel
+            EasyExcel.read(file.getInputStream(), KateWorkFlowExcelVo.class, new UploadWorkFlowListener(workFlowService, oldWorkFlowMap, workStationList)).sheet().doRead();
+            // 添加导入记录
+            uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "WORKFLOW"));
+            uploadFileHashStringList.remove(fileVo.getHash());
+            response.setCode(ResponseCode.OK.getCode());
+            // 设置返回信息
+            StringBuilder message = new StringBuilder();
+            if (!workStationList.isEmpty()) {
+                message.append("以下工作站已有任务，不执行导入：");
+                for (String workStation : workStationList) {
+                    message.append(workStation).append("、");
+                }
+                message = new StringBuilder(message.substring(0, message.length() - 1));
+            }
+            if (StringUtils.isEmpty(message.toString())) {
+                response.setMessage("导入工作流成功。");
+            } else {
+                response.setMessage(message.toString());
+            }
+            return convertJsonString(response);
+        } catch (Exception e) {
+            logger.error("导入工作流异常：{}", convertJsonString(e));
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            uploadFileHashStringList.remove(fileVo.getHash());
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("导入工作流异常。");
+            return convertJsonString(response);
+        }
+    }
+
     /**
      * 导入物料
      *

src/main/java/com/wms/controller/TaskController.java

@@ -1405,12 +1405,12 @@ public class TaskController {
                 response.setCode(ResponseCode.OK.getCode());
                 response.setMessage("确认成功，放行");
             } else {
-                // 处理库存偏差
-                if (workConfirmRequest.getRemainNumReal().compareTo(workConfirmRequest.getRemainNumOrigin()) != 0) {
                 Stock existStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
                         .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, workConfirmRequest.getGoodsId())
                         .eq(Stock::getVehicleId, pickTask.getVehicleId())
                         .last("limit 1"));// 更新库存数量
+                // 处理库存偏差
+                if (workConfirmRequest.getRemainNumReal().compareTo(workConfirmRequest.getRemainNumOrigin()) != 0) {
                     if (existStock != null && existStock.getGoodsRelated() != null) {
                         Stock originStock = BeanUtil.copyProperties(existStock, Stock.class);
                         BigDecimal quantityBefore = originStock.getGoodsRelated().getRemainNum();
@@ -1429,6 +1429,42 @@ public class TaskController {
                         if (currentGoodsVehicle != null) {
                             currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
                             outsideVehiclesService.updateById(currentGoodsVehicle);
+                            // 已经分配的数量
+                            BigDecimal distributedNum = workConfirmRequest.getRemainNumOrigin().subtract(workConfirmRequest.getRemainNumReal());
+                            // 将当前物料的所有goodsToStation
+                            List<GoodsToStation> goodsToStations = goodsToStationService.list(new LambdaQueryWrapper<GoodsToStation>()
+                                    .eq(GoodsToStation::getGoodsId, currentGoodsVehicle.getGoodsId()));
+                            List<GoodsToStation> updatedGoodsToStationList = new ArrayList<>();
+                            for (GoodsToStation goodsToStation : goodsToStations) {
+                                if (distributedNum.compareTo(BigDecimal.ZERO) > 0) {
+                                    // 查询这个料对应的当前站台未完成工作流
+                                    List<WorkFlow> workFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                                            .eq(WorkFlow::getWorkStation, goodsToStation.getWorkStation())
+                                            .eq(WorkFlow::getGoodsId, goodsToStation.getGoodsId())
+                                            .eq(WorkFlow::getWorkStatus, 1));
+                                    BigDecimal recallNum = BigDecimal.ZERO;
+                                    for (WorkFlow workFlow : workFlows) {
+                                        // 分配数量无了
+                                        if (distributedNum.compareTo(BigDecimal.ZERO) <= 0) {
+                                            break;
+                                        }
+                                        BigDecimal needNum = workFlow.getNeedNum().subtract(workFlow.getPickedNum());
+                                        if (needNum.compareTo(BigDecimal.ZERO) > 0) {
+                                            recallNum = recallNum.add(needNum);
+                                            distributedNum = distributedNum.subtract(needNum);
+                                        }
+                                    }
+                                    if (recallNum.compareTo(BigDecimal.ZERO) >0) {
+                                        goodsToStation.setDistributedNum(goodsToStation.getDistributedNum().subtract(recallNum));
+                                        goodsToStation.setDistributeStatus(1);
+                                        updatedGoodsToStationList.add(goodsToStation);
+                                    }
+                                }
+                            }
+                            // 更新站台要料表
+                            if (!updatedGoodsToStationList.isEmpty()) {
+                                goodsToStationService.updateBatchById(updatedGoodsToStationList);
+                            }
                         }
                     } else {
                         // 更新流转载具表剩余数量
@@ -1437,6 +1473,24 @@ public class TaskController {
                             outsideVehiclesService.updateById(currentGoodsVehicle);
                         }
                     }
+                } else {
+                    if (existStock != null && existStock.getGoodsRelated() != null) {
+                        if (workConfirmRequest.getRemainNumOrigin().compareTo(BigDecimal.ZERO) == 0) {
+                            Stock originStock = BeanUtil.copyProperties(existStock, Stock.class);
+                            BigDecimal quantityBefore = originStock.getGoodsRelated().getRemainNum();
+                            StockDetailInfo goodsDetail = existStock.getGoodsRelated();
+                            goodsDetail.setRemainNum(BigDecimal.ZERO);
+                            existStock.setGoodsRelated(goodsDetail);
+                            stockService.updateById(existStock);
+                            stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore);
+                            OutsideVehicles currentGoodsVehicle = outsideVehiclesService.getOne(new LambdaQueryWrapper<OutsideVehicles>()
+                                    .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
+                                    .eq(OutsideVehicles::getGoodsId, workConfirmRequest.getGoodsId())
+                                    .last("limit 1"));
+                            currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
+                            outsideVehiclesService.updateById(currentGoodsVehicle);
+                        }
+                    }
                 }
                 // 查询当前载具上的流转中的物料
                 List<OutsideVehicles> outsideVehicles = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()

src/main/java/com/wms/service/business/serviceImplements/WmsTaskServiceImplements.java

@@ -24,9 +24,8 @@ import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
+import java.util.stream.Collectors;
-import java.util.Objects;
 
 import static com.wms.constants.WmsConstants.MYSQL_JSON_CI;
 import static com.wms.utils.StringUtils.convertJsonString;
@@ -500,18 +499,29 @@ public class WmsTaskServiceImplements implements IWmsTaskService {
         if (!Objects.equals(pickStatus, PickTaskStatusEnum.TEMP.getCode()) && !Objects.equals(pickStatus, PickTaskStatusEnum.NEW.getCode())) {
             return;
         }
-        // 这里查询所有暂存的任务
+        // 这里查询所有拣选任务
-        List<PickTask> tempPickTasks = pickTaskService.list(new LambdaQueryWrapper<PickTask>()
+        List<PickTask> allPickTasks = pickTaskService.list();
-                .eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode()));
+        // 所有的暂存箱子
-        List<String> tempPickVehicles = tempPickTasks.stream().map(PickTask::getVehicleId).distinct().toList();
+        List<String> tempPickVehicles = allPickTasks.stream().filter(pickTask -> Objects.equals(pickTask.getPickStatus(), PickTaskStatusEnum.TEMP.getCode())).map(PickTask::getVehicleId).distinct().toList();
+        // 之前下发过的当前站台的任务
+        Map<String, PickTask> currentStandPickTasksMap = allPickTasks.stream().filter(pickTask -> pickTask.getStandId().equals(workStation)).collect(Collectors.toMap(pickTask -> pickTask.getVehicleId() + "_" + pickTask.getStandId(), pickTask -> pickTask));
         // 拣选任务暂存列表
-        List<PickTask> pickTasks = new ArrayList<>();
+        Map<String, PickTask> pickTaskMap = new HashMap<>();
         // 增加的拣选任务数量
         int addNum = 0;
         for (String vehicleId : vehicleIds) {
+            String key = vehicleId + "_" + workStation;
+            // 之前已经下发过同一箱子同一站台的任务，不再下发
+            if (currentStandPickTasksMap.containsKey(key)) {
+                continue;
+            }
+            // 此次新建的保存过
+            if (pickTaskMap.containsKey(key)) {
+                continue;
+            }
             // 暂存拣选任务
             PickTask tempPickTask = new PickTask();
-            tempPickTask.setPickTaskId(generateId("PICK_"));
+            tempPickTask.setPickTaskId(key);
             tempPickTask.setVehicleId(vehicleId);
             tempPickTask.setStandId(workStation);
             if (tempPickVehicles.contains(vehicleId)) {
@@ -520,16 +530,18 @@ public class WmsTaskServiceImplements implements IWmsTaskService {
                 tempPickTask.setPickStatus(pickStatus);
             }
             tempPickTask.setLastUpdateTime(LocalDateTime.now());
-            pickTasks.add(tempPickTask);
+            pickTaskMap.put(key, tempPickTask);
             if (!Objects.equals(tempPickTask.getPickStatus(), PickTaskStatusEnum.TEMP.getCode())) {
                 addNum++;
             }
         }
         // 添加数据库
-        pickTaskService.saveBatch(pickTasks);
+        if (!pickTaskMap.isEmpty()) {
+            pickTaskService.saveOrUpdateBatch(pickTaskMap.values());
             // 更新站台的拣选数量
             standService.update(new LambdaUpdateWrapper<Stand>()
                     .setSql("pick_vehicle_count = pick_vehicle_count + " + addNum)
                     .eq(Stand::getStandId, workStation));
         }
+    }
 }

src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java

@@ -23,6 +23,7 @@ import org.springframework.transaction.interceptor.TransactionAspectSupport;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static com.wms.config.InitLocalConfig.configMap;
 import static com.wms.constants.WmsConstants.MYSQL_JSON_CI;
@@ -51,6 +52,131 @@ public class WorkServiceImplements implements IWorkService {
     private final List<String> workDoingStations = new ArrayList<>();// 当前正在执行任务的站台
     private final List<String> workFinishingStations = new ArrayList<>();// 当前正在完成任务的站台
 
+//    @Override
+//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+//    public void createWork(String workStation) throws Exception {
+//        if (workCreatingStations.contains(workStation)) {
+//            // 当前站台正在创建任务
+//            return;
+//        } else {
+//            // 添加站台
+//            workCreatingStations.add(workStation);
+//        }
+//        if (StringUtils.isEmpty(workStation)) {
+//            // 站台号为空
+//            return;
+//        }
+//        try {
+//            // 先查看当前站台已经生成的工作流是否为空
+//            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+//                    .eq(WorkFlow::getWorkStation, workStation));
+//            // 当前站台的工作流中还存在其他任务
+//            if (currentWorkFlowList != null && !currentWorkFlowList.isEmpty()) {
+//                return;
+//            }
+//            // 当前站台分配的工位
+//            List<WorkFlow> currentStationWorkFlows = new ArrayList<>();
+//            // 先找MWL机型
+//            findWorks(workStation, currentStationWorkFlows, "MWL");
+//            if (currentStationWorkFlows.isEmpty()) {
+//                // 找非MWL机型
+//                findWorks(workStation, currentStationWorkFlows, "NOT_MWL");
+//            }
+//            // 如果当前站台有任务
+//            if (!currentStationWorkFlows.isEmpty()) {
+//                // 将工作流列表添加进数据库
+//                workFlowService.saveBatch(currentStationWorkFlows);
+//                // 获得工单列表
+//                List<String> workOrderList = new ArrayList<>();
+//                // 获得工单以及小工位列表
+//                List<String> boxNoList = new ArrayList<>();
+//                // 要料Map
+//                Map<String, BigDecimal> needGoodsMap = new HashMap<>();
+//                for (WorkFlow tempWorkflow : currentStationWorkFlows) {
+//                    // 添加工单
+//                    if (!workOrderList.contains(tempWorkflow.getWorkOrder())) {
+//                        workOrderList.add(tempWorkflow.getWorkOrder());
+//                    }
+//                    // 添加盒子配置
+//                    String boxNo = tempWorkflow.getWorkOrder() + "@" + tempWorkflow.getWorkCenter();
+//                    if (!boxNoList.contains(boxNo)) {
+//                        boxNoList.add(boxNo);
+//                    }
+//                    // 添加要料信息
+//                    if (!needGoodsMap.containsKey(tempWorkflow.getGoodsId())) {
+//                        // 添加物料信息
+//                        needGoodsMap.put(tempWorkflow.getGoodsId(), tempWorkflow.getNeedNum());
+//                    } else {
+//                        // 增加需求数量
+//                        needGoodsMap.replace(tempWorkflow.getGoodsId(), needGoodsMap.get(tempWorkflow.getGoodsId()).add(tempWorkflow.getNeedNum()));
+//                    }
+//                }
+//                // 站台要料
+//                List<GoodsToStation> goodsToStationList = new ArrayList<>();
+//                for (String goodsId : needGoodsMap.keySet()) {
+//                    GoodsToStation goodsToStation = new GoodsToStation();
+//                    goodsToStation.setGoodsId(goodsId);
+//                    goodsToStation.setWorkStation(workStation);
+//                    goodsToStation.setDistributeStatus(0);
+//                    goodsToStation.setDistributedNum(BigDecimal.ZERO);
+//                    goodsToStation.setTotalNum(needGoodsMap.get(goodsId));
+//                    goodsToStationList.add(goodsToStation);
+//                }
+//                // 将站台要料列表存进数据库
+//                goodsToStationService.saveBatch(goodsToStationList);
+//                // 更新工单表
+//                List<String> orderIds = currentStationWorkFlows.stream().map(WorkFlow::getOrderId).distinct().toList();
+//                if (!orderIds.isEmpty()) {
+//                    kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+//                            .set(KateOrders::getOrderStatus, 1)
+//                            .in(KateOrders::getOrderId, orderIds)
+//                            .eq(KateOrders::getOrderStatus, 0));
+//                }
+//                // 更新dbs表
+//                if (!workOrderList.isEmpty()) {
+//                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
+//                            .set(KateDBS::getDbsStatus, 1)
+//                            .in(KateDBS::getWorkOrder, workOrderList)
+//                            .eq(KateDBS::getDbsStatus, 0));
+//                }
+//                // 电子标签库位配置
+//                List<ELocationConfig> eLocationConfigList = new ArrayList<>();
+//                // 查找到当前站台所有可用的电子标签
+//                List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
+//                        .eq(ETagLocation::getWorkStation, workStation)
+//                        .eq(ETagLocation::getELocationStatus, 0)
+//                        .orderByAsc(ETagLocation::getSequenceId));
+//                if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
+//                    throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
+//                }
+//                for (ETagLocation eTagLocation : eTagLocationList) {
+//                    if (!boxNoList.isEmpty()) {
+//                        String tempBoxNo = boxNoList.get(0);
+//                        ELocationConfig eLocationConfig = new ELocationConfig();
+//                        eLocationConfig.setWorkOrder(tempBoxNo.split("@")[0]);
+//                        eLocationConfig.setWorkCenter(tempBoxNo.split("@")[1]);
+//                        eLocationConfig.setWorkStation(workStation);
+//                        eLocationConfig.setELocationId(eTagLocation.getELocationId());
+//                        eLocationConfig.setOrderBoxNo(tempBoxNo);
+//                        // 添加配置
+//                        eLocationConfigList.add(eLocationConfig);
+//                        // 移除已经分配的盒子
+//                        boxNoList.remove(tempBoxNo);
+//                    }
+//                }
+//                // 将电子标签库位配置存进数据库
+//                eLocationConfigService.saveBatch(eLocationConfigList);
+//            }
+//        } catch (Exception e) {
+//            logger.error("创建站台：{}工作发生异常：{}", workStation, convertJsonString(e));
+//            // 回滚事务
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//        } finally {
+//            // 当前站台创建任务完成
+//            workCreatingStations.remove(workStation);
+//        }
+//    }
+
     @Override
     @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     public void createWork(String workStation) throws Exception {
@@ -68,34 +194,29 @@ public class WorkServiceImplements implements IWorkService {
         try {
             // 先查看当前站台已经生成的工作流是否为空
             List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
-                    .eq(WorkFlow::getWorkStation, workStation));
+                    .eq(WorkFlow::getWorkStation, workStation)
+                    .ne(WorkFlow::getWorkStatus, 0));
             // 当前站台的工作流中还存在其他任务
             if (currentWorkFlowList != null && !currentWorkFlowList.isEmpty()) {
                 return;
             }
-            // 当前站台分配的工位
+            // 查询是否有已经分配好的电子标签库位信息
-            List<WorkFlow> currentStationWorkFlows = new ArrayList<>();
+            List<ELocationConfig> oldELocationConfigList = eLocationConfigService.list(new LambdaQueryWrapper<ELocationConfig>()
-            // 先找MWL机型
+                    .eq(ELocationConfig::getWorkStation, workStation));
-            findWorks(workStation, currentStationWorkFlows, "MWL");
+            if (oldELocationConfigList != null && !oldELocationConfigList.isEmpty()) {
-            if (currentStationWorkFlows.isEmpty()) {
+                return;
-                // 找非MWL机型
-                findWorks(workStation, currentStationWorkFlows, "NOT_MWL");
             }
+            // 查询所有待下发的
+            List<WorkFlow> currentStationWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                    .eq(WorkFlow::getWorkStatus, 0)
+                    .eq(WorkFlow::getWorkStation, workStation));
             // 如果当前站台有任务
             if (!currentStationWorkFlows.isEmpty()) {
-                // 将工作流列表添加进数据库
-                workFlowService.saveBatch(currentStationWorkFlows);
-                // 获得工单列表
-                List<String> workOrderList = new ArrayList<>();
                 // 获得工单以及小工位列表
                 List<String> boxNoList = new ArrayList<>();
                 // 要料Map
                 Map<String, BigDecimal> needGoodsMap = new HashMap<>();
                 for (WorkFlow tempWorkflow : currentStationWorkFlows) {
-                    // 添加工单
-                    if (!workOrderList.contains(tempWorkflow.getWorkOrder())) {
-                        workOrderList.add(tempWorkflow.getWorkOrder());
-                    }
                     // 添加盒子配置
                     String boxNo = tempWorkflow.getWorkOrder() + "@" + tempWorkflow.getWorkCenter();
                     if (!boxNoList.contains(boxNo)) {
@@ -114,6 +235,7 @@ public class WorkServiceImplements implements IWorkService {
                 List<GoodsToStation> goodsToStationList = new ArrayList<>();
                 for (String goodsId : needGoodsMap.keySet()) {
                     GoodsToStation goodsToStation = new GoodsToStation();
+                    goodsToStation.setConfigId(goodsId + "_" + workStation);
                     goodsToStation.setGoodsId(goodsId);
                     goodsToStation.setWorkStation(workStation);
                     goodsToStation.setDistributeStatus(0);
@@ -122,22 +244,7 @@ public class WorkServiceImplements implements IWorkService {
                     goodsToStationList.add(goodsToStation);
                 }
                 // 将站台要料列表存进数据库
-                goodsToStationService.saveBatch(goodsToStationList);
+                goodsToStationService.saveOrUpdateBatch(goodsToStationList);
-                // 更新工单表
-                List<String> orderIds = currentStationWorkFlows.stream().map(WorkFlow::getOrderId).distinct().toList();
-                if (!orderIds.isEmpty()) {
-                    kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
-                            .set(KateOrders::getOrderStatus, 1)
-                            .in(KateOrders::getOrderId, orderIds)
-                            .eq(KateOrders::getOrderStatus, 0));
-                }
-                // 更新dbs表
-                if (!workOrderList.isEmpty()) {
-                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
-                            .set(KateDBS::getDbsStatus, 1)
-                            .in(KateDBS::getWorkOrder, workOrderList)
-                            .eq(KateDBS::getDbsStatus, 0));
-                }
                 // 电子标签库位配置
                 List<ELocationConfig> eLocationConfigList = new ArrayList<>();
                 // 查找到当前站台所有可用的电子标签
@@ -165,6 +272,12 @@ public class WorkServiceImplements implements IWorkService {
                 }
                 // 将电子标签库位配置存进数据库
                 eLocationConfigService.saveBatch(eLocationConfigList);
+                // 更新工作流状态
+                List<String> workFlowIds = currentStationWorkFlows.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
+                workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+                        .set(WorkFlow::getWorkStatus, 1)
+                        .in(WorkFlow::getWorkFlowId, workFlowIds)
+                        .eq(WorkFlow::getWorkStatus, 0));
             }
         } catch (Exception e) {
             logger.error("创建站台：{}工作发生异常：{}", workStation, convertJsonString(e));
@@ -176,6 +289,108 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
+//    @Override
+//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+//    public void doWork(String workStation) throws Exception {
+//        if (workDoingStations.contains(workStation)) {
+//            // 当前站台正在创建任务
+//            return;
+//        } else {
+//            // 添加站台
+//            workDoingStations.add(workStation);
+//        }
+//        try {
+//            // 查找当前站台未开始的工作流
+//            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+//                    .eq(WorkFlow::getWorkStation, workStation)
+//                    .ne(WorkFlow::getWorkStatus, 2));
+//            // 没有可做的任务
+//            if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
+//                return;
+//            }
+//            // 查站台要料表---未分配以及分配但未完全分配
+//            List<GoodsToStation> goodsToStationList = goodsToStationService.list(new LambdaQueryWrapper<GoodsToStation>()
+//                    .eq(GoodsToStation::getWorkStation, workStation)
+//                    .lt(GoodsToStation::getDistributeStatus, 2));
+//            if (goodsToStationList == null || goodsToStationList.isEmpty()) {
+//                // 查询是否还有这个站台的拣选任务
+//                if (!pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
+//                        .eq(PickTask::getStandId, workStation))) {
+//                    // 已经不存在未分配的任务，且没有拣选任务，可视为完成。
+//                    // 更新工作流状态-->完成
+//                    List<String> workFlowIds = currentWorkFlowList.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
+//                    if (!workFlowIds.isEmpty()) {
+//                        workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+//                                .set(WorkFlow::getWorkStatus, 2)
+//                                .set(WorkFlow::getFinishTime, LocalDateTime.now())
+//                                .set(WorkFlow::getOpUser, "系统自动完成")
+//                                .in(WorkFlow::getWorkFlowId, workFlowIds)
+//                                .ne(WorkFlow::getWorkStatus, 2));
+//                    }
+//                }
+//                return;
+//            }
+//            for (GoodsToStation goodsToStation : goodsToStationList) {
+//                // 当前物料当前站台需求数量
+//                BigDecimal needNum = goodsToStation.getTotalNum().subtract(goodsToStation.getDistributedNum());
+//                if (needNum.compareTo(BigDecimal.ZERO) == 0) {
+//                    // 需求数量为0
+//                    continue;
+//                }
+//                // 判断实际库存是否充足
+//                List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
+//                        .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, goodsToStation.getGoodsId())
+//                        .apply("goods_related ->> '$.remainNum' > 0"));
+//                if (stockList == null || stockList.isEmpty()) {
+//                    goodsToStation.setDistributeStatus(3);
+//                    continue;
+//                }
+//                // 判断当前物料是否在流转中
+//                needNum = wmsTaskService.callGoods(goodsToStation.getGoodsId(), needNum, workStation);
+//                // 判断此时需求数量是否为0
+//                if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
+//                    // 分配完成
+//                    goodsToStation.setDistributeStatus(2);
+//                } else {
+//                    needNum = wmsTaskService.callStocks(goodsToStation.getGoodsId(), needNum, workStation);
+//                    if (needNum.compareTo(BigDecimal.ZERO) > 0) {
+//                        // 已分配但未完全分配
+//                        goodsToStation.setDistributeStatus(1);
+//                    } else {
+//                        // 分配完成
+//                        goodsToStation.setDistributeStatus(2);
+//                    }
+//                }
+//                // 更新已分配数量
+//                goodsToStation.setDistributedNum(goodsToStation.getTotalNum().subtract(needNum));
+//            }
+//            goodsToStationService.updateBatchById(goodsToStationList);
+//            // 更新工作流状态
+//            List<String> workFlowIds = currentWorkFlowList.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
+//            List<String> orderIds = currentWorkFlowList.stream().map(WorkFlow::getOrderId).distinct().toList();
+//            List<String> goodsIds = currentWorkFlowList.stream().map(WorkFlow::getGoodsId).distinct().toList();
+//            List<String> smallBoxes = currentWorkFlowList.stream().map(WorkFlow::getWorkCenter).distinct().toList();
+//            workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+//                    .set(WorkFlow::getWorkStatus, 1)
+//                    .in(WorkFlow::getWorkFlowId, workFlowIds)
+//                    .eq(WorkFlow::getWorkStatus, 0));
+//            // 更新工单表状态
+//            kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+//                    .set(KateOrders::getOrderStatus, 2)
+//                    .in(KateOrders::getOrderId, orderIds)
+//                    .in(KateOrders::getGoodsId, goodsIds)
+//                    .in(KateOrders::getSupplyArea, smallBoxes)
+//                    .eq(KateOrders::getOrderStatus, 1));
+//        } catch (Exception e) {
+//            logger.error("执行站台：{}工作发生异常：{}", workStation, convertJsonString(e));
+//            // 回滚事务
+//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+//        } finally {
+//            // 当前站台创建任务完成
+//            workDoingStations.remove(workStation);
+//        }
+//    }
+
     @Override
     @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     public void doWork(String workStation) throws Exception {
@@ -190,34 +405,79 @@ public class WorkServiceImplements implements IWorkService {
             // 查找当前站台未开始的工作流
             List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
                     .eq(WorkFlow::getWorkStation, workStation)
-                    .ne(WorkFlow::getWorkStatus, 2));
+                    .eq(WorkFlow::getWorkStatus, 1));
             // 没有可做的任务
             if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
                 return;
             }
             // 查站台要料表---未分配以及分配但未完全分配
             List<GoodsToStation> goodsToStationList = goodsToStationService.list(new LambdaQueryWrapper<GoodsToStation>()
-                    .eq(GoodsToStation::getWorkStation, workStation)
+                    .eq(GoodsToStation::getWorkStation, workStation));
-                    .lt(GoodsToStation::getDistributeStatus, 2));
+            List<GoodsToStation> notFinishedGoodsList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() < 2).toList();
-            if (goodsToStationList == null || goodsToStationList.isEmpty()) {
+            if (notFinishedGoodsList.isEmpty()) {
                 // 查询是否还有这个站台的拣选任务
                 if (!pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
                         .eq(PickTask::getStandId, workStation))) {
-                    // 已经不存在未分配的任务，且没有拣选任务，可视为完成。
+                    // 需要重新分配的goodsToStationsList
-                    // 更新工作流状态-->完成
+                    Map<String, GoodsToStation> needDistributeGoodsMap = new HashMap<>();
-                    List<String> workFlowIds = currentWorkFlowList.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
+                    // 需要完成的工作流
-                    if (!workFlowIds.isEmpty()) {
+                    List<WorkFlow> needFinishWorkFlowList = new ArrayList<>();
-                        workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+                    // 所有缺料的分配
-                                .set(WorkFlow::getWorkStatus, 2)
+                    List<String> lackGoodsIdList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 3).map(GoodsToStation::getGoodsId).distinct().toList();
-                                .set(WorkFlow::getFinishTime, LocalDateTime.now())
+                    // 不缺料的分配
-                                .set(WorkFlow::getOpUser, "系统自动完成")
+                    Map<String, GoodsToStation> noLackGoodsMap = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 2).collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
-                                .in(WorkFlow::getWorkFlowId, workFlowIds)
+                    // 查询当前工作流中所有缺料的数据行
-                                .ne(WorkFlow::getWorkStatus, 2));
+                    for (WorkFlow notFinishedWorkFlow : currentWorkFlowList) {
+                        if (notFinishedWorkFlow.getPickedNum().compareTo(notFinishedWorkFlow.getNeedNum()) < 0) {
+                            // 缺料时，判断是否当前物料在缺料列表中
+                            if (lackGoodsIdList.contains(notFinishedWorkFlow.getGoodsId())) {
+                                // 缺料，添加到需要分配的列表中
+                                notFinishedWorkFlow.setWorkStatus(2);
+                                notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
+                                notFinishedWorkFlow.setOpUser("系统自动完成");
+                                needFinishWorkFlowList.add(notFinishedWorkFlow);
+                            } else {
+                                BigDecimal needNum = notFinishedWorkFlow.getNeedNum().subtract(notFinishedWorkFlow.getPickedNum());
+                                if (needDistributeGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
+                                    // 减少分配数量
+                                    GoodsToStation oldGoodsToStation = needDistributeGoodsMap.get(notFinishedWorkFlow.getGoodsId());
+                                    oldGoodsToStation.setDistributedNum(oldGoodsToStation.getDistributedNum().subtract(needNum));
+                                    oldGoodsToStation.setDistributeStatus(1);
+                                    needDistributeGoodsMap.replace(notFinishedWorkFlow.getGoodsId(), oldGoodsToStation);
+                                } else {
+                                    if (noLackGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
+                                        GoodsToStation newGoodsToStation = noLackGoodsMap.get(notFinishedWorkFlow.getGoodsId());
+                                        newGoodsToStation.setDistributedNum(newGoodsToStation.getDistributedNum().subtract(needNum));
+                                        newGoodsToStation.setDistributeStatus(1);
+                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), newGoodsToStation);
+                                    } else {
+                                        GoodsToStation goodsToStation = new GoodsToStation();
+                                        goodsToStation.setConfigId(notFinishedWorkFlow.getGoodsId() + "_" + workStation);
+                                        goodsToStation.setGoodsId(notFinishedWorkFlow.getGoodsId());
+                                        goodsToStation.setWorkStation(workStation);
+                                        goodsToStation.setDistributeStatus(0);
+                                        goodsToStation.setDistributedNum(BigDecimal.ZERO);
+                                        goodsToStation.setTotalNum(needNum);
+                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), goodsToStation);
                                     }
                                 }
+                            }
+                        } else {
+                            // 不缺料，直接完成
+                            notFinishedWorkFlow.setWorkStatus(2);
+                            notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
+                            notFinishedWorkFlow.setOpUser("系统自动完成");
+                            needFinishWorkFlowList.add(notFinishedWorkFlow);
+                        }
+                    }
+                    // 保存重新分配的goodsToStationList
+                    goodsToStationService.saveOrUpdateBatch(needDistributeGoodsMap.values());
+                    // 保存需要完成的工作流
+                    workFlowService.updateBatchById(needFinishWorkFlowList);
+                }
                 return;
             }
-            for (GoodsToStation goodsToStation : goodsToStationList) {
+            for (GoodsToStation goodsToStation : notFinishedGoodsList) {
                 // 当前物料当前站台需求数量
                 BigDecimal needNum = goodsToStation.getTotalNum().subtract(goodsToStation.getDistributedNum());
                 if (needNum.compareTo(BigDecimal.ZERO) == 0) {
@@ -251,23 +511,7 @@ public class WorkServiceImplements implements IWorkService {
                 // 更新已分配数量
                 goodsToStation.setDistributedNum(goodsToStation.getTotalNum().subtract(needNum));
             }
-            goodsToStationService.updateBatchById(goodsToStationList);
+            goodsToStationService.updateBatchById(notFinishedGoodsList);
-            // 更新工作流状态
-            List<String> workFlowIds = currentWorkFlowList.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
-            List<String> orderIds = currentWorkFlowList.stream().map(WorkFlow::getOrderId).distinct().toList();
-            List<String> goodsIds = currentWorkFlowList.stream().map(WorkFlow::getGoodsId).distinct().toList();
-            List<String> smallBoxes = currentWorkFlowList.stream().map(WorkFlow::getWorkCenter).distinct().toList();
-            workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
-                    .set(WorkFlow::getWorkStatus, 1)
-                    .in(WorkFlow::getWorkFlowId, workFlowIds)
-                    .eq(WorkFlow::getWorkStatus, 0));
-            // 更新工单表状态
-            kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
-                    .set(KateOrders::getOrderStatus, 2)
-                    .in(KateOrders::getOrderId, orderIds)
-                    .in(KateOrders::getGoodsId, goodsIds)
-                    .in(KateOrders::getSupplyArea, smallBoxes)
-                    .eq(KateOrders::getOrderStatus, 1));
         } catch (Exception e) {
             logger.error("执行站台：{}工作发生异常：{}", workStation, convertJsonString(e));
             // 回滚事务
@@ -278,6 +522,108 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
+//    @Override
+//    public String finishWork(String workStation) throws Exception {
+//        if (workFinishingStations.contains(workStation)) {
+//            // 当前站台正在完成工作
+//            return "当前站台正在完成工作，请勿重复操作";
+//        } else {
+//            // 添加站台
+//            workFinishingStations.add(workStation);
+//        }
+//        try {
+//            if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
+//                    .eq(WorkFlow::getWorkStation, workStation)
+//                    .ne(WorkFlow::getWorkStatus, 2))) {
+//                // 当前站台工作未全部完成
+//                return "工作未全部做完，不允许确认完成。";
+//            }
+//            if (eLocationConfigService.exists(new LambdaQueryWrapper<ELocationConfig>()
+//                    .eq(ELocationConfig::getWorkStation, workStation)
+//                    .eq(ELocationConfig::getPrintStatus, 0))) {
+//                // 有标签未打印
+//                return "有标签未打印";
+//            }
+//            if (!eLocationConfigService.exists(new LambdaQueryWrapper<ELocationConfig>()
+//                    .eq(ELocationConfig::getWorkStation, workStation))) {
+//                // 没有标签，说明点过确认。
+//                return "没有可以确认完成的工作，请勿重复点击。";
+//            }
+//            // 查找当前站台的标签配置
+//            List<ELocationConfig> eLocationConfigList = eLocationConfigService.list(new LambdaQueryWrapper<ELocationConfig>()
+//                    .eq(ELocationConfig::getWorkStation, workStation));
+//            // 保存一下记录
+//            List<ELocationConfigLast> eLocationConfigLastList = ELocationConfig.toLocationsConfigLastList(eLocationConfigList);
+//            // 先清空之前的
+//            eLocationConfigLastService.remove(new LambdaQueryWrapper<ELocationConfigLast>()
+//                    .eq(ELocationConfigLast::getWorkStation, workStation));
+//            eLocationConfigLastService.saveBatch(eLocationConfigLastList);
+//            // 删除所有的标签配置
+//            eLocationConfigService.remove(new LambdaQueryWrapper<ELocationConfig>()
+//                    .eq(ELocationConfig::getWorkStation, workStation));
+//            // 查询当前站台的所有工作流列表
+//            List<WorkFlow> workFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+//                    .eq(WorkFlow::getWorkStation, workStation)
+//                    .eq(WorkFlow::getWorkStatus, 2));
+//            // workSummary列表
+//            List<WorkSummary> workSummaryList = new ArrayList<>();
+//            for (WorkFlow workFlow : workFlowList) {
+//                WorkSummary summary = new WorkSummary();
+//                summary.setWorkFlowId(workFlow.getWorkFlowId());
+//                summary.setWorkStation(workFlow.getWorkStation());
+//                summary.setWorkOrder(workFlow.getWorkOrder());
+//                summary.setWorkCenter(workFlow.getWorkCenter());
+//                summary.setGoodsId(workFlow.getGoodsId());
+//                summary.setPickedNum(workFlow.getPickedNum());
+//                summary.setNeedNum(workFlow.getNeedNum());
+//                summary.setLackNum(workFlow.getNeedNum().subtract(workFlow.getPickedNum()));
+//                summary.setWorkDate(workFlow.getCreateTime().toLocalDate().atStartOfDay());
+//                summary.setWorkStatus(workFlow.getWorkStatus());
+//                summary.setLackStatus(summary.getLackNum().compareTo(BigDecimal.ZERO) > 0 ? 1 : 0);
+//                summary.setFinishTime(workFlow.getFinishTime());
+//                summary.setOpUser(workFlow.getOpUser());
+//                // 设置电子标签位置
+//                List<ELocationConfig> currentBoxELocationList = eLocationConfigList.stream().filter(e ->
+//                        e.getWorkOrder().equals(workFlow.getWorkOrder())
+//                                && e.getWorkCenter().equals(workFlow.getWorkCenter())).toList();
+//                summary.setELocationId(currentBoxELocationList.size() > 0 ? currentBoxELocationList.get(0).getELocationId() : "");
+//                workSummaryList.add(summary);
+//                // 更新工单表
+//                kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+//                        .set(KateOrders::getOrderStatus, 4)
+//                        .set(KateOrders::getFinishTime, LocalDateTime.now())
+//                        .set(KateOrders::getPickedQuantity, workFlow.getPickedNum())
+//                        .set(KateOrders::getLackQuantity, workFlow.getNeedNum().subtract(workFlow.getPickedNum()))
+//                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
+//                        .eq(KateOrders::getSupplyArea, workFlow.getWorkCenter())
+//                        .eq(KateOrders::getGoodsId, workFlow.getGoodsId()));
+//                // 如果当前工单已经没有未完成的工作，更新DBS状态完成
+//                if (!kateOrdersService.exists(new LambdaQueryWrapper<KateOrders>()
+//                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
+//                        .ne(KateOrders::getOrderStatus, 4))) {
+//                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
+//                            .set(KateDBS::getDbsStatus, 2)
+//                            .set(KateDBS::getLastUpdateTime, LocalDateTime.now())
+//                            .eq(KateDBS::getWorkOrder, workFlow.getOrderId()));
+//                }
+//            }
+//            workSummaryService.saveBatch(workSummaryList);
+//            // 移除工作流
+//            workFlowService.remove(new LambdaQueryWrapper<WorkFlow>()
+//                    .eq(WorkFlow::getWorkStation, workStation));
+//            // 移库站台要料
+//            goodsToStationService.remove(new LambdaQueryWrapper<GoodsToStation>()
+//                    .eq(GoodsToStation::getWorkStation, workStation));
+//        } catch (Exception e) {
+//            logger.error("完成站台：{}工作发生异常：{}", workStation, convertJsonString(e));
+//            throw new Exception("完成站台：" + workStation + "工作发生异常!");
+//        } finally {
+//            // 当前站台工作完成
+//            workFinishingStations.remove(workStation);
+//        }
+//        return "";
+//    }
+
     @Override
     public String finishWork(String workStation) throws Exception {
         if (workFinishingStations.contains(workStation)) {
@@ -290,7 +636,7 @@ public class WorkServiceImplements implements IWorkService {
         try {
             if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                     .eq(WorkFlow::getWorkStation, workStation)
-                    .ne(WorkFlow::getWorkStatus, 2))) {
+                    .eq(WorkFlow::getWorkStatus, 1))) {
                 // 当前站台工作未全部完成
                 return "工作未全部做完，不允许确认完成。";
             }
@@ -344,24 +690,6 @@ public class WorkServiceImplements implements IWorkService {
                                 && e.getWorkCenter().equals(workFlow.getWorkCenter())).toList();
                 summary.setELocationId(currentBoxELocationList.size() > 0 ? currentBoxELocationList.get(0).getELocationId() : "");
                 workSummaryList.add(summary);
-                // 更新工单表
-                kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
-                        .set(KateOrders::getOrderStatus, 4)
-                        .set(KateOrders::getFinishTime, LocalDateTime.now())
-                        .set(KateOrders::getPickedQuantity, workFlow.getPickedNum())
-                        .set(KateOrders::getLackQuantity, workFlow.getNeedNum().subtract(workFlow.getPickedNum()))
-                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
-                        .eq(KateOrders::getSupplyArea, workFlow.getWorkCenter())
-                        .eq(KateOrders::getGoodsId, workFlow.getGoodsId()));
-                // 如果当前工单已经没有未完成的工作，更新DBS状态完成
-                if (!kateOrdersService.exists(new LambdaQueryWrapper<KateOrders>()
-                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
-                        .ne(KateOrders::getOrderStatus, 4))) {
-                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
-                            .set(KateDBS::getDbsStatus, 2)
-                            .set(KateDBS::getLastUpdateTime, LocalDateTime.now())
-                            .eq(KateDBS::getWorkOrder, workFlow.getOrderId()));
-                }
             }
             workSummaryService.saveBatch(workSummaryList);
             // 移除工作流

src/main/java/com/wms/utils/excel/listener/UploadWorkFlowListener.java

@@ -0,0 +1,118 @@
+package com.wms.utils.excel.listener;
+
+import com.alibaba.excel.context.AnalysisContext;
+import com.alibaba.excel.read.listener.ReadListener;
+import com.alibaba.excel.util.ListUtils;
+import com.wms.constants.enums.ConfigMapKeyEnum;
+import com.wms.entity.table.WorkFlow;
+import com.wms.service.WorkFlowService;
+import com.wms.utils.WmsUtils;
+import com.wms.utils.excel.vo.KateWorkFlowExcelVo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 上传库存监听
+ */
+public class UploadWorkFlowListener implements ReadListener<KateWorkFlowExcelVo> {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    /**
+     * 每隔5条存储数据库，实际使用中可以1000条，然后清理list ，方便内存回收
+     */
+    private static final int BATCH_COUNT = 1000;
+    private List<KateWorkFlowExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
+    private final WorkFlowService workFlowService;// Dbs服务
+    private final Map<String, WorkFlow> oldWorkFlowMap;// 旧的工作流数据
+    private final Map<String, WorkFlow> newWorkFlowMap = new HashMap<>();// 新的工作流数据
+    private final List<String> standIds;// 不可用工作站台
+    public UploadWorkFlowListener(WorkFlowService workFlowService, Map<String, WorkFlow> oldWorkFlowMap, List<String> standIds) {
+        this.workFlowService = workFlowService;
+        this.oldWorkFlowMap = oldWorkFlowMap;
+        this.standIds = standIds;
+    }
+
+    @Override
+    public void onException(Exception exception, AnalysisContext context) throws Exception {
+        int rowCount = context.readRowHolder().getRowIndex() + 1;
+        logger.error("处理工单数据发生异常，第{}行发生异常。", rowCount);
+        throw new Exception("第" + rowCount + "行数据异常。");
+    }
+
+    /**
+     * 这个每一条数据解析都会来调用
+     *
+     * @param workFlowExcelVo    one row value. It is same as {@link AnalysisContext#readRowHolder()}
+     * @param analysisContext context
+     */
+    @Override
+    public void invoke(KateWorkFlowExcelVo workFlowExcelVo, AnalysisContext analysisContext) {
+        if (!standIds.contains(workFlowExcelVo.getWorkOrder())) {
+                // 符合条件
+                cachedDataList.add(workFlowExcelVo);
+        }
+        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
+        if (cachedDataList.size() >= BATCH_COUNT) {
+            saveData();
+            // 存储完成清理 list
+            cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
+        }
+    }
+
+    /**
+     * 所有数据解析完成了 都会来调用
+     *
+     * @param analysisContext context
+     */
+    @Override
+    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
+        // 再做一次数据处理
+        saveData();
+        // 在这里统一保存数据
+        insertIntoDb();
+    }
+
+    /**
+     * 存储数据
+     */
+    private void saveData() {
+        for (KateWorkFlowExcelVo workFlowExcelVo : cachedDataList) {
+            String key = workFlowExcelVo.getWorkOrder() + workFlowExcelVo.getGoodsId() + workFlowExcelVo.getWorkCenter();
+            if (newWorkFlowMap.containsKey(key)) {
+                continue;
+            }
+            // 查询数据库是否存在重复数据
+            if (!oldWorkFlowMap.containsKey(key)) {
+                // 之前没存在过
+                WorkFlow newWorkFlow = new WorkFlow();
+                newWorkFlow.setWorkFlowId(WmsUtils.generateId("WORKFLOW_"));
+                newWorkFlow.setOrderId(key);
+                newWorkFlow.setWorkStation(workFlowExcelVo.getWorkStation());
+                newWorkFlow.setWorkOrder(workFlowExcelVo.getWorkOrder());
+                newWorkFlow.setWorkCenter(workFlowExcelVo.getWorkCenter());
+                newWorkFlow.setGoodsId(workFlowExcelVo.getGoodsId());
+                newWorkFlow.setNeedNum(workFlowExcelVo.getNeedNum());
+                newWorkFlow.setCreateTime(LocalDateTime.now());
+                newWorkFlow.setWorkStatus(0);
+                newWorkFlow.setLightStatus(0);
+                newWorkFlow.setPickedNum(BigDecimal.ZERO);
+                newWorkFlowMap.put(key, newWorkFlow);
+            }
+        }
+    }
+
+    /**
+     * 保存数据库
+     */
+    private void insertIntoDb() {
+        logger.info("此次共导入{}条数据。", newWorkFlowMap.size());
+        // 保存数据
+        workFlowService.saveOrUpdateBatch(newWorkFlowMap.values(), BATCH_COUNT);
+        logger.info("保存成功{}条数据。", newWorkFlowMap.size());
+    }
+}

src/main/java/com/wms/utils/excel/vo/KateWorkFlowExcelVo.java

@@ -0,0 +1,46 @@
+package com.wms.utils.excel.vo;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.wms.entity.table.WorkFlow;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@Data
+public class KateWorkFlowExcelVo {
+    /**
+     * 工作站台
+     */
+    @ExcelProperty("工作站台")
+    private String workStation;
+    /**
+     * 工单
+     */
+    @ExcelProperty("工单")
+    private String workOrder;
+    /**
+     * 小盒子
+     */
+    @ExcelProperty("小盒子")
+    private String workCenter;
+    /**
+     * 料号
+     */
+    @ExcelProperty("料号")
+    private String goodsId;
+    /**
+     * 需求数量
+     */
+    @ExcelProperty("需求数量")
+    private BigDecimal needNum;
+
+    /**
+     * 从数据库实体转换为excel对象
+     * @param workFlowPo 数据库实体
+     * @return excel对象
+     */
+    public static KateWorkFlowExcelVo of(WorkFlow workFlowPo) {
+        return BeanUtil.copyProperties(workFlowPo, KateWorkFlowExcelVo.class);
+    }
+}