版本整合

zhoushihao

2024-10-16 adbeaabf30a5bbef970e287da5e317a1e89a8033

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/CacheGlassTask.java

@@ -6,10 +6,13 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.query.MPJQueryWrapper;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
@@ -34,6 +37,7 @@
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author : zhoush
@@ -58,6 +62,8 @@

    @Autowired
    WebSocketServer webServerService;
    @Autowired
    DamageService damageService;

    @Value("${mes.threshold}")
    private int threshold;
@@ -88,7 +94,7 @@

    public static String engineerId = "";

    @Scheduled(fixedDelay = 1000)
    //@Scheduled(fixedDelay = 1000)
    public void plcHomeEdgTask() {
        Date startDate = new Date();
        log.info("本次任务开始执行时间：{}", startDate);
@@ -118,8 +124,9 @@
            log.info("2、获取到的请求字不为0，将确认字不为0，直接结束");
            return;
        }
        if ("1".equals(taskRequestTypeValue)) {
            log.info("2、进片请求，且确认字为0，执行进片任务");
        boolean result = edgStorageCageDetailsService.inToVerify(glassIdeValue);
        if ("1".equals(taskRequestTypeValue) && result) {
            log.info("2、进片请求，且确认字为0，执行进片任务,扫码重复ID验证【有重复=false,无重复=true】：{}", result);
            inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
        } else if ("2".equals(taskRequestTypeValue)) {
            //09空闲 ：1      10空闲 ：2        都空闲：3    其他0
@@ -131,8 +138,8 @@
            //加笼子里面是否有玻璃，有先出，无玻璃先进
            boolean outFlase = outTo(Integer.parseInt(out08Glassstate),
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, glassIdeValue, Integer.parseInt(currentSlot));
            log.info("出片任务是否完成：{},失败且玻璃id:{}不为空则执行进片任务", outFlase, glassIdeValue);
            if (!outFlase && StringUtils.isNotBlank(glassIdeValue)) {
            log.info("出片任务是否完成：{},且玻璃id:{}不为空则执行进片任务,扫码重复ID验证【有重复=false,无重复=true】：{}", outFlase, glassIdeValue, result);
            if (!outFlase && StringUtils.isNotBlank(glassIdeValue) && result) {
                inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
            }
        }
@@ -140,23 +147,36 @@
        log.info("本次任务结束时间：{}，共耗时：{}ms", endDate, endDate.getTime() - startDate.getTime());
    }


    @Scheduled(fixedDelay = 1000)
    public void temperingIsRun() {
        JSONObject jsonObject = new JSONObject();
        //正在进行的任务
        List<TaskCache> taskCaches = taskCacheService.selectTaskCacheIsRun();
        jsonObject.append("taskCaches", taskCaches);
        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("isRun");
        if (sendwServer != null) {
            for (WebSocketServer webserver : sendwServer) {
                if (webserver != null) {
                    webserver.sendMessage(jsonObject.toString());
                } else {
                    log.info("Home is closed");
                }
            }
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("卧式理片破损玻璃清除任务开始执行时间：{}", startDate);
        List<TaskCache> taskCacheList = taskCacheService.list(new LambdaQueryWrapper<TaskCache>().in(TaskCache::getTaskStatus, Const.GLASS_STATE_DAMAGE_TAKE)
                .in(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT_ALL));
        if (CollectionUtils.isNotEmpty(taskCacheList)) {
            //获取破损/拿走玻璃id
            List<String> glassList = taskCacheList.stream().map(TaskCache::getGlassId).collect(Collectors.toList());
            //将磨边队列的数据删除
            edgGlassTaskInfoService.remove(new LambdaQueryWrapper<EdgGlassTaskInfo>().in(EdgGlassTaskInfo::getGlassId, glassList));
            //将任务表中的数据删除
            taskCacheService.remove(new LambdaQueryWrapper<TaskCache>().in(TaskCache::getGlassId, glassList).in(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT_ALL));
            List<Damage> damageList = taskCacheList.stream().map(e -> {
                Damage damage = new Damage();
                damage.setGlassId(e.getGlassId());
                damage.setLine(e.getEndCell());
                damage.setWorkingProcedure("冷加工");
                damage.setRemark("磨边前卧式理片");
                damage.setStatus(0);
                damage.setType(e.getTaskStatus());
                return damage;
            }).collect(Collectors.toList());
            damageService.batchInsertDamage(damageList);
        }
        Date endDate = new Date();
        log.info("本次任务结束时间：{}，共耗时：{}ms", endDate, endDate.getTime() - startDate.getTime());
    }


    /**
     * 进片任务
@@ -172,9 +192,13 @@
        Assert.isTrue(null != nearestEmpty, "格子已满");
        log.info("2、查询卧式理片笼里面的空格:{}", nearestEmpty);

        //查询玻璃并进行交换
        GlassInfo glassInfo = queryAndChangeGlass(glassId);
        //查询玻璃信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        if (glassInfo == null) {
            return;
        }
        if ((glassInfo.getWidth() < Double.parseDouble(minTwoFirstLength) && glassInfo.getHeight() < Double.parseDouble(minTwoSecondLength)) || (glassInfo.getWidth() < Double.parseDouble(minTwoSecondLength) && glassInfo.getHeight() < Double.parseDouble(minTwoFirstLength))) {
            log.info("3、玻璃信息不符合进入理片笼最小尺寸，玻璃信息为{}", glassInfo);
            return;
        }
        log.info("4、将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
@@ -192,7 +216,6 @@
        S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
        log.info("7、发送确认字完成");


    }

    /**
@@ -201,15 +224,10 @@
     * @param glassId
     * @return
     */
    public GlassInfo queryAndChangeGlass(String glassId) {
    public String queryAndChangeGlass(String glassId) {
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
//                .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1"));
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");
        if ((glassInfo.getWidth() < Double.parseDouble(minTwoFirstLength) && glassInfo.getHeight() < Double.parseDouble(minTwoSecondLength)) || (glassInfo.getWidth() < Double.parseDouble(minTwoSecondLength) && glassInfo.getHeight() < Double.parseDouble(minTwoFirstLength))) {
            log.info("3、玻璃信息不符合进入理片笼最小尺寸，玻璃信息为{}", glassInfo);
            return null;
        }
        //按照玻璃尺寸
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");        //按照玻璃尺寸
        LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getWidth, glassInfo.getWidth())
                .eq(GlassInfo::getHeight, glassInfo.getHeight())
@@ -231,9 +249,41 @@
            glassInfo.setGlassId(swapGlassId);
            glassInfoService.updateById(swapGlassInfo);
            glassInfoService.updateById(glassInfo);
            return swapGlassInfo;
            return swapGlassId;
        }
        return glassInfo;
        return "";
    }


    /**
     * 查询卧式理片玻璃并进行交换
     *
     * @param glassId
     * @return
     */
    public void queryEdgAndChangeGlass(String glassId, String swapGlassId) {
        if (StringUtils.isBlank(swapGlassId)) {
            log.info("当前出笼玻璃不存在需要替换的玻璃");
            return;
        }
        //获取待出笼的玻璃
        EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
//        获取待出笼的玻璃需要替换的玻璃信息
        EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
//      玻璃小片表中玻璃已经替换，更新卧理笼内现有的准备出笼的玻璃信息，
        if (null == swapGlassDetailInfo) {
            //需要替换的玻璃为存进卧理，仅需更新当前需要出笼的玻璃信息即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getGlassId, glassId).set(EdgStorageCageDetails::getGlassId, swapGlassId));
        } else {
            //需要替换的玻璃都在卧理内，按照玻璃id对调玻璃信息：对调玻璃id即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, glassInfo.getId()).set(EdgStorageCageDetails::getGlassId, swapGlassId));
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId()).set(EdgStorageCageDetails::getGlassId, glassId));
        }
    }

    /**
@@ -538,7 +588,7 @@
        if (endcell == Const.A10_OUT_TARGET_POSITION) {
            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                    "on t.glass_id = t1.glass_id and (t1.first_length >= " + minOneFirstLength + " and t1.second_length >= " + minOneSecondLength);
                    "on t.glass_id = t1.glass_id and (t1.first_length >= " + minOneFirstLength + " and t1.second_length >= " + minOneSecondLength + ")");
        } else {
            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
@@ -618,7 +668,6 @@
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
@@ -635,6 +684,159 @@
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
            log.info("8、发送确认字已完成");
            Damage damage = new Damage();
            damage.setGlassId(glassInfo.getGlassId());
            damage.setWorkingProcedure("切割");
            damage.setLine(1001);
            damage.setType(1);
            damage.setRemark("过卧式理片");
            damageService.insertDamage(damage);
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 保存出片任务相关信息
     *
     * @param glassInfo
     * @param endcell
     * @param confirmationWrodAddress
     * @param glassId
     * @return
     */
    private boolean saveOutGlassMessageBySlot(EdgStorageCageDetails glassInfo, int endcell, String confirmationWrodAddress, String glassId, Integer currentSlot) {
        if (glassInfo != null) {
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
            if (glassInfo.getGlassId().equals(glassId)) {
                log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                EdgStorageCageDetails details = new EdgStorageCageDetails();
                //玻璃信息替换
                String glassIdChange = queryAndChangeGlass(glassId);
                if (StringUtils.isBlank(glassIdChange)) {
                    BeanUtils.copyProperties(glassInfo, details);
                } else {
                    GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
                    BeanUtils.copyProperties(glassInfo, details);
                }
                EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(currentSlot, Boolean.TRUE);
                Assert.isTrue(null != nearestEmpty, "格子已满,无法执行直通任务");
                log.info("3、查询卧式理片笼里面的空格:{}", nearestEmpty);
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);
                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
                log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                if (endcell != currentSlot) {
                    EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                            .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(EdgStorageCageDetails::getSlot, currentSlot).eq(EdgStorageCageDetails::getWidth, glassInfo.getWidth())
                            .eq(EdgStorageCageDetails::getHeight, glassInfo.getHeight()).eq(EdgStorageCageDetails::getThickness, glassInfo.getThickness())
                    );
                    if (null != currentGlass) {
                        glassInfo = currentGlass;
                        endcell = currentSlot;
                    }
                }
                //玻璃信息替换
                String glassIdChange = queryAndChangeGlass(glassInfo.getGlassId());
                //处理在卧理内的玻璃信息：笼内的数据处理
                queryEdgAndChangeGlass(glassInfo.getGlassId(), glassIdChange);
                LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>();
                wrapper.eq(EdgStorageCageDetails::getGlassId, glassInfo.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.update(wrapper);
                log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), glassInfo.getSlot(), endcell, Const.GLASS_CACHE_TYPE_OUT);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            }
            boolean glassSizeStatus = saveGlassSize(glassInfo, endcell);
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
            log.info("8、发送确认字已完成");
            Damage damage = new Damage();
            damage.setGlassId(glassInfo.getGlassId());
            damage.setWorkingProcedure("切割");
            damage.setLine(1001);
            damage.setType(1);
            damage.setRemark("过卧式理片");
            damageService.insertDamage(damage);
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 保存出片任务相关信息
     *
     * @param glassInfo
     * @param endcell
     * @param confirmationWrodAddress
     * @param glassId
     * @return
     */
    private boolean saveOutGlassMessageBySlot(EdgStorageCageDetails glassInfo, int endcell, String confirmationWrodAddress, String glassId, Integer currentSlot) {
        if (glassInfo != null) {
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
            if (glassInfo.getGlassId().equals(glassId)) {
                log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                EdgStorageCageDetails details = new EdgStorageCageDetails();
                //玻璃信息替换
                String glassIdChange = queryAndChangeGlass(glassId);
                if (StringUtils.isBlank(glassIdChange)) {
                    BeanUtils.copyProperties(glassInfo, details);
                } else {
                    GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
                    BeanUtils.copyProperties(glassInfo, details);
                }
                EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(currentSlot, Boolean.TRUE);
                Assert.isTrue(null != nearestEmpty, "格子已满,无法执行直通任务");
                log.info("3、查询卧式理片笼里面的空格:{}", nearestEmpty);
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);
                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
                log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                if (endcell != currentSlot) {
                    EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                            .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(EdgStorageCageDetails::getSlot, currentSlot).eq(EdgStorageCageDetails::getWidth, glassInfo.getWidth())
                            .eq(EdgStorageCageDetails::getHeight, glassInfo.getHeight()).eq(EdgStorageCageDetails::getThickness, glassInfo.getThickness())
                    );
                    if (null != currentGlass) {
                        glassInfo = currentGlass;
                        endcell = currentSlot;
                    }
                }
                //玻璃信息替换
                String glassIdChange = queryAndChangeGlass(glassInfo.getGlassId());
                //处理在卧理内的玻璃信息：笼内的数据处理
                queryEdgAndChangeGlass(glassInfo.getGlassId(), glassIdChange);
                LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>();
                wrapper.eq(EdgStorageCageDetails::getGlassId, glassInfo.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.update(wrapper);
                log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), glassInfo.getSlot(), endcell, Const.GLASS_CACHE_TYPE_OUT);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            }
            boolean glassSizeStatus = saveGlassSize(glassInfo, endcell);
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
            log.info("8、发送确认字已完成");
            Damage damage = new Damage();
            damage.setGlassId(glassInfo.getGlassId());
            damage.setWorkingProcedure("切割");
            damage.setLine(1001);
            damage.setType(1);
            damage.setRemark("过卧式理片");
            damageService.insertDamage(damage);
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
@@ -661,7 +863,7 @@
    }

    /**
     * 添加理片笼任务
     * 添加磨边队列信息
     *
     * @param glassInfo
     * @param endcell
@@ -707,22 +909,8 @@
    public void CacheGlassTasks() {
        JSONObject jsonObject = new JSONObject();
        List<Map<String, Object>> currentCutTerritorys = edgStorageCageDetailsService.selectCutTerritory();
//        List<Map<String, Object>> currentCutTerritorys=new ArrayList<>();
//        if(engineerId==null||engineerId.isEmpty()){
//            //识别摆片 当前版图数据
//            currentCutTerritorys = edgStorageCageDetailsService.selectCutTerritory();
//        }else{
//            //识别摆片 此engineerId 工程版图数据
//            currentCutTerritorys = edgStorageCageDetailsService.selectCurrentCutTerritory(engineerId);
//        }
        jsonObject.append("currentCutTerritory", currentCutTerritorys);
        //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);
        //磨边信息
        List<Map<String, Object>> EdgTasks1 = taskCacheService.selectEdgInfo("2001");
        List<Map<String, Object>> EdgTasks2 = taskCacheService.selectEdgInfo("2002");
        jsonObject.append("EdgTasks1", EdgTasks1);
        jsonObject.append("EdgTasks2", EdgTasks2);

        //卧室缓存笼内信息
        List<Map<String, Object>> EdgStorageCageinfos = edgStorageCageService.selectEdgStorageCages();
        jsonObject.append("EdgStorageCageinfos", EdgStorageCageinfos);
@@ -743,11 +931,12 @@
            }
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void cacheGlassIsRun(){
    public void cacheGlassIsRun() {
        JSONObject jsonObject = new JSONObject();
        //正在进行的任务
        List<TaskCache>taskCaches=taskCacheService.selectTaskCacheIsRun();
        List<EdgGlassTaskInfo> taskCaches = edgGlassTaskInfoService.selectTaskCacheIsRun();
        jsonObject.append("taskCaches", taskCaches);
        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("cacheGlassIsRun");
        if (sendwServer != null) {
@@ -761,4 +950,28 @@
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void CacheGlassTaskss() {
        JSONObject jsonObject = new JSONObject();
        //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);
        //磨边信息
        List<EdgGlassTaskInfo> edgTasks = edgGlassTaskInfoService.selectEdgInfo();
        jsonObject.append("edgTasks", edgTasks);

        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("edgTasks");
        if (sendwServer != null) {
            for (WebSocketServer webserver : sendwServer) {
                if (webserver != null) {
                    webserver.sendMessage(jsonObject.toString());
                    List<String> messages = webserver.getMessages();
                    if (!messages.isEmpty()) {
                        // // 将最后一个消息转换为整数类型的列表
                        webserver.clearMessages();
                    }
                } else {
                    log.info("edgTasks is closed");
                }
            }
        }
    }
}