优化遥测、信道治理、状态 websocket

liusuyi

2025-03-11 de7cddcd9a5597ac281fbd619f4f0bba09772386

优化遥测、信道治理、状态 websocket

 ard-work/src/main/java/com/ard/tianyu/websocket/domain/UavSignalMessage.java

New file
@@ -0,0 +1,36 @@
package com.ard.tianyu.websocket.domain;

import com.ard.tianyu.domain.dto.signal.SignalInfo;
import com.ard.tianyu.domain.dto.telemetry.TelemetryData;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Description: 无人机信号质量消息
 * Author: liusuyi
 * Date: 2025年03月10日11:49
 **/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UavSignalMessage {

    /**
     * 盒子编号
     */
    private String boxSn;

    /**
     * 无人机信号质量
     */
    private SignalInfo signalInfo;

    /**
     * 是否订阅
     */
    private Boolean subscribe;

}

 ard-work/src/main/java/com/ard/tianyu/websocket/domain/UavTelemetryMessage.java

New file
@@ -0,0 +1,35 @@
package com.ard.tianyu.websocket.domain;

import com.ard.tianyu.domain.dto.telemetry.TelemetryData;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Description: 无人机遥测消息
 * Author: liusuyi
 * Date: 2025年03月10日11:49
 **/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UavTelemetryMessage {

    /**
     * 盒子编号
     */
    private String boxSn;

    /**
     * 无人机遥测数据
     */
    private TelemetryData telemetryData;

    /**
     * 是否订阅
     */
    private Boolean subscribe;

}

 ard-work/src/main/java/com/ard/tianyu/websocket/handler/BaseSubscriptionManager.java

New file
@@ -0,0 +1,111 @@
package com.ard.tianyu.websocket.handler;

import com.alibaba.fastjson2.JSON;
import com.ard.tianyu.websocket.domain.BaseMessage;
import com.ard.tianyu.websocket.utils.WebSocketUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.*;

@Slf4j
public abstract class BaseSubscriptionManager<T> {

    // 存储订阅的用户
    protected final Map<String, Set<Long>> subscriptions = new ConcurrentHashMap<>();
    // 定时任务调度器
    protected final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    // 存储推送任务
    protected final Map<String, ScheduledFuture<?>> pushTasks = new ConcurrentHashMap<>();

    /**
     * 订阅指定设备的数据
     */
    public void subscribe(String boxSn, Long userId) {
        subscriptions.computeIfAbsent(boxSn, k -> new HashSet<>()).add(userId);
        if (subscriptions.get(boxSn).size() == 1) {
            startPushTask(boxSn);
        }
    }

    /**
     * 取消订阅
     */
    public void unsubscribe(String boxSn, Long userId) {
        Set<Long> userIds = subscriptions.get(boxSn);
        if (userIds != null) {
            userIds.remove(userId);
            if (userIds.isEmpty()) {
                stopPushTask(boxSn);
            }
        }
    }

    /**
     * 启动推送任务
     */
    private void startPushTask(String boxSn) {
        // 如果已经存在任务，则不再创建
        if (pushTasks.containsKey(boxSn)) {
            return;
        }
        ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(() -> {
            sendDataToSubscribers(boxSn);
        }, 0, 2, TimeUnit.SECONDS);

        pushTasks.put(boxSn, future);
    }

    /**
     * 停止推送任务
     */
    private void stopPushTask(String boxSn) {
        ScheduledFuture<?> future = pushTasks.get(boxSn);
        if (future != null) {
            future.cancel(false);
        }
        pushTasks.remove(boxSn);
    }

    /**
     * 移除用户订阅
     */
    public void removeSubscribe(Long userId) {
        for (Set<Long> userIds : subscriptions.values()) {
            userIds.remove(userId);
        }
    }



    /**
     * 向订阅者发送数据
     */
    private void sendDataToSubscribers(String boxSn) {
        T data = getData(boxSn);
        BaseMessage<T> baseMessage = new BaseMessage<>(getMessageType(), data);
        Set<Long> userIds = subscriptions.get(boxSn);
        if (userIds != null) {
            for (Long userId : userIds) {
                try {
                    log.warn("给用户{}定时推送",userId);
                    WebSocketUtil.sendMessage(userId, JSON.toJSONString(baseMessage));
                } catch (Exception e) {
                    log.error("Error sending message to session {}", userId, e);
                }
            }
        }
    }

    /**
     * 获取数据的具体实现
     */
    protected abstract T getData(String boxSn);

    /**
     * 获取消息类型
     */
    protected abstract String getMessageType();
}

 ard-work/src/main/java/com/ard/tianyu/websocket/handler/TyMessageHandler.java

@@ -3,9 +3,7 @@
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.ard.tianyu.service.control.UavControlService;
import com.ard.tianyu.websocket.domain.BaseMessage;
import com.ard.tianyu.websocket.domain.UavStreamMessage;
import com.ard.tianyu.websocket.domain.UavStateMessage;
import com.ard.tianyu.websocket.domain.*;
import com.ard.tianyu.websocket.utils.WebSocketUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@@ -13,6 +11,7 @@
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import javax.annotation.Resource;


@@ -26,7 +25,10 @@
    private UavControlService uavControlService;
    @Resource
    private UavStateManager uavStateManager;

    @Resource
    private UavTelemetryManager uavTelemetryManager;
    @Resource
    private UavSignalManager uavSignalManager;

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
@@ -43,6 +45,12 @@
                break;
            case "state":
                handleStateMessage(payload, userId);
                break;
            case "telemetry":
                handleTelemetryMessage(payload, userId);
                break;
            case "signal":
                handleSignalMessage(payload, userId);
                break;
        }
    }
@@ -68,9 +76,9 @@

            // 根据Subscribe决定操作类型：true表示开始拉流，false表示停止拉流
            if (uavStreamMessage.getSubscribe()) {
                uavStreamManager.startPullStream(boxSn, userId);
                uavStreamManager.subscribe(boxSn, userId);
            } else {
                uavStreamManager.stopPullStream(boxSn, userId);
                uavStreamManager.unsubscribe(boxSn, userId);
            }
        }
    }
@@ -98,15 +106,75 @@
            Boolean subscribe = uavStateMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavStateManager.subscribeState(boxSn, userId);
                uavStateManager.subscribe(boxSn, userId);
            } else {
                // 执行退订操作
                uavStateManager.unsubscribeState(boxSn, userId);
                uavStateManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理遥测消息
     * 根据接收到的消息内容，决定无人机状态信息的订阅或退订
     *
     * @param payload 消息负载，包含订阅信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleTelemetryMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavTelemetryMessage> telemetryMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavTelemetryMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavTelemetryMessage uavTelemetryMessage = telemetryMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavTelemetryMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavTelemetryMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavTelemetryMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavTelemetryManager.subscribe(boxSn, userId);
            } else {
                // 执行退订操作
                uavTelemetryManager.unsubscribe(boxSn, userId);
            }
        }
    }

    /**
     * 处理信号质量
     * 根据接收到的消息内容，决定无人机信号质量信息的订阅或退订
     *
     * @param payload 消息负载，包含订阅信息
     * @param userId  用户ID，用于标识用户
     */
    private void handleSignalMessage(String payload, Long userId) {
        // 解析接收到的JSON消息，将其转换为BaseMessage对象
        BaseMessage<UavSignalMessage> signalMessage = JSON.parseObject(payload,
                new TypeReference<BaseMessage<UavSignalMessage>>() {
                });
        // 获取消息的有效载荷部分
        UavSignalMessage uavSignalMessage = signalMessage.getPayload();

        // 检查有效载荷是否存在
        if (uavSignalMessage != null) {
            // 获取无人机盒子的序列号
            String boxSn = uavSignalMessage.getBoxSn();
            // 根据消息中的订阅标志，决定是订阅还是退订无人机状态
            Boolean subscribe = uavSignalMessage.getSubscribe();
            if (subscribe) {
                // 执行订阅操作
                uavSignalManager.subscribe(boxSn, userId);
            } else {
                // 执行退订操作
                uavSignalManager.unsubscribe(boxSn, userId);
            }
        }
    }
    @Override
    public void afterConnectionEstablished(WebSocketSession session) {
        log.info("【cmd】Connected: {}", session.getId());
@@ -130,6 +198,8 @@
            uavControlService.releaseAllControls(userId);
        }

        uavStateManager.removeSubscribeState(userId);
        uavStateManager.removeSubscribe(userId);
        uavTelemetryManager.removeSubscribe(userId);
        uavSignalManager.removeSubscribe(userId);
    }
}

 ard-work/src/main/java/com/ard/tianyu/websocket/handler/UavSignalManager.java

New file
@@ -0,0 +1,23 @@
package com.ard.tianyu.websocket.handler;

import com.ard.tianyu.domain.cache.UavSignalInfoCache;
import com.ard.tianyu.domain.cache.UavStateCache;
import com.ard.tianyu.domain.dto.signal.SignalInfo;
import com.ard.tianyu.domain.dto.state.UavState;
import org.springframework.stereotype.Component;


@Component
public class UavSignalManager extends BaseSubscriptionManager<SignalInfo> {

    @Override
    protected SignalInfo getData(String boxSn) {
        return UavSignalInfoCache.getUavSignalInfo(boxSn);
    }

    @Override
    protected String getMessageType() {
        return "signal";
    }

}

 ard-work/src/main/java/com/ard/tianyu/websocket/handler/UavStateManager.java

@@ -1,158 +1,21 @@
package com.ard.tianyu.websocket.handler;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.ard.tianyu.domain.cache.UavStateCache;
import com.ard.tianyu.domain.dto.state.UavState;
import com.ard.tianyu.websocket.domain.BaseMessage;
import com.ard.tianyu.websocket.utils.WebSocketUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.*;

/**
 * Description: 无人机状态管理
 * Author: liusuyi
 * Date: 2025年03月10日11:54
 **/
@Slf4j
@Component
public class UavStateManager {
public class UavStateManager extends BaseSubscriptionManager<UavState> {

    // 存储状态订阅的用户
    private static final Map<String, Set<Long>> stateSubscriptions = new ConcurrentHashMap<>();
    // 定时任务调度器
    private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    // 存储状态推送任务
    private static final Map<String, ScheduledFuture<?>> statePushTasks = new ConcurrentHashMap<>();


    /**
     * 订阅指定设备的状态
     * 当用户需要接收特定设备的状态更新时调用此方法
     * 如果这是第一次订阅该设备，此方法还将启动一个定时任务来推送设备状态
     *
     * @param boxSn  设备的序列号，用于唯一标识设备
     * @param userId 用户ID，表示谁订阅了设备状态
     */
    public void subscribeState(String boxSn, Long userId) {
        // 向订阅列表中添加该session
        stateSubscriptions.computeIfAbsent(boxSn, k -> new HashSet<>()).add(userId);

        // 如果是第一次订阅该无人机的状态，启动定时任务
        if (stateSubscriptions.get(boxSn).size() == 1) {
            startStatePushTask(boxSn);
        }
    }

    /**
     * 取消用户对指定设备状态的订阅
     * <p>
     * 当用户不再需要接收特定设备的状态更新时，通过此方法取消订阅这会从设备的订阅者集合中移除当前用户如果该设备没有其他订阅者，
     * 还将停止与该设备状态推送相关的定时任务
     *
     * @param boxSn  设备序列号，用于唯一标识一个设备
     * @param userId 用户ID，表示要取消订阅的用户
     */
    public void unsubscribeState(String boxSn, Long userId) {
        // 获取指定设备的所有订阅者集合
        Set<Long> userIds = stateSubscriptions.get(boxSn);
        if (userIds != null) {
            // 从订阅者集合中移除当前会话
            userIds.remove(userId);

            // 如果没有用户再订阅该状态，停止定时任务
            if (userIds.isEmpty()) {
                stopStatePushTask(boxSn);
            }
        }
    }

    /**
     * 启动状态推送任务
     * 该方法用于为特定的无人机（通过boxSn标识）启动一个定时任务，定时任务将定期推送无人机的状态
     *
     * @param boxSn 无人机的序列号，用于唯一标识无人机
     */
    private void startStatePushTask(String boxSn) {
        // 启动定时任务，每隔一定时间推送一次状态
        ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(() -> {
            // 推送无人机状态到订阅者
            sendDroneStateToSubscribers(boxSn);
        }, 0, 2, TimeUnit.SECONDS); // 每2秒推送一次状态
        // 将推送任务与无人机序列号关联，以便后续可能的管理或取消
        statePushTasks.put(boxSn, future);
    }

    /**
     * 停止并移除与指定盒子SN关联的状态推送定时任务
     *
     * @param boxSn 盒子的唯一序列号，用于标识特定的定时任务
     */
    private void stopStatePushTask(String boxSn) {
        // 停止定时任务
        ScheduledFuture<?> future = statePushTasks.get(boxSn);
        if (future != null) {
            // 如果任务存在，则取消任务，参数false表示不中断正在执行的任务
            future.cancel(false);
        }
        // 从任务集合中移除与该盒子SN关联的任务
        statePushTasks.remove(boxSn);
    }

    /**
     * 移除用户订阅的状态
     *
     * @param userId 用户ID
     */
    public void removeSubscribeState(Long userId) {
        // 清理掉该用户订阅的状态
        for (Set<Long> userIds : stateSubscriptions.values()) {
            userIds.remove(userId);
        }
    }

    /**
     * 向订阅者发送无人机状态信息
     *
     * @param boxSn 无人机的序列号，用于标识特定的无人机
     *              <p>
     *              此方法首先调用getDroneState方法获取指定无人机的当前状态，然后通过WebSocket向所有订阅该无人机状态的客户端发送状态信息
     *              如果在发送过程中遇到异常，则记录错误日志，包括会话ID和异常信息
     */
    private void sendDroneStateToSubscribers(String boxSn) {
        // 获取当前无人机状态
        UavState uavState = getDroneState(boxSn);
        BaseMessage<UavState>baseMessage=new BaseMessage<>("state",uavState);
        // 向所有订阅者推送状态
        Set<Long> userIds = stateSubscriptions.get(boxSn);
        if (userIds != null) {
            for (Long userId : userIds) {
                try {
                    WebSocketUtil.sendMessage(userId, JSON.toJSONString(baseMessage));
                } catch (Exception e) {
                    log.error("Error sending state message to session {}", userId, e);
                }
            }
        }
    }

    /**
     * 获取无人机的状态信息
     * 此方法通过传入的无人机序列号（boxSn）来获取无人机的当前状态
     * 它主要起到了解无人机实时状态的作用，以便于进一步的控制或显示状态信息
     *
     * @param boxSn 无人机的唯一序列号，用于标识特定的无人机
     * @return UavState 无人机的状态对象，包含各种状态信息如电池电量、飞行高度等
     */
    private UavState getDroneState(String boxSn) {
        // 假设这里是获取无人机状态的逻辑，返回状态信息
    @Override
    protected UavState getData(String boxSn) {
        return UavStateCache.getUavState(boxSn);
    }
}

    @Override
    protected String getMessageType() {
        return "state";
    }

}

 ard-work/src/main/java/com/ard/tianyu/websocket/handler/UavStreamManager.java

@@ -42,7 +42,7 @@
     * @param boxSn  盒子序列号
     * @param userId 用户ID
     */
    public void startPullStream(String boxSn, Long userId) {
    public void subscribe(String boxSn, Long userId) {
        String webrtcUrl = "";
        STREAM_USER_MAP.computeIfAbsent(boxSn, k -> ConcurrentHashMap.newKeySet()).add(userId);
        //不管谁拉流都判断流媒体中是否存在
@@ -68,7 +68,7 @@
     * @param boxSn  盒子序列号
     * @param userId 用户ID
     */
    public void stopPullStream(String boxSn, Long userId) {
    public void unsubscribe(String boxSn, Long userId) {
        synchronized (this) {
            Set<Long> users = STREAM_USER_MAP.get(boxSn);
            if (users == null) {
@@ -102,7 +102,7 @@
     */
    public void stopAllPullStreamByUser(Long userId) {
        synchronized (this) {
            STREAM_USER_MAP.forEach((boxSn, users) -> stopPullStream(boxSn, userId));
            STREAM_USER_MAP.forEach((boxSn, users) -> unsubscribe(boxSn, userId));
        }
    }


 ard-work/src/main/java/com/ard/tianyu/websocket/handler/UavTelemetryManager.java

New file
@@ -0,0 +1,22 @@
package com.ard.tianyu.websocket.handler;

import com.ard.tianyu.domain.cache.UavTelemetryDataCache;
import com.ard.tianyu.domain.dto.telemetry.TelemetryData;
import org.springframework.stereotype.Component;


@Component
public class UavTelemetryManager extends BaseSubscriptionManager<TelemetryData> {

    @Override
    protected TelemetryData getData(String boxSn) {
        return UavTelemetryDataCache.getUavTelemetryData(boxSn);
    }

    @Override
    protected String getMessageType() {
        return "telemetry";
    }


}