FeiDaBaoKai/wms_server_kate_suzhou
11
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

代码更新：

Browse Source 
1. 修改发送任务逻辑
2. 优化导入
This commit is contained in:
梁州 2024-09-21 18:23:39 +08:00
parent fe2beacfc6
commit fc1d0ef3b4
14 changed files with 461 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/main/java/com/wms/config/InitLocalConfig.java
View File

@ -1,7 +1,9 @@
package com.wms.config;
import com.wms.entity.table.Config;
import com.wms.entity.table.Location;
import com.wms.service.ConfigService;
import com.wms.service.LocationService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -14,6 +16,7 @@ import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Component
@Order(1)
@ -23,8 +26,13 @@ public class InitLocalConfig implements ApplicationRunner {
* 配置类
*/
private final ConfigService configService;
/**
* 库位服务
*/
private final LocationService locationService;
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
public static Map<String, String> configMap = new HashMap<String, String>();
public static Map<String, Location> instantLocationMap = new HashMap<>();
@Override
public void run(ApplicationArguments args) {
List<Config> configs = configService.selectConfigs("");
@ -34,5 +42,8 @@ public class InitLocalConfig implements ApplicationRunner {
logger.info("导入系统配置成功---{}：{}", config.getConfigName(), config.getConfigValue());
}
}
// 生成库位Map
instantLocationMap = locationService.list().stream().collect(Collectors.toMap(Location::getLocationId, location -> location));
logger.info("生成库位Map成功");
}
}

1
src/main/java/com/wms/constants/enums/ConfigMapKeyEnum.java
View File

@ -10,6 +10,7 @@ public enum ConfigMapKeyEnum {
CREATE_WORK("CREATE_WORK"),
START_WORK("START_WORK"),
SEND_TASK("SEND_TASK"),
SEND_PICK_OUT_TASK("SEND_PICK_OUT_TASK"),
MAX_VEHICLE_NUMS("MAX_VEHICLE_NUMS"),
MAX_WCS_ACCEPT_NUMS("MAX_WCS_ACCEPT_NUMS"),
SLOC_FILTER_STRING("SLOC_FILTER_STRING"),

33
src/main/java/com/wms/controller/ExcelController.java
View File

@ -41,10 +41,8 @@ import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.*;
import java.util.stream.Collectors;
import static com.wms.constants.WmsConstants.MYSQL_JSON_CI;
import static com.wms.utils.HttpUtils.getIpAddr;
@ -66,9 +64,7 @@ public class ExcelController {
private final LocationService locationService;// 库位服务
private final UploadRecordService uploadRecordService;// 上传服务
private final KateDBSService kateDbsService;// Dbs服务
private final KateDBSLastService kateDbsLastService;// Dbs上次记录服务
private final KateOrdersService kateOrdersService;// 工单服务
private final KateOrdersLastService kateOrdersLastService;// 工单上次服务
private final GoodsService goodsService;// 物料服务
private final WorkStationConfigService workStationConfigService;// 工站配置服务
@ -167,14 +163,10 @@ public class ExcelController {
return convertJsonString(response);
}
uploadFileHashStringList.add(fileVo.getHash());
// 先移除之前last表中的内容
kateDbsLastService.remove(new LambdaQueryWrapper<>());
// 将当前Dbs表的数据存进Last表
kateDbsLastService.saveBatch(BeanUtil.copyToList(kateDbsService.list(), KateDBSLast.class));
// 移库Dbs表中的内容
kateDbsService.remove(new LambdaQueryWrapper<>());
// 获取之前DBS表的内容
Map<String, KateDBS> kateDbsMap = kateDbsService.list().stream().collect(Collectors.toMap(KateDBS::getWorkOrder, kateDBS -> kateDBS));
// 导入excel
EasyExcel.read(file.getInputStream(), KateDbsExcelVo.class, new UploadDbsListener(kateDbsService, kateDbsLastService, fileVo.getUserName())).sheet().headRowNumber(8).doRead();
EasyExcel.read(file.getInputStream(), KateDbsExcelVo.class, new UploadDbsListener(kateDbsService, kateDbsMap, fileVo.getUserName())).sheet().headRowNumber(8).doRead();
// 添加导入记录
uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "DBS"));
uploadFileHashStringList.remove(fileVo.getHash());
@ -212,16 +204,10 @@ public class ExcelController {
return convertJsonString(response);
}
uploadFileHashStringList.add(fileVo.getHash());
// 先移除之前last表中的内容
kateOrdersLastService.remove(new LambdaQueryWrapper<>());
// 将当前工单表的数据存进Last表
List<KateOrdersLast> kateOrdersLastList = BeanUtil.copyToList(kateOrdersService.list(), KateOrdersLast.class);
kateOrdersLastService.saveBatch(kateOrdersLastList);
// 移库工单表中的内容
kateOrdersService.remove(new LambdaQueryWrapper<>());
// 获取之前工单表的内容
Map<String, KateOrders> kateOrdersMap = kateOrdersService.list().stream().collect(Collectors.toMap(kateOrders -> kateOrders.getWorkOrder() + kateOrders.getGoodsId() + kateOrders.getSupplyArea(), kateOrders -> kateOrders));
// 导入excel
// TODO
EasyExcel.read(file.getInputStream(), KateOrdersExcelVo.class, new UploadKateOrdersListener(kateOrdersLastList, kateOrdersService, fileVo.getUserName())).sheet().doRead();
EasyExcel.read(file.getInputStream(), KateOrdersExcelVo.class, new UploadKateOrdersListener(kateOrdersService, kateOrdersMap, fileVo.getUserName())).sheet().doRead();
// 添加导入记录
uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "ORDERS"));
uploadFileHashStringList.remove(fileVo.getHash());
@ -299,7 +285,8 @@ public class ExcelController {
}
uploadFileHashStringList.add(fileVo.getHash());
// 导入excel
EasyExcel.read(file.getInputStream(), StationConfigExcelVo.class, new UploadStationConfigListener(workStationConfigService, fileVo.getUserName())).sheet("工站配置").doRead();
Map<String, WorkStationConfig> oldWorkStationConfigMap = workStationConfigService.list().stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, workStationConfig -> workStationConfig));
EasyExcel.read(file.getInputStream(), StationConfigExcelVo.class, new UploadStationConfigListener(workStationConfigService, oldWorkStationConfigMap, fileVo.getUserName())).sheet("工站配置").doRead();
// 添加导入记录
uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "STATION-CONFIG_"));
uploadFileHashStringList.remove(fileVo.getHash());

20
src/main/java/com/wms/controller/JobComponent.java
View File

@ -63,6 +63,26 @@ public class JobComponent {
}
}
/**
* 向Wcs下发站台拣选出库任务
* 每2秒执行一次
*/
@Scheduled(fixedDelay = 2000)
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public void sendPickOutTasks() {
String sendTask = configMap.get(ConfigMapKeyEnum.SEND_PICK_OUT_TASK.getConfigKey());
if (StringUtils.isEmpty(sendTask) || !sendTask.equals("1")) {
return;
}
try {
// 发送站台拣选出库任务
wmsJobService.sendPickOutTasks();
} catch (Exception e) {
// 回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
}
/**
* 拣选任务
* 每2秒执行一次

180
src/main/java/com/wms/controller/TaskController.java
View File

@ -605,6 +605,7 @@ public class TaskController {
.set(Task::getDestination, nextLocationId)
.set(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())
.eq(Task::getVehicleId, wcsVehicleInRequest.getVehicleNo())
.eq(Task::getTaskType, TaskType.IN.getCode())
.eq(Task::getTaskStatus, WmsTaskStatus.TEMP.getCode());
if (!taskService.update(lambdaUpdateWrapperOfTask)) {
// 回退库位锁定
@ -900,7 +901,7 @@ public class TaskController {
if (pickTask == null || StringUtils.isEmpty(pickTask.getVehicleId())) {
logger.error("当前站台查不到正在拣选的箱子");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前站台查不到正在拣选的箱子");
response.setMessage("当前站台查不到正在拣选的箱子，请尝试拣选界面修改当前料箱状态。");
return convertJsonString(response);
}
String vehicleId = pickTask.getVehicleId();
@ -912,7 +913,7 @@ public class TaskController {
if (stock == null || StringUtils.isEmpty(stock.getStockId()) || stock.getGoodsRelated() == null) {
logger.error("请求料号：{}与正在拣选的箱子：{}无对应关系", workQuery.getGoodsId(), vehicleId);
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("请求料号：" + workQuery.getGoodsId() + "与正在拣选的箱子：" + vehicleId + "无对应关系");
response.setMessage("请求料号：" + workQuery.getGoodsId() + "与正在拣选的箱子：" + vehicleId + "无对应关系，请扫描其他料号或者按按钮。");
return convertJsonString(response);
}
// 查一下物料信息
@ -930,7 +931,7 @@ public class TaskController {
if (workFlows == null || workFlows.isEmpty()) {
logger.error("当前站台当前物料查询不到对应的工作");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前站台当前物料查询不到对应的工作");
response.setMessage("当前站台当前物料查询不到对应的工作，请扫描其他料号或者按按钮。");
return convertJsonString(response);
}
// 亮灯
@ -1027,26 +1028,8 @@ public class TaskController {
standPickVo.setPlanPickNum(originNum.subtract(realNum));
standPickVo.setRemainNumOrigin(realNum);
standPickVo.setRemainNumReal(realNum);
try {
// 获取当前站台已完成数量
List<WorkFlow> allWorkFlows = workFlowService.list();
int finishingRows = 0;
BigDecimal finishedCounts = BigDecimal.ZERO;
BigDecimal allCounts = BigDecimal.ZERO;
for (WorkFlow workFlow : allWorkFlows) {
if (workFlow.getWorkStatus() == 2) {
finishingRows++;
}
finishedCounts = finishedCounts.add(workFlow.getPickedNum());
allCounts = allCounts.add(workFlow.getNeedNum());
}
standPickVo.setFinishedRows(finishingRows);
standPickVo.setTotalRows(allWorkFlows.size());
standPickVo.setFinishedCounts(finishedCounts);
standPickVo.setTotalCounts(allCounts);
} catch (Exception e) {
logger.error("获取已完成数据报表失败，可能存在类型转换错误");
}
// 获取完成工作信息
getFinishedInfo(standId, standPickVo);
standPickVo.setRemark(goodsInfo != null ? goodsInfo.getUnpackingType() : "");
// 返回成功
response.setCode(ResponseCode.OK.getCode());
@ -1103,6 +1086,8 @@ public class TaskController {
// 返回成功
StandPickVo standPickVo = new StandPickVo();
standPickVo.setTip(targetStand.getPickTip());
// 获取完成工作信息
getFinishedInfo(targetStand.getStandId(), standPickVo);
response.setCode(ResponseCode.OK.getCode());
response.setMessage("当前物料拣货完成。");
response.setReturnData(standPickVo);
@ -1139,6 +1124,33 @@ public class TaskController {
}
}
/**
* 获取已完成行数信息
* @param standPickVo 查询
*/
public void getFinishedInfo(String workStation, StandPickVo standPickVo) {
try {
// 获取当前站台所有的工作流信息
List<WorkFlow> allWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>().eq(WorkFlow::getWorkStation, workStation));
int finishingRows = 0;
BigDecimal finishedCounts = BigDecimal.ZERO;
BigDecimal allCounts = BigDecimal.ZERO;
for (WorkFlow workFlow : allWorkFlows) {
if (workFlow.getWorkStatus() == 2) {
finishingRows++;
}
finishedCounts = finishedCounts.add(workFlow.getPickedNum());
allCounts = allCounts.add(workFlow.getNeedNum());
}
standPickVo.setFinishedRows(finishingRows);
standPickVo.setTotalRows(allWorkFlows.size());
standPickVo.setFinishedCounts(finishedCounts);
standPickVo.setTotalCounts(allCounts);
} catch (Exception e) {
logger.error("获取已完成数据报表失败，可能存在类型转换错误");
}
}
/**
* 获取电子标签反馈
*
@ -1192,11 +1204,12 @@ public class TaskController {
GoodsToStation goodsToStation = goodsToStationService.getOne(new LambdaQueryWrapper<GoodsToStation>()
.eq(GoodsToStation::getWorkStation, workFlow.getWorkStation())
.eq(GoodsToStation::getGoodsId, workFlow.getGoodsId())
.lt(GoodsToStation::getDistributeStatus, 2)
// .lt(GoodsToStation::getDistributeStatus, 2)
.last("limit 1"));
if (goodsToStation != null) {
// 更新站台要料数量
goodsToStation.setDistributedNum(goodsToStation.getDistributedNum().subtract(BigDecimal.valueOf(diffNum)));
BigDecimal newDistributeNum = goodsToStation.getDistributedNum().subtract(BigDecimal.valueOf(diffNum));
goodsToStation.setDistributedNum(newDistributeNum.compareTo(BigDecimal.ZERO) <= 0 ? BigDecimal.ZERO : newDistributeNum);
goodsToStation.setDistributeStatus(1);
goodsToStationService.updateById(goodsToStation);
}
@ -1842,17 +1855,19 @@ public class TaskController {
// 生成料箱出库任务
int needNum = callEmptyVehicleRequest.getNeedNum();
List<Task> vehicleOutTasks = new ArrayList<>();
// TODO
while (needNum > 0) {
// 先找空箱
Vehicle emptyVehicle = vehicleService.getOne(new LambdaQueryWrapper<Vehicle>()
List<Task> vehicleOutTasks = new ArrayList<>();// 任务列表
List<String> outVehicleIds = new ArrayList<>();// 料箱列表
// 查询出需求数量的空箱
List<Vehicle> emptyVehicles = vehicleService.list(new LambdaQueryWrapper<Vehicle>()
.eq(StringUtils.isNotEmpty(callEmptyVehicleRequest.getVehicleType1()), Vehicle::getVehicleType, callEmptyVehicleRequest.getVehicleType1())
.eq(Vehicle::getIsEmpty, 1)
.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
.orderByAsc(Vehicle::getLastInTime)
.last("limit 1"));
if (emptyVehicle != null) {// 有可用的空箱
.last("limit " + needNum));
for (Vehicle emptyVehicle : emptyVehicles) {
if (needNum <= 0) {
break;
}
// 创建一个空箱出库任务
Task emptyVehicleTask = new Task();
emptyVehicleTask.setTaskId(generateId("VCK_"));
@ -1869,22 +1884,23 @@ public class TaskController {
emptyVehicleTask.setUserName(callEmptyVehicleRequest.getUserName());
emptyVehicleTask.setIsPicking(0);
vehicleOutTasks.add(emptyVehicleTask);
// 更新料箱信息
emptyVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
vehicleService.updateById(emptyVehicle);
// 出库料箱表
outVehicleIds.add(emptyVehicle.getVehicleId());
needNum--;
} else {// 已经没有空箱可用了
// TODO 这里后续增加出不出带料箱子的配置
break;
}
}
// 保存任务
taskService.saveBatch(vehicleOutTasks);
// 更新料箱表
vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
.set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
.in(Vehicle::getVehicleId, outVehicleIds)
.ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
if (needNum <= 0) {
response.setCode(ResponseCode.OK.getCode());
response.setMessage("呼叫空箱成功，请等待箱子出库。");
} else if (needNum < callEmptyVehicleRequest.getNeedNum()) {
response.setCode(ResponseCode.OK.getCode());
response.setMessage("已呼叫空箱，但库中空箱数量不足。需求" + callEmptyVehicleRequest.getNeedNum() + "个，实际呼叫" + (callEmptyVehicleRequest.getNeedNum() - needNum) + "个。");
response.setMessage("已呼叫空箱，但库中空箱数量不足。需求" + callEmptyVehicleRequest.getNeedNum() + "个，实际呼叫" + vehicleOutTasks.size() + "个。");
} else {
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("库中没有空箱了。");
@ -2273,7 +2289,7 @@ public class TaskController {
} else {
logger.info("没有可亮灯的数据。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("没有可亮灯的数据。");
response.setMessage("没有可亮灯的数据，请按按钮。");
}
return convertJsonString(response);
} catch (Exception e) {
@ -2513,6 +2529,14 @@ public class TaskController {
response.setMessage("请求缺少必须参数，箱号、料号、数量不可缺少。");
return convertJsonString(response);
}
// 验证载具号是否重复入库
if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, pickNumQuery.getVehicleId())
.and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
logger.error("当前箱子{}已在库中，无法回库。", pickNumQuery.getVehicleId());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前箱子" + pickNumQuery.getVehicleId() + "已在库中，无法回库。");
return convertJsonString(response);
}
// 更新库存
Stock existStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
.apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, pickNumQuery.getGoodsId())
@ -2522,10 +2546,23 @@ public class TaskController {
if (existStock != null && existStock.getGoodsRelated() != null) {
Stock originStock = BeanUtil.copyProperties(existStock, Stock.class);
StockDetailInfo goodsDetail = existStock.getGoodsRelated();
goodsDetail.setRemainNum(goodsDetail.getRemainNum().subtract(pickNumQuery.getRealPickNum()));
// 设置剩余库存
if (pickNumQuery.getRemainNum() != null) {
goodsDetail.setRemainNum(pickNumQuery.getRemainNum());
} else {
BigDecimal calRemainNum = goodsDetail.getRemainNum().subtract(pickNumQuery.getRealPickNum());
if (calRemainNum.compareTo(BigDecimal.ZERO) <= 0) {
logger.error("系统计算领料后库存为0，请界面输入剩余数量后再确认回库。");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("系统计算领料后库存为0，请界面输入剩余数量后再确认回库。");
return convertJsonString(response);
} else {
goodsDetail.setRemainNum(calRemainNum);
}
}
existStock.setGoodsRelated(goodsDetail);
stockService.updateById(existStock);
stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, "直接物料非计划领料确认回库", pickNumQuery.getUserName());
stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, "直接物料非计划领料确认回库更新", pickNumQuery.getUserName());
}
// 判断这个箱子是否还有拣选任务
boolean hasPickTasks = pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
@ -2537,14 +2574,6 @@ public class TaskController {
.eq(Task::getTaskType, TaskType.IN.getCode())
.likeRight(Task::getTaskId, "HK_"));
if (!hasBackTask) {
// 验证载具号是否重复入库
if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, pickNumQuery.getVehicleId())
.and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
logger.error("当前箱子{}已在库中，无法回库。", pickNumQuery.getVehicleId());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("当前箱子" + pickNumQuery.getVehicleId() + "已在库中，无法回库。");
return convertJsonString(response);
}
// 判断当前载具是否有入库任务
boolean hasInTask = taskService.exists(new LambdaQueryWrapper<Task>()
.eq(Task::getVehicleId, pickNumQuery.getVehicleId())
@ -2552,64 +2581,19 @@ public class TaskController {
.eq(Task::getTaskStatus, WmsTaskStatus.TEMP.getCode())
.likeRight(Task::getTaskId, "RK_"));
if (!hasInTask) {
// 寻找库位
String nextLocationId = "";
for (int i = 0; i < locationService.count(new LambdaQueryWrapper<Location>().eq(Location::getLocationStatus, LocationStatus.EMPTY.getCode())); i++) {
Map<String, String> resultMap = locationService.getOneLocation("", "");
if (resultMap.isEmpty() || !resultMap.containsKey("nextLocationId")) {
logger.error("暂无可用库位");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("暂无可用库位！");
return convertJsonString(response);
} else {
Location nextLocation = locationService.getOne(new LambdaQueryWrapper<Location>().eq(Location::getLocationId, resultMap.get("nextLocationId")).last("limit 1"));
LambdaUpdateWrapper<Location> updateLocationWrapper = new LambdaUpdateWrapper<Location>()
.set(Location::getLocationStatus, LocationStatus.OCCUPY.getCode())
.set(Location::getVehicleId, pickNumQuery.getVehicleId())
.eq(Location::getLocationId, nextLocation.getLocationId())
.eq(Location::getLocationStatus, LocationStatus.EMPTY.getCode());
if (locationService.update(updateLocationWrapper)) {
nextLocationId = resultMap.get("nextLocationId");
break;
}
}
}
if (Objects.equals(nextLocationId, "")) {
logger.error("暂无可用库位");
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("暂无可用库位！");
return convertJsonString(response);
}
// 生成回库任务
Task backTask = new Task();
backTask.setTaskId(generateId("HK_"));
backTask.setTaskGroup(generateId(""));
backTask.setTaskType(TaskType.IN.getCode());
backTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
backTask.setTaskStatus(WmsTaskStatus.TEMP.getCode());
backTask.setVehicleId(pickNumQuery.getVehicleId());
backTask.setDestination(nextLocationId);
backTask.setVehicleSize(1);
backTask.setWeight(BigDecimal.ZERO);
backTask.setTaskPriority(1);
backTask.setUserName(pickNumQuery.getUserName());
backTask.setCreateTime(LocalDateTime.now());
if (taskService.save(backTask)) {
// 设置库存状态为回库中
stockService.update(new LambdaUpdateWrapper<Stock>()
.set(Stock::getStockStatus, StockStatus.BACK.getCode())
.eq(Stock::getVehicleId, pickNumQuery.getVehicleId()));
} else {
// 回退库位锁定
locationService.update(new LambdaUpdateWrapper<Location>()
.set(Location::getLocationStatus, LocationStatus.EMPTY.getCode())
.set(Location::getVehicleId, "")
.eq(Location::getLocationId, nextLocationId)
.eq(Location::getLocationStatus, LocationStatus.OCCUPY.getCode()));
logger.error("生成回库任务失败，箱号：{}", pickNumQuery.getVehicleId());
response.setCode(ResponseCode.ERROR.getCode());
response.setMessage("生成回库任务失败。");
return convertJsonString(response);
}
taskService.save(backTask);
}
}
logger.info("确认回库成功。");

5
src/main/java/com/wms/entity/app/request/PickNumQuery.java
View File

@ -27,4 +27,9 @@ public class PickNumQuery extends PageQuery{
*/
@JsonProperty("realPickNum")
private BigDecimal realPickNum;
/**
* 剩余数量
*/
@JsonProperty("remainNum")
private BigDecimal remainNum;
}

6
src/main/java/com/wms/service/business/IWmsJobService.java
View File

@ -10,6 +10,12 @@ public interface IWmsJobService {
*/
void sendCommonTasks() throws Exception;
/**
* 下发拣选出库任务
* @throws Exception 异常
*/
void sendPickOutTasks() throws Exception;
/**
* 发送拣选任务
* @throws Exception 异常用于回滚事务

335
src/main/java/com/wms/service/business/serviceImplements/WmsJobServiceImplements.java
View File

@ -27,6 +27,7 @@ import java.time.LocalDateTime;
import java.util.*;
import static com.wms.config.InitLocalConfig.configMap;
import static com.wms.config.InitLocalConfig.instantLocationMap;
import static com.wms.utils.StringUtils.convertJsonString;
/**
@ -53,43 +54,16 @@ public class WmsJobServiceImplements implements IWmsJobService {
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode());
List<Task> allTasks = taskService.list(waitForDistributeTaskQuery);
if (!allTasks.isEmpty()) {
String max_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_NUMS.getConfigKey());
String max_wcs_accept_nums = configMap.get(ConfigMapKeyEnum.MAX_WCS_ACCEPT_NUMS.getConfigKey());
if (StringUtils.isEmpty(max_vehicle_nums) || StringUtils.isEmpty(max_wcs_accept_nums)) {
if (StringUtils.isEmpty(max_wcs_accept_nums)) {
logger.error("配置未生成");
return;
}
int maxVehicleNums = Integer.parseInt(max_vehicle_nums);
int maxWcsAcceptNums = Integer.parseInt(max_wcs_accept_nums);
List<String> outsideVehicles = outsideVehiclesService.selectDistinctVehicles();
if (outsideVehicles == null || outsideVehicles.isEmpty()) {
outsideVehicles = Collections.emptyList();
}
int remainVehicleNums = maxVehicleNums - outsideVehicles.size();
// 需要发送给wcs的任务列表
List<WcsTaskRequest> request = new ArrayList<>();
// 已经下发的任务组列表
List<String> taskGroupIds = new ArrayList<>();
// 本次生成的环线任务
List<String> pickVehicleIds = new ArrayList<>();
// 查找所有已经出库的站台拣选任务
List<PickTask> standPickTasks = pickTaskService.list();
// 生成一个Map，计算每个站台已经出库的拣选任务
Map<String, Integer> outPickTaskMap = new HashMap<>();
// 轮询工作站台，判断是否需要下发任务
List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
.eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
.eq(Stand::getStandType, 2));
for (Stand workStation : stands) {
outPickTaskMap.put(workStation.getStandId(), 0);
}
standPickTasks.forEach(pickTask -> {
if (!Objects.equals(pickTask.getPickStatus(), PickTaskStatusEnum.TEMP.getCode())) {
outPickTaskMap.put(pickTask.getStandId(),
outPickTaskMap.getOrDefault(pickTask.getStandId(), 0) + 1);
}
});
// 这里单独处理站台拣选出库以外的任务
for (Task task : allTasks) {
if (taskGroupIds.size() >= maxWcsAcceptNums) {
@ -128,91 +102,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
// 已经发送过的任务组
taskGroupIds.add(task.getTaskGroup());
}
// 处理站台拣选出库任务
while (taskGroupIds.size() < maxWcsAcceptNums && pickVehicleIds.size() < remainVehicleNums) {
// 先找出目前数量最少的站台
String standId = outPickTaskMap.entrySet().stream()
.min(Comparator.comparingInt(Map.Entry::getValue))
.map(Map.Entry::getKey)
.orElse("");
List<String> vehicleIds;
if (StringUtils.isNotEmpty(standId)) {
// 查找这个站台未下发的料箱
vehicleIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getStandId().equals(standId) && pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode()) && !pickVehicleIds.contains(pickTask.getVehicleId()))
.map(PickTask::getVehicleId)
.distinct()
.toList();
if (vehicleIds.isEmpty()) {
outPickTaskMap.remove(standId);
continue;
}
} else {
vehicleIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode()) && !pickVehicleIds.contains(pickTask.getVehicleId()))
.map(PickTask::getVehicleId)
.distinct()
.toList();
if (vehicleIds.isEmpty()) {
break;
}
}
// 生成箱子-站台数量的Map
Map<String, Integer> vehicleStandsMap = new HashMap<>();
standPickTasks.forEach(pickTask -> {
if (vehicleIds.contains(pickTask.getVehicleId())) {
vehicleStandsMap.put(pickTask.getVehicleId(),
vehicleStandsMap.getOrDefault(pickTask.getVehicleId(), 0) + 1);
}
});
// 先找出目前数量最多的料箱
String vehicleId = vehicleStandsMap.entrySet().stream()
.max(Comparator.comparingInt(Map.Entry::getValue))
.map(Map.Entry::getKey)
.orElse("");
if (StringUtils.isEmpty(vehicleId)) {
continue;
}
// 更新每个站台的拣选箱数量
List<String> standIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getVehicleId().equals(vehicleId))
.map(PickTask::getStandId)
.distinct()
.toList();
if (!standIds.isEmpty()) {
standIds.forEach(tempStandId -> outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1));
}
// 找到这个箱子的任务
List<Task> outPickTasks = allTasks.stream().filter(task ->
task.getVehicleId().equals(vehicleId) && Objects.equals(task.getTaskType(), TaskType.OUT.getCode())
&& task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
for (Task task : outPickTasks) {
if (taskGroupIds.contains(task.getTaskGroup())) {
// 该任务组已经下发
continue;
}
if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
// 查询一下前置的任务有没有存在，存在则不下发
if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
continue;
}
}
// 创建发送的任务
WcsTaskRequest tempTask = new WcsTaskRequest();
tempTask.setTaskId(task.getTaskGroup());
tempTask.setTaskType(task.getTaskType());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
tempTask.setVehicleNo(task.getVehicleId());
tempTask.setVehicleSize(task.getVehicleSize());
tempTask.setWeight(task.getWeight());
tempTask.setPriority(task.getTaskPriority());
request.add(tempTask);
// 已经发送过的任务组
taskGroupIds.add(task.getTaskGroup());
}
pickVehicleIds.add(vehicleId);
}
if (request.size() == 0) {
// 没有新任务发送
return;
@ -236,12 +125,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
.set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
.in(Task::getTaskGroup, taskGroupIds)
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// 流转载具状态变更
if (!pickVehicleIds.isEmpty()) {
outsideVehiclesService.update(new LambdaUpdateWrapper<OutsideVehicles>()
.set(OutsideVehicles::getOutStatus, 1)
.in(OutsideVehicles::getVehicleId, pickVehicleIds));
}
} else {
// 判断returnData的数据
if (result.getReturnData() != null) {
@ -268,6 +151,220 @@ public class WmsJobServiceImplements implements IWmsJobService {
}
}
@Override
public void sendPickOutTasks() throws Exception {
try {
// 检索任务表---新建未下发的任务
LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())
.eq(Task::getTaskType, TaskType.OUT.getCode());
List<Task> allTasks = taskService.list(waitForDistributeTaskQuery);
if (!allTasks.isEmpty()) {
// 需要发送给wcs的任务列表
List<WcsTaskRequest> request = new ArrayList<>();
// 已经下发的任务组列表
List<String> taskGroupIds = new ArrayList<>();
// 本次生成的环线任务
List<String> pickVehicleIds = new ArrayList<>();
// 查找所有站台拣选任务
List<PickTask> standPickTasks = pickTaskService.list();
// 生成一个Map，计算每个站台已经出库的拣选任务
Map<String, Integer> outPickTaskMap = new HashMap<>();
// 轮询工作站台，判断是否需要下发任务
List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
.eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
.eq(Stand::getStandType, 2));
for (Stand workStation : stands) {
outPickTaskMap.put(workStation.getStandId(), 0);
}
standPickTasks.forEach(pickTask -> {
if (!Objects.equals(pickTask.getPickStatus(), PickTaskStatusEnum.TEMP.getCode())) {
outPickTaskMap.put(pickTask.getStandId(),
outPickTaskMap.getOrDefault(pickTask.getStandId(), 0) + 1);
}
});
// 轮询堆垛机状态
List<Stand> stackerList = standService.list(new LambdaQueryWrapper<Stand>()
.eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
.eq(Stand::getStandType, 3));
List<Task> stackRunningTasks = taskService.list(new LambdaQueryWrapper<Task>()
.eq(Task::getTaskType, TaskType.OUT.getCode())
.eq(Task::getTaskStatus, WmsTaskStatus.RUN.getCode()));
Map<Integer, Integer> runningTaskNumToEquipmentMap = new HashMap<>();
Map<Integer, List<Task>> newTaskToEquipmentMap = new HashMap<>();
for (Stand stacker : stackerList) {
// 找这台堆垛机正在执行的拣选出库任务数量
runningTaskNumToEquipmentMap.put(stacker.getEquipmentId(), 0);
// 查询每台堆垛机还没有下发的任务
List<Task> stackNewTasks = allTasks.stream().filter(task ->
task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())
&& Objects.equals(stacker.getEquipmentId(), instantLocationMap.get(task.getOrigin()).getEquipmentId())
).toList();
newTaskToEquipmentMap.put(stacker.getEquipmentId(), stackNewTasks);
}
stackRunningTasks.forEach(task -> {
if (instantLocationMap.containsKey(task.getOrigin())) {
int key = instantLocationMap.get(task.getOrigin()).getEquipmentId();
runningTaskNumToEquipmentMap.put(key, runningTaskNumToEquipmentMap.get(key) + 1);
}
});
for (Stand stacker : stackerList) {
int availableTaskNum = 2 - runningTaskNumToEquipmentMap.get(stacker.getEquipmentId());
while (availableTaskNum > 0) {
// 可以继续发任务
List<Task> currentStackerTasks = newTaskToEquipmentMap.get(stacker.getEquipmentId());
// 从这些任务里面找到最适合的任务下发
if (!currentStackerTasks.isEmpty()) {
// 先找出目前数量最少的站台
String standId = outPickTaskMap.entrySet().stream()
.min(Comparator.comparingInt(Map.Entry::getValue))
.map(Map.Entry::getKey)
.orElse("");
List<String> vehicleIds;
List<String> currentStackerVehicleIds = currentStackerTasks.stream().map(Task::getVehicleId).distinct().toList();
if (StringUtils.isNotEmpty(standId)) {
// 查找这个站台未下发的料箱
vehicleIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getStandId().equals(standId) && pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
&& !pickVehicleIds.contains(pickTask.getVehicleId()) && currentStackerVehicleIds.contains(pickTask.getVehicleId()))
.map(PickTask::getVehicleId)
.distinct()
.toList();
if (vehicleIds.isEmpty()) {
outPickTaskMap.remove(standId);
continue;
}
} else {
vehicleIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
&& !pickVehicleIds.contains(pickTask.getVehicleId()) && currentStackerVehicleIds.contains(pickTask.getVehicleId()))
.map(PickTask::getVehicleId)
.distinct()
.toList();
if (vehicleIds.isEmpty()) {
break;
}
}
// 生成箱子-站台数量的Map
Map<String, Integer> vehicleStandsMap = new HashMap<>();
standPickTasks.forEach(pickTask -> {
if (vehicleIds.contains(pickTask.getVehicleId())) {
vehicleStandsMap.put(pickTask.getVehicleId(),
vehicleStandsMap.getOrDefault(pickTask.getVehicleId(), 0) + 1);
}
});
// 先找出适合的料箱
String vehicleId = vehicleStandsMap.entrySet().stream()
.min(Comparator.comparingInt(Map.Entry::getValue))
.map(Map.Entry::getKey)
.orElse("");
if (StringUtils.isEmpty(vehicleId)) {
continue;
}
// 更新每个站台的拣选箱数量
List<String> standIds = standPickTasks.stream()
.filter(pickTask -> pickTask.getVehicleId().equals(vehicleId))
.map(PickTask::getStandId)
.distinct()
.toList();
if (!standIds.isEmpty()) {
standIds.forEach(tempStandId -> outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1));
}
// 找到这个箱子的任务
List<Task> outPickTasks = currentStackerTasks.stream().filter(task -> task.getVehicleId().equals(vehicleId)).toList();
for (Task task : outPickTasks) {
if (taskGroupIds.contains(task.getTaskGroup())) {
// 该任务组已经下发
currentStackerTasks.remove(task);
continue;
}
if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
// 查询一下前置的任务有没有存在，存在则不下发
if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
continue;
}
}
// 创建发送的任务
WcsTaskRequest tempTask = new WcsTaskRequest();
tempTask.setTaskId(task.getTaskGroup());
tempTask.setTaskType(task.getTaskType());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
tempTask.setVehicleNo(task.getVehicleId());
tempTask.setVehicleSize(task.getVehicleSize());
tempTask.setWeight(task.getWeight());
tempTask.setPriority(task.getTaskPriority());
request.add(tempTask);
// 已经发送过的任务组
taskGroupIds.add(task.getTaskGroup());
}
// 已经发送过的vehicleId
pickVehicleIds.add(vehicleId);
// 移除已经发送过的任务
currentStackerTasks.removeIf(task -> task.getVehicleId().equals(vehicleId));
newTaskToEquipmentMap.replace(stacker.getEquipmentId(), currentStackerTasks);
} else {
break;
}
// 可用数量-1
availableTaskNum--;
}
}
if (request.size() == 0) {
// 没有新任务发送
return;
}
// 发送任务
String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
if (url != null) {
logger.info("向WCS发送拣选出库任务，地址：{}，请求详情：{}", url, convertJsonString(request));
ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
try {
logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
} catch (Exception e) {
logger.error("插入日志错误。");
}
if (result == null) {
logger.error("发送拣选出库任务异常。");
} else {
if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
logger.info("发送WCS拣选出库任务成功。");
taskService.update(new LambdaUpdateWrapper<Task>()
.set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
.in(Task::getTaskGroup, taskGroupIds)
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
// 流转载具状态变更
if (!pickVehicleIds.isEmpty()) {
outsideVehiclesService.update(new LambdaUpdateWrapper<OutsideVehicles>()
.set(OutsideVehicles::getOutStatus, 1)
.in(OutsideVehicles::getVehicleId, pickVehicleIds));
}
} else {
// 判断returnData的数据
if (result.getReturnData() != null) {
List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class);
if (!errorTasks.isEmpty()) {
List<String> failedTaskIds = errorTasks.stream().map(WcsTaskRequest::getTaskId).distinct().toList();
// 更新任务状态为异常
taskService.update(new LambdaUpdateWrapper<Task>()
.set(Task::getTaskStatus, WmsTaskStatus.EXCEPTION.getCode())
.in(Task::getTaskGroup, failedTaskIds)
.eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
}
}
logger.error("发送拣选出库任务错误：{}", convertJsonString(result));
}
}
} else {
logger.error("WCS发送任务地址为空。");
}
}
} catch (Exception exception) {
logger.error("向WCS发送拣选出库任务时发生异常：{}", convertJsonString(exception));
throw new Exception("向WCS发送拣选出库任务时发生异常。");
}
}
/**
* 发送拣选任务
*/

8
src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java
View File

@ -92,7 +92,7 @@ public class WorkServiceImplements implements IWorkService {
workOrderList.add(tempWorkflow.getWorkOrder());
}
// 添加盒子配置
String boxNo = tempWorkflow.getWorkOrder() + "-" + tempWorkflow.getWorkCenter();
String boxNo = tempWorkflow.getWorkOrder() + "@" + tempWorkflow.getWorkCenter();
if (!boxNoList.contains(boxNo)) {
boxNoList.add(boxNo);
}
@ -147,8 +147,8 @@ public class WorkServiceImplements implements IWorkService {
if (!boxNoList.isEmpty()) {
String tempBoxNo = boxNoList.get(0);
ELocationConfig eLocationConfig = new ELocationConfig();
eLocationConfig.setWorkOrder(tempBoxNo.split("-")[0]);
eLocationConfig.setWorkCenter(tempBoxNo.split("-")[1]);
eLocationConfig.setWorkOrder(tempBoxNo.split("@")[0]);
eLocationConfig.setWorkCenter(tempBoxNo.split("@")[1]);
eLocationConfig.setWorkStation(workStation);
eLocationConfig.setELocationId(eTagLocation.getELocationId());
eLocationConfig.setOrderBoxNo(tempBoxNo);
@ -327,7 +327,7 @@ public class WorkServiceImplements implements IWorkService {
workSummaryList.add(summary);
// 更新工单表
kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
.set(KateOrders::getOrderStatus, 2)
.set(KateOrders::getOrderStatus, 4)
.set(KateOrders::getFinishTime, LocalDateTime.now())
.set(KateOrders::getPickedQuantity, workFlow.getPickedNum())
.set(KateOrders::getLackQuantity, workFlow.getNeedNum().subtract(workFlow.getPickedNum()))

61
src/main/java/com/wms/utils/excel/listener/UploadDbsListener.java
View File

@ -3,10 +3,7 @@ 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.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.wms.entity.table.KateDBS;
import com.wms.entity.table.KateDBSLast;
import com.wms.service.KateDBSLastService;
import com.wms.service.KateDBSService;
import com.wms.utils.StringUtils;
import com.wms.utils.excel.vo.KateDbsExcelVo;
@ -14,8 +11,9 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.wms.utils.WmsUtils.generateId;
@ -28,17 +26,14 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 100;
/**
* 保存数据总数
*/
private int SAVE_COUNT = 0;
private List<KateDbsExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
private final KateDBSService kateDBSService;// Dbs服务
private final KateDBSLastService kateDBSLastService;// DbsLast服务
private final String uploadUser;// 用户
public UploadDbsListener(KateDBSService kateDBSService, KateDBSLastService kateDBSLastService, String uploadUser) {
private final Map<String, KateDBS> oldKateDBSMap;// 旧的DBS数据
private final Map<String, KateDBS> newKateDBSMap = new HashMap<>();// 新的DBS数据
public UploadDbsListener(KateDBSService kateDBSService, Map<String, KateDBS> oldKateDBSMap, String uploadUser) {
this.kateDBSService = kateDBSService;
this.kateDBSLastService = kateDBSLastService;
this.oldKateDBSMap = oldKateDBSMap;
this.uploadUser = uploadUser;
}
@ -66,7 +61,6 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
}
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
if (cachedDataList.size() >= BATCH_COUNT) {
logger.info("已经导入{}条数据，开始存储数据库！", cachedDataList.size());
saveData();
// 存储完成清理 list
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
@ -80,38 +74,34 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
*/
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
// 再做一次数据处理
saveData();
logger.info("此次共保存{}条数据。", SAVE_COUNT);
// 在这里统一保存数据
insertIntoDb();
}
/**
* 存储数据
*/
private void saveData() {
List<KateDBS> kateDbsList = new ArrayList<>();
for (KateDbsExcelVo kateDbsExcelVo : cachedDataList) {
if (kateDBSService.exists(new LambdaQueryWrapper<KateDBS>()
.eq(KateDBS::getWorkOrder, kateDbsExcelVo.getWorkOrder())
.or().eq(KateDBS::getWorkSequence, kateDbsExcelVo.getWorkSequence()))) {
// 工单号或者序号重复，那么跳过这条DBS
if (newKateDBSMap.containsKey(kateDbsExcelVo.getWorkOrder())) {
// 新的数据工单号重复，那么跳过这条DBS
continue;
}
KateDBSLast kateDbsLast = kateDBSLastService.getOne(new LambdaQueryWrapper<KateDBSLast>()
.eq(KateDBSLast::getWorkOrder, kateDbsExcelVo.getWorkOrder()));
if (kateDbsLast != null) {
// 之前存在过
KateDBS oldKateDbs = new KateDBS();
oldKateDbs.setDbsId(kateDbsLast.getDbsId());
if (oldKateDBSMap.containsKey(kateDbsExcelVo.getWorkOrder())) {
// 之前有
KateDBS oldKateDbs = oldKateDBSMap.get(kateDbsExcelVo.getWorkOrder());
oldKateDbs.setWorkSequence(kateDbsExcelVo.getWorkSequence());
oldKateDbs.setMachineNo(kateDbsExcelVo.getMachineNo());
oldKateDbs.setWorkOrder(kateDbsExcelVo.getWorkOrder());
oldKateDbs.setPlanStartDate(kateDbsExcelVo.getPlanStartDate());
oldKateDbs.setDbsStatus(kateDbsLast.getDbsStatus());
oldKateDbs.setLastUpdateTime(LocalDateTime.now());
oldKateDbs.setLastUpdateUser(uploadUser);
kateDbsList.add(oldKateDbs);
// 替换
newKateDBSMap.put(kateDbsExcelVo.getWorkOrder(), oldKateDbs);
} else {
// 之前没存在过
// 之前没有
KateDBS newKateDbs = new KateDBS();
newKateDbs.setDbsId(generateId("DBS_"));
newKateDbs.setWorkSequence(kateDbsExcelVo.getWorkSequence());
@ -121,10 +111,19 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
newKateDbs.setDbsStatus(0);
newKateDbs.setLastUpdateTime(LocalDateTime.now());
newKateDbs.setLastUpdateUser(uploadUser);
kateDbsList.add(newKateDbs);
// 添加
newKateDBSMap.put(kateDbsExcelVo.getWorkOrder(), newKateDbs);
}
}
kateDBSService.saveOrUpdateBatch(kateDbsList);
SAVE_COUNT += kateDbsList.size();
}
/**
* 保存数据库
*/
private void insertIntoDb() {
logger.info("此次共导入{}条数据。", newKateDBSMap.size());
// 保存数据
kateDBSService.saveOrUpdateBatch(newKateDBSMap.values(), BATCH_COUNT);
logger.info("保存成功{}条数据。", newKateDBSMap.size());
}
}

1
src/main/java/com/wms/utils/excel/listener/UploadGoodsListener.java
View File

@ -72,6 +72,7 @@ public class UploadGoodsListener implements ReadListener<GoodsExcelVo> {
*/
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
logger.info("已经导入{}条数据，开始存储数据库！", cachedDataList.size());
saveData();
logger.info("此次共保存{}条数据。", SAVE_COUNT);
}

119
src/main/java/com/wms/utils/excel/listener/UploadKateOrdersListener.java
View File

@ -25,27 +25,19 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
/**
* 每隔5条存储数据库，实际使用中可以1000条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 5000;
/**
* 保存数据总数
*/
private int SAVE_COUNT = 0;
private static final int BATCH_COUNT = 1000;
private List<KateOrdersExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
/**
* 优化导入速度的变量---开始
*/
private int MAP_INDEX = 0;
private int LAST_SHOT_INDEX = 0;
private final Map<Integer, Map<String, KateOrders>> doneMap = new HashMap<>();
private final List<KateOrdersLast> kateOrdersLastList;// 所有之前的工单列表;
/**
* 优化导入速度的变量---结束
* 筛选工单字符串
*/
private final String slocFilterString = configMap.get(ConfigMapKeyEnum.SLOC_FILTER_STRING.getConfigKey());
private final KateOrdersService kateOrdersService;// Dbs服务
private final String uploadUser;// 用户
public UploadKateOrdersListener(List<KateOrdersLast> kateOrdersLastList, KateOrdersService kateOrdersService, String uploadUser) {
this.kateOrdersLastList = kateOrdersLastList;
private final Map<String, KateOrders> oldKateOrdersMap;// 旧的工单数据
private final Map<String, KateOrders> newKateOrdersMap = new HashMap<>();// 新的工单数据
public UploadKateOrdersListener(KateOrdersService kateOrdersService, Map<String, KateOrders> oldKateOrdersMap, String uploadUser) {
this.kateOrdersService = kateOrdersService;
this.oldKateOrdersMap = oldKateOrdersMap;
this.uploadUser = uploadUser;
}
@ -64,7 +56,6 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
*/
@Override
public void invoke(KateOrdersExcelVo kateOrdersExcelVo, AnalysisContext analysisContext) {
String slocFilterString = configMap.get(ConfigMapKeyEnum.SLOC_FILTER_STRING.getConfigKey());
if (StringUtils.isNotEmpty(slocFilterString) && Objects.equals(kateOrdersExcelVo.getSortString(), slocFilterString)) {
// 符合筛选字符串
if (StringUtils.isNotEmpty(kateOrdersExcelVo.getWorkOrder())
@ -78,7 +69,6 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
}
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
if (cachedDataList.size() >= BATCH_COUNT) {
logger.info("已经导入{}条数据，开始存储数据库！", cachedDataList.size());
saveData();
// 存储完成清理 list
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
@ -92,91 +82,28 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
*/
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
// 再做一次数据处理
saveData();
logger.info("此次共保存{}条数据。", SAVE_COUNT);
// 在这里统一保存数据
insertIntoDb();
}
/**
* 存储数据
*/
private void saveData() {
List<KateOrders> kateOrdersList = new ArrayList<>();
Map<String, KateOrders> tempDoneMap = new HashMap<>();
for (KateOrdersExcelVo kateOrdersExcelVo : cachedDataList) {
// 查看当前List中是否有该工单
List<KateOrders> currentOrdersList = kateOrdersList.stream().filter(kateOrders ->
Objects.equals(kateOrders.getWorkOrder(), kateOrdersExcelVo.getWorkOrder())
&& Objects.equals(kateOrders.getGoodsId(), kateOrdersExcelVo.getGoodsId())
&& Objects.equals(kateOrders.getSupplyArea(), kateOrdersExcelVo.getSupplyArea())
).toList();
if (!currentOrdersList.isEmpty()) {
KateOrders currentOrder = currentOrdersList.get(0);
String key = kateOrdersExcelVo.getWorkOrder() + kateOrdersExcelVo.getGoodsId() + kateOrdersExcelVo.getSupplyArea();
if (newKateOrdersMap.containsKey(key)) {
KateOrders currentOrder = newKateOrdersMap.get(key);
// 设定数量
currentOrder.setRequirementQuantity(currentOrder.getRequirementQuantity().add(kateOrdersExcelVo.getRequirementQuantity()));
currentOrder.setLackQuantity(currentOrder.getLackQuantity().add(kateOrdersExcelVo.getRequirementQuantity()));
// 先移除
kateOrdersList.removeIf(kateOrders ->
Objects.equals(kateOrders.getWorkOrder(), kateOrdersExcelVo.getWorkOrder())
&& Objects.equals(kateOrders.getGoodsId(), kateOrdersExcelVo.getGoodsId())
&& Objects.equals(kateOrders.getSupplyArea(), kateOrdersExcelVo.getSupplyArea()));
// 再添加
kateOrdersList.add(currentOrder);
newKateOrdersMap.replace(key, currentOrder);
continue;
}
// 查询数据库是否存在重复数据
KateOrders existsKateOrder = null;
String key = kateOrdersExcelVo.getWorkOrder() + kateOrdersExcelVo.getGoodsId() + kateOrdersExcelVo.getSupplyArea();
if (LAST_SHOT_INDEX > 0) {
if (doneMap.get(LAST_SHOT_INDEX).containsKey(key)) {
existsKateOrder = doneMap.get(LAST_SHOT_INDEX).get(key);
System.out.println("命中");
}
} else {
for (Integer keyIndex : doneMap.keySet()) {
if (doneMap.get(keyIndex).containsKey(key)) {
LAST_SHOT_INDEX = keyIndex;
existsKateOrder = doneMap.get(keyIndex).get(key);
System.out.println("命中");
break;
}
}
}
if (existsKateOrder != null) {
// 数据重复
existsKateOrder.setRequirementQuantity(existsKateOrder.getRequirementQuantity().add(kateOrdersExcelVo.getRequirementQuantity()));
existsKateOrder.setLackQuantity(existsKateOrder.getLackQuantity().add(kateOrdersExcelVo.getRequirementQuantity()));
kateOrdersList.add(existsKateOrder);
continue;
}
List<KateOrdersLast> kateOrdersLastList = this.kateOrdersLastList.stream().filter(kateOrdersLast ->
Objects.equals(kateOrdersExcelVo.getWorkOrder(), kateOrdersLast.getWorkOrder())
&& Objects.equals(kateOrdersExcelVo.getGoodsId(), kateOrdersLast.getGoodsId())
&& Objects.equals(kateOrdersExcelVo.getSupplyArea(), kateOrdersLast.getSupplyArea())
).toList();
if (!kateOrdersLastList.isEmpty()) {
// 之前存在过
KateOrdersLast kateOrdersLast = kateOrdersLastList.get(0);
KateOrders oldKateOrders = new KateOrders();
oldKateOrders.setOrderId(kateOrdersLast.getOrderId());
oldKateOrders.setWorkOrder(kateOrdersExcelVo.getWorkOrder());
oldKateOrders.setGoodsId(kateOrdersExcelVo.getGoodsId());
oldKateOrders.setItem(kateOrdersExcelVo.getItem());
oldKateOrders.setDescription(kateOrdersExcelVo.getDescription());
oldKateOrders.setSLoc(kateOrdersExcelVo.getSLoc());
oldKateOrders.setType(kateOrdersExcelVo.getType());
oldKateOrders.setOriginStatus(kateOrdersExcelVo.getOriginStatus());
oldKateOrders.setSupplyArea(kateOrdersExcelVo.getSupplyArea());
oldKateOrders.setSortString(kateOrdersExcelVo.getSortString());
oldKateOrders.setRequirementQuantity(kateOrdersExcelVo.getRequirementQuantity());
oldKateOrders.setGoodsUnit(kateOrdersExcelVo.getGoodsUnit());
oldKateOrders.setOrderStatus(kateOrdersLast.getOrderStatus());
oldKateOrders.setLackQuantity(kateOrdersLast.getLackQuantity());
oldKateOrders.setPickedQuantity(kateOrdersLast.getPickedQuantity());
oldKateOrders.setFinishTime(kateOrdersLast.getFinishTime());
oldKateOrders.setUserName(uploadUser);
kateOrdersList.add(oldKateOrders);
tempDoneMap.put(kateOrdersExcelVo.getWorkOrder() + kateOrdersExcelVo.getGoodsId() + kateOrdersExcelVo.getSupplyArea(), oldKateOrders);
} else {
if (!oldKateOrdersMap.containsKey(key)) {
// 之前没存在过
KateOrders newKateOrders = new KateOrders();
newKateOrders.setOrderId(generateId("ORDER_"));
@ -195,12 +122,18 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
newKateOrders.setLackQuantity(kateOrdersExcelVo.getRequirementQuantity());
newKateOrders.setPickedQuantity(BigDecimal.ZERO);
newKateOrders.setUserName(uploadUser);
kateOrdersList.add(newKateOrders);
tempDoneMap.put(kateOrdersExcelVo.getWorkOrder() + kateOrdersExcelVo.getGoodsId() + kateOrdersExcelVo.getSupplyArea(), newKateOrders);
newKateOrdersMap.put(key, newKateOrders);
}
}
kateOrdersService.saveOrUpdateBatch(kateOrdersList);
SAVE_COUNT += kateOrdersList.size();
doneMap.put(MAP_INDEX++, tempDoneMap);
}
/**
* 保存数据库
*/
private void insertIntoDb() {
logger.info("此次共导入{}条数据。", newKateOrdersMap.size());
// 保存数据
kateOrdersService.saveOrUpdateBatch(newKateOrdersMap.values(), BATCH_COUNT);
logger.info("保存成功{}条数据。", newKateOrdersMap.size());
}
}

51
src/main/java/com/wms/utils/excel/listener/UploadStationConfigListener.java
View File

@ -14,7 +14,9 @@ import org.slf4j.LoggerFactory;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static com.wms.utils.WmsUtils.generateId;
@ -27,15 +29,14 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
* 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
*/
private static final int BATCH_COUNT = 100;
/**
* 保存数据总数
*/
private int SAVE_COUNT = 0;
private List<StationConfigExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
private final WorkStationConfigService workStationConfigService;// 工站配置服务
private final String uploadUser;// 用户
public UploadStationConfigListener(WorkStationConfigService workStationConfigService, String uploadUser) {
private final Map<String, WorkStationConfig> oldWorkStationConfigMap;// 旧配置
private final Map<String, WorkStationConfig> newWorkStationConfigMap = new HashMap<>();// 新配置
public UploadStationConfigListener(WorkStationConfigService workStationConfigService, Map<String, WorkStationConfig> oldWorkStationConfigMap, String uploadUser) {
this.workStationConfigService = workStationConfigService;
this.oldWorkStationConfigMap = oldWorkStationConfigMap;
this.uploadUser = uploadUser;
}
@ -59,9 +60,8 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
// 符合条件的数据
cachedDataList.add(stationConfigExcelVo);
}
// 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
// 达到BATCH_COUNT了
if (cachedDataList.size() >= BATCH_COUNT) {
logger.info("已经导入{}条数据，开始存储数据库！", cachedDataList.size());
saveData();
// 存储完成清理 list
cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
@ -75,8 +75,10 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
*/
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
// 再做一次数据处理
saveData();
logger.info("此次共保存{}条数据。", SAVE_COUNT);
// 在这里统一保存数据
insertIntoDb();
}
/**
@ -84,12 +86,10 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
*/
private void saveData() {
// 存储数据
List<WorkStationConfig> stationConfigList = new ArrayList<>();
for (StationConfigExcelVo stationConfigExcelVo : cachedDataList) {
WorkStationConfig oldConfig = workStationConfigService.getOne(new LambdaQueryWrapper<WorkStationConfig>()
.eq(WorkStationConfig::getSmallBox, stationConfigExcelVo.getSmallBox())
.last("limit 1"));
if (oldConfig != null) {
String key = stationConfigExcelVo.getSmallBox();
if (oldWorkStationConfigMap.containsKey(key)) {
WorkStationConfig oldConfig = oldWorkStationConfigMap.get(key);
oldConfig.setOrderQuantity(stationConfigExcelVo.getOrderQuantity());
oldConfig.setWorkStation(stationConfigExcelVo.getWorkStation());
oldConfig.setVehicle(stationConfigExcelVo.getVehicle());
@ -100,17 +100,24 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
oldConfig.setLastUpdateUser(uploadUser);
oldConfig.setModel(stationConfigExcelVo.getModel());
oldConfig.setBigBox(stationConfigExcelVo.getBigBox());
stationConfigList.add(oldConfig);
oldWorkStationConfigMap.replace(key, oldConfig);
} else {
WorkStationConfig stationConfig = BeanUtil.copyProperties(stationConfigExcelVo, WorkStationConfig.class);
stationConfig.setConfigId(generateId("STATION-CONFIG_"));
stationConfig.setLastUpdateTime(LocalDateTime.now());
stationConfig.setLastUpdateUser(uploadUser);
stationConfigList.add(stationConfig);
WorkStationConfig newStationConfig = BeanUtil.copyProperties(stationConfigExcelVo, WorkStationConfig.class);
newStationConfig.setConfigId(generateId("STATION-CONFIG_"));
newStationConfig.setLastUpdateTime(LocalDateTime.now());
newStationConfig.setLastUpdateUser(uploadUser);
oldWorkStationConfigMap.put(key, newStationConfig);
}
}
workStationConfigService.saveOrUpdateBatch(stationConfigList);
// 打印数量
SAVE_COUNT += stationConfigList.size();
}
/**
* 保存数据库
*/
private void insertIntoDb() {
logger.info("此次共导入{}条数据。", newWorkStationConfigMap.size());
// 保存数据
workStationConfigService.saveOrUpdateBatch(newWorkStationConfigMap.values(), BATCH_COUNT);
logger.info("保存成功{}条数据。", newWorkStationConfigMap.size());
}
}

1
src/main/java/com/wms/utils/excel/listener/UploadStocksListener.java
View File

@ -78,6 +78,7 @@ public class UploadStocksListener implements ReadListener<StockExcelVo> {
*/
private void saveData() {
List<Stock> stockList = new ArrayList<>();
// TODO 下个项目优化
for (StockExcelVo stockExcelVo : cachedDataList) {
Stock oldStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
.eq(Stock::getVehicleId, stockExcelVo.getVehicleId())