优化

‘liusuyi’

2024-03-14 650b127a6a671a87034db5e027379e740aa56364

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

@@ -1,9 +1,11 @@
package com.ruoyi.alarm.global.service.impl;

import com.alibaba.fastjson.JSON;
import com.ruoyi.alarm.access.domain.ArdAlarmAccess;
import com.ruoyi.alarm.access.service.IArdAlarmAccessService;
import com.ruoyi.alarm.external.domain.ArdAlarmExternal;
import com.ruoyi.alarm.external.service.IArdAlarmExternalService;
import com.ruoyi.alarm.global.domain.GuidePoint;
import com.ruoyi.alarm.global.domain.GuidePriorityQueue;
import com.ruoyi.alarm.global.domain.GuideTask;
import com.ruoyi.alarm.radar.domain.ArdAlarmRadarFire;
@@ -14,19 +16,28 @@
import com.ruoyi.alarm.radar.service.IArdAlarmRadarPumpService;
import com.ruoyi.alarm.tube.domain.ArdAlarmTube;
import com.ruoyi.alarm.tube.service.IArdAlarmTubeService;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.service.ICameraSdkService;
import com.ruoyi.utils.websocket.util.WebSocketUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.Duration;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

import static com.ruoyi.utils.websocket.util.WebSocketUtils.ONLINE_USER_SESSIONS;

/**
 * @Description: 队列处理器
@@ -37,6 +48,9 @@
@Slf4j(topic = "guideQueue")
@Component
public class QueueHandler {
    @Resource
    private RedisCache redisCache;

    /**
     * 引导任务入队
     * 刘苏义
@@ -46,34 +60,16 @@
        /*通过相机ID获取引导队列，并将引导任务加入队列*/
        PriorityBlockingQueue<GuideTask> guideTaskQueue = GuidePriorityQueue.cameraQueueMap.get(cameraId);
        if (StringUtils.isNull(guideTaskQueue)) {
            log.info("相机未登录,没有队列,无法入队引导");
            log.debug("相机未登录,没有队列,无法入队引导");
            return;
        }
        log.debug("新任务入队:" + task.getAlarmId());
        guideTaskQueue.add(task);
        /*获取该相机的当前执行线程-----弃用*/
        //TaskThread currentTaskThread = threadMap.get(cameraId);
        ////如果队列当前线程正在运行，若入队任务优先级大于当前任务优先级，则终止当前线程
        //if (currentTaskThread != null){
        //    if (task.getPriority() > currentTaskThread.getCurrentTask().getPriority()) {
        //        currentTaskThread.getThread().interrupt();
        //    }
        //    if (!currentTaskThread.getThread().isAlive()) {
        //        Thread newThread = createThread(cameraId, guideTaskQueue);
        //        threadMap.put(cameraId, new TaskThread(newThread, task));
        //        newThread.start();
        //    }
        //}
        ////如果队列当前没有线程正在运行，则启动新线程
        //else {
        //    Thread newThread = createThread(cameraId, guideTaskQueue);
        //    threadMap.put(cameraId, new TaskThread(newThread, task));
        //    newThread.start();
        //}
    }
    @Async

    @Async("guideExecutor")
    public void process(String cameraId) {
        log.debug("CameraId:【" + cameraId + "】队列处理器启动");
        log.debug("CameraId:【" + cameraId + "】引导队列处理器启动成功");
        PriorityBlockingQueue<GuideTask> guideTasks = GuidePriorityQueue.cameraQueueMap.get(cameraId);
        while (true) {
            if (guideTasks.size() > 0) {
@@ -86,7 +82,7 @@
                }
                log.debug("执行新任务:【" + newTask.getAlarmId() + "】");
                log.debug("剩余任务数:【" + guideTasks.size() + "】");
                // 异步处理任务，并获取Future
                // 处理任务
                processTask(newTask);
            }
            try {
@@ -96,38 +92,63 @@
            }
        }
    }

    //异步处理任务
    public void processTask(GuideTask guideTask) {
        try {
            String url="";
            if (!IsEnableGuide(guideTask.getCameraId())) {
                return;
            }
            String url = "";
            CameraCmd cmd = new CameraCmd();
            cmd.setCameraId(guideTask.getCameraId());
            cmd.setChanNo(guideTask.getChanNum());
            cmd.setTargetPosition(guideTask.getTargetPosition());
            cmd.setChanNo(guideTask.getChanNo());
            cmd.setOperator(guideTask.getAlarmType());
            cmd.setExpired(30);
            cmd.setRecordBucketName("record");
            Map<String, Double> ptzMap = new HashMap<>();
            ptzMap.put("p", guideTask.getGuidePTZ().getP());
            ptzMap.put("t", guideTask.getGuidePTZ().getT());
            ptzMap.put("z", guideTask.getGuidePTZ().getZ());
            cmd.setPtzMap(ptzMap);
            if (guideTask.getRecordSn().equals(1)) {
                cmd.setRecordObjectName("alarm_" + guideTask.getAlarmId() + "_1");
            } else {
                cmd.setRecordObjectName("alarm_" + guideTask.getAlarmId() + "_2");
            Map<String, Double> ptzMap=new HashMap<>();
            if(guideTask.getTargetPTZ()!=null) {
                if (guideTask.getChanNo() == 1) {
                    ptzMap.put("p", guideTask.getTargetPTZ().getP1());
                    ptzMap.put("t", guideTask.getTargetPTZ().getT1());
                    ptzMap.put("z", guideTask.getTargetPTZ().getZ1());
                }
                if (guideTask.getChanNo() == 2) {
                    ptzMap.put("p", guideTask.getTargetPTZ().getP2());
                    ptzMap.put("t", guideTask.getTargetPTZ().getT2());
                    ptzMap.put("z", guideTask.getTargetPTZ().getZ2());
                }
                cmd.setPtzMap(ptzMap);
            }
            cmd.setRecordBucketName("record");
            GuidePoint targetPosition = guideTask.getTargetPosition();
            cmd.setTargetPosition(new double[]{targetPosition.getLongitude(),targetPosition.getLatitude()});
            cmd.setRecordObjectName("alarmGuide/" + DateUtils.getDateYYYYMMDD() + "/" + guideTask.getAlarmType() + "/" + guideTask.getAlarmId());
            ICameraSdkService cameraSdkService = SpringUtils.getBean(ICameraSdkService.class);
            log.debug("开始引导");
            boolean guideRes = false;
            boolean recordFlag = false;
            if (cmd.getPtzMap().get("p") != null) {
                //p值存在 优先引导ptz
                guideRes = cameraSdkService.setPtz(cmd);
            boolean guideRes = false;
            if (guideTask.getIsGuidePTZ()) {
                AjaxResult result = cameraSdkService.setPtz(cmd);
                if (result.get("code").equals(200)) {
                    guideRes = true;
                }
            } else {
                guideRes = cameraSdkService.guideTargetPosition(cmd);
                AjaxResult result = cameraSdkService.guideTargetPosition(cmd);
                guideRes = result.get("code").equals(200);
            }
            if (guideRes) {
                log.debug("引导成功");
                //region 通知前端
                Map<String, Object> message = new HashMap<>();
                Map<String, String> data = new HashMap<>();
                data.put("cameraId", cmd.getCameraId());
                data.put("chanNo", cmd.getChanNo().toString());
                data.put("alarmType", cmd.getOperator());
                data.put("alarmId", guideTask.getAlarmId());
                data.put("wellId", guideTask.getWellId());
                message.put("70000", data);
                WebSocketUtils.sendMessageAll(message);
                //endregion
                cameraSdkService.controlLock(cmd);//上锁
                cameraSdkService.recordStart(cmd);//开始录像
                recordFlag = true;
@@ -137,8 +158,11 @@
                    Instant currentTime = Instant.now();
                    long elapsedSeconds = Duration.between(startTime, currentTime).getSeconds();
                    if (elapsedSeconds >= 30) {
                        recordFlag = false;
                        recordFlag = false;//达到30秒录像停止
                        url = cameraSdkService.recordStopToMinio(cmd);//停止录像返回url
                    }
                    if (!IsEnableGuide(guideTask.getCameraId())) {
                        recordFlag = false;//相机关闭引导录像停止
                    }
                    //判断队列中第一条数据的优先级是否大于当前数据的优先级
                    PriorityBlockingQueue<GuideTask> guideTasks = GuidePriorityQueue.cameraQueueMap.get(guideTask.getCameraId());
@@ -146,7 +170,6 @@
                        GuideTask firstTask = guideTasks.peek();
                        if (firstTask.getPriority() > guideTask.getPriority()) {
                            recordFlag = false;//录像停止
                            break;
                        }
                    }
                }
@@ -162,33 +185,21 @@
                        case "sys_radar_move":
                            ArdAlarmRadarMove ardAlarmRadarMove = new ArdAlarmRadarMove();
                            ardAlarmRadarMove.setId(guideTask.getAlarmId());
                            if (guideTask.getRecordSn().equals(1)) {
                                ardAlarmRadarMove.setRecordUrl1(url);
                            } else {
                                ardAlarmRadarMove.setRecordUrl2(url);
                            }
                            ardAlarmRadarMove.setRecordUrl(url);
                            IArdAlarmRadarMoveService ardAlarmRadarMoveService = SpringUtils.getBean(IArdAlarmRadarMoveService.class);
                            ardAlarmRadarMoveService.updateArdAlarmRadarMove(ardAlarmRadarMove);
                            break;
                        case "sys_radar_fire":
                            ArdAlarmRadarFire ardAlarmRadarFire = new ArdAlarmRadarFire();
                            ardAlarmRadarFire.setId(guideTask.getAlarmId());
                            if (guideTask.getRecordSn().equals(1)) {
                                ardAlarmRadarFire.setRecordUrl1(url);
                            } else {
                                ardAlarmRadarFire.setRecordUrl2(url);
                            }
                            ardAlarmRadarFire.setRecordUrl(url);
                            IArdAlarmRadarFireService ardAlarmRadarFireService = SpringUtils.getBean(IArdAlarmRadarFireService.class);
                            ardAlarmRadarFireService.updateArdAlarmRadarFire(ardAlarmRadarFire);
                            break;
                        case "sys_radar_pump":
                            ArdAlarmRadarPump ardAlarmRadarPump = new ArdAlarmRadarPump();
                            ardAlarmRadarPump.setId(guideTask.getAlarmId());
                            if (guideTask.getRecordSn().equals(1)) {
                                ardAlarmRadarPump.setRecordUrl1(url);
                            } else {
                                ardAlarmRadarPump.setRecordUrl2(url);
                            }
                            ardAlarmRadarPump.setRecordUrl(url);
                            IArdAlarmRadarPumpService ardAlarmRadarPumpService = SpringUtils.getBean(IArdAlarmRadarPumpService.class);
                            ardAlarmRadarPumpService.updateArdAlarmRadarPump(ardAlarmRadarPump);
                            break;
@@ -213,4 +224,20 @@
            log.info("线程任务异常:" + ex.getMessage());
        }
    }
}

    /**
     * 光电是否开启报警引导功能
     * 刘苏义
     * 2023/7/7 14:03
     */
    private Boolean IsEnableGuide(String cameraId) {
        boolean enabled = false;
        ArdCameras ardCameras = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
        if (ardCameras != null) {
            if (ardCameras.getCamAlarmGuideEnable().equals(1)) {
                enabled = true;
            }
        }
        return enabled;
    }
}