锁管理

aijinhui

2023-10-17 3beffd06aa145959811de597a69c3834d3abe8c8

 ard-work/src/main/java/com/ruoyi/alarm/global/service/impl/GlobalAlarmServiceImpl.java

@@ -1002,32 +1002,44 @@
                                ardAlarmRadarMove.setId(uuid);
                                ardAlarmRadarMove.setTargetId(targetId);
                                ardAlarmRadarMove.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setCreateTime(new Date());
                                ardAlarmRadarMove.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarMove.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarMove.setAlarmType("运动目标检测");
                                ardAlarmRadarMove.setLongitude(longitude);
                                ardAlarmRadarMove.setLatitude(latitude);
                                ardAlarmRadarMove.setUpdateTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setRadarId(radarId);
                                Date alarmTime = ardAlarmRadarMove.getAlarmTime();
                                //获取当前兴趣点当前雷达的上一条数据
                                ArdAlarmRadarMove lastMoveData = ardAlarmRadarMoveMapper.selectArdAlarmRadarLastData(ardAlarmRadarMove.getName());
                                if (lastMoveData == null) {
                                    //入库
                                    ardAlarmRadarMove.setGuideTime(alarmTime);
                                    ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                                    radarMoveGuide(ardAlarmRadarMove);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastMoveData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarMove.getAlarmTime();

                                    Date lastGuideTime = lastMoveData.getGuideTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarMove updateData = new ArdAlarmRadarMove();
                                        updateData.setId(lastMoveData.getId());
                                        updateData.setUpdateTime(alarmTime);

                                        //判断引导时间超过5分钟再次引导
                                        long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime,lastGuideTime);
                                        if(secDatePoorGuide>=300)
                                        {
                                            updateData.setGuideTime(alarmTime);
                                            radarMoveGuide(ardAlarmRadarMove);//引导
                                        }
                                        ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        ardAlarmRadarMove.setGuideTime(alarmTime);
                                        ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                                        radarMoveGuide(ardAlarmRadarMove);//引导
                                    }
@@ -1046,7 +1058,7 @@
                                ardAlarmRadarFire.setId(uuid);
                                ardAlarmRadarFire.setTargetId(targetId);
                                ardAlarmRadarFire.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarFire.setCreateTime(new Date());
                                ardAlarmRadarFire.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarFire.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarFire.setAlarmType("热源检测");
                                ardAlarmRadarFire.setLongitude(longitude);
@@ -1055,24 +1067,35 @@
                                ardAlarmRadarFire.setUpdateTime(radarAlarmData.getAlarmTime());
                                //
                                ArdAlarmRadarFire lastFireData = ardAlarmRadarFireMapper.selectArdAlarmRadarLastData(ardAlarmRadarFire.getName());
                                alarmTime = ardAlarmRadarFire.getAlarmTime();
                                if (lastFireData == null) {
                                    //入库

                                    ardAlarmRadarFire.setGuideTime(alarmTime);
                                    ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                    radarFireGuide(ardAlarmRadarFire);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastFireData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarFire.getAlarmTime();

                                    Date lastGuideTime = lastFireData.getGuideTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarFire updateData = new ArdAlarmRadarFire();
                                        updateData.setId(lastFireData.getId());
                                        updateData.setUpdateTime(alarmTime);

                                        //判断引导时间超过5分钟再次引导
                                        long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime,lastGuideTime);
                                        if(secDatePoorGuide>=300)
                                        {
                                            updateData.setGuideTime(alarmTime);
                                            radarFireGuide(ardAlarmRadarFire);//引导
                                        }
                                        ardAlarmRadarFireMapper.updateArdAlarmRadarFire(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        ardAlarmRadarFire.setGuideTime(alarmTime);
                                        ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                        radarFireGuide(ardAlarmRadarFire);//引导
                                    }
@@ -1084,10 +1107,11 @@
                                ardAlarmRadarPump.setId(uuid);
                                ardAlarmRadarPump.setTargetId(targetId);
                                ardAlarmRadarPump.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarPump.setCreateTime(new Date());
                                ardAlarmRadarPump.setCreateTime(DateUtils.covertTime(new Date()));
                                ardAlarmRadarPump.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
                                ardAlarmRadarPump.setUpdateTime(radarAlarmData.getAlarmTime());
                                alarmTime = ardAlarmRadarPump.getAlarmTime();
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                                if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                                    ardAlarmRadarPump.setLongitude(ardAlarmpointsWell.getLongitude());
@@ -1097,21 +1121,30 @@
                                ArdAlarmRadarPump lastPumpData = ardAlarmRadarPumpMapper.selectArdAlarmRadarLastData(ardAlarmRadarPump.getName());
                                if (lastPumpData == null) {
                                    //入库
                                    ardAlarmRadarPump.setGuideTime(alarmTime);
                                    ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                    radarPumpGuide(ardAlarmRadarPump);//引导
                                } else {
                                    //否则比对更新时间
                                    Date lastUpdateTime = lastPumpData.getUpdateTime();
                                    Date alarmTime = ardAlarmRadarPump.getAlarmTime();
                                    Date lastGuideTime = lastPumpData.getGuideTime();
                                    long secDatePoor = DateUtils.getSecDatePoor(alarmTime,lastUpdateTime);
                                    if (secDatePoor <= radarMergeTime) {
                                        //小于10秒的新数据，更新上一条
                                        ArdAlarmRadarPump updateData = new ArdAlarmRadarPump();
                                        updateData.setId(lastPumpData.getId());
                                        updateData.setUpdateTime(alarmTime);
                                        //判断引导时间超过5分钟再次引导
                                        long secDatePoorGuide = DateUtils.getSecDatePoor(alarmTime,lastGuideTime);
                                        if(secDatePoorGuide>=300)
                                        {
                                            radarPumpGuide(ardAlarmRadarPump);//引导
                                            updateData.setGuideTime(alarmTime);
                                        }
                                        ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(updateData);
                                    } else {
                                        //超过10秒的数据,入库
                                        ardAlarmRadarPump.setGuideTime(alarmTime);
                                        ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                        radarPumpGuide(ardAlarmRadarPump);//引导
                                    }
@@ -1347,7 +1380,7 @@
            //如果雷达塔上有光电
            messagesEnqueued(cameraIdWithTower, alarmId, alarmType, createTime, 1, 1, coordinate);
        } else {
            log.debug("未获取到雷达塔上的光电");
            log.debug("未获取到雷达塔上的光电,无法引导");
        }
        //获取报警点关联的大光电
        ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
@@ -1360,11 +1393,12 @@
            //如果报警点关联了光电
            messagesEnqueued(cameraId, alarmId, alarmType, createTime, 1, 2, coordinate);
        } else {
            log.debug("未获取到报警点关联的光电");
            log.debug("未获取到报警点关联的光电,无法引导");
        }
    }
    //雷达移动引导
    private void radarMoveGuide(ArdAlarmRadarMove ardAlarmRadarMove) {
        log.debug("雷达移动开始引导");
        if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
            log.debug("坐标为空不引导");
            return;
@@ -1375,6 +1409,7 @@
    }
    //雷达防火引导
    private void radarFireGuide(ArdAlarmRadarFire ardAlarmRadarFire) {
        log.debug("雷达防火开始引导");
        if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
            log.debug("坐标为空不引导");
            return;
@@ -1385,6 +1420,7 @@
    }
    //雷达抽油机停机引导
    private void radarPumpGuide(ArdAlarmRadarPump ardAlarmRadarPump) {
        log.debug("雷达抽油机停机开始引导");
        if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
            //坐标为空不引导
            log.debug("坐标为空不引导");
@@ -1393,166 +1429,6 @@
        double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
        //引导入队
        radarGuideToQueue(ardAlarmRadarPump.getId(), ardAlarmRadarPump.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);//更新
    }


    //每个点位未引导次数
    private Map<String, Integer> unGuideCountMapMove = new HashMap<>();
    private Map<String, Integer> unGuideCountMapFire = new HashMap<>();
    private Map<String, Integer> unGuideCountMapPump = new HashMap<>();
    private void radarMoveGuide(List<ArdAlarmRadarMove> ardAlarmRadarMoves, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarMoves = ardAlarmRadarMoves.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarMove::getName))), ArrayList::new));
        if (ardAlarmRadarMoves.size() > 0) {
            for (ArdAlarmRadarMove ardAlarmRadarMove : ardAlarmRadarMoves) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarMove alarmRadarMove = redisCache.getCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarMove == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarMove.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapMove.get(ardAlarmRadarMove.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarMove.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队

                            radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarMove.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarMove.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), count);
                }
                //更新
                ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(ardAlarmRadarMove);
            }
        }
        //endregion
    }
    private void radarFireGuide(List<ArdAlarmRadarFire> ardAlarmRadarFires, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarFires = ardAlarmRadarFires.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarFire::getName))), ArrayList::new));
        if (ardAlarmRadarFires.size() > 0) {
            for (ArdAlarmRadarFire ardAlarmRadarFire : ardAlarmRadarFires) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarFire alarmRadarFire = redisCache.getCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarFire == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarFire.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapFire.put(alarmRadarFire.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapFire.get(alarmRadarFire.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarFire.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarFire.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarFire.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapFire.put(ardAlarmRadarFire.getName(), count);
                }
                //更新
                ardAlarmRadarFireMapper.updateArdAlarmRadarFire(ardAlarmRadarFire);
            }
        }
        //endregion
    }
    private void radarPumpGuide(List<ArdAlarmRadarPump> ardAlarmRadarPumps, RadarAlarmData radarAlarmData) {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarPumps = ardAlarmRadarPumps.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarPump::getName))), ArrayList::new));
        if (ardAlarmRadarPumps.size() > 0) {
            for (ArdAlarmRadarPump ardAlarmRadarPump : ardAlarmRadarPumps) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarPump alarmRadarPump = redisCache.getCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarPump == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarPump.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapPump.put(alarmRadarPump.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapPump.get(ardAlarmRadarPump.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarPump.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarPump.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarPump.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapPump.put(ardAlarmRadarPump.getName(), count);
                }
                //更新
                ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(ardAlarmRadarPump);
            }
        }
        //endregion
    }

}