BJ_ZTEITS-Developers / parking-cloud-yudao

Commit b87bc19116ffa22e0f0bb47a13a2fb92731b1738

Authored by YunaiV
1 parent 1b4ac9fb

feat：【iot】移除不再使用的 MQTT WebSocket 协议配置类（实现不够标准，使用 MQTT 即可）

Inline Side-by-side
Showing 9 changed files with 3 additions and 1531 deletions
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/config/IotGatewayConfiguration.java
  View file @b87bc19
... ... @@ -12,10 +12,6 @@ import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.IotMqttDownstreamSubscr
12 12 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.IotMqttUpstreamProtocol;
13 13 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.manager.IotMqttConnectionManager;
14 14 import cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.router.IotMqttDownstreamHandler;
15   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.IotMqttWsDownstreamSubscriber;
16   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.IotMqttWsUpstreamProtocol;
17   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.manager.IotMqttWsConnectionManager;
18   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.router.IotMqttWsDownstreamHandler;
19 15 import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.IotTcpDownstreamSubscriber;
20 16 import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.IotTcpUpstreamProtocol;
21 17 import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.manager.IotTcpConnectionManager;
... ... @@ -160,44 +156,6 @@ public class IotGatewayConfiguration {
160 156 }
161 157  
162 158 /**
163   - * IoT 网关 MQTT WebSocket 协议配置类
164   - */
165   - @Configuration
166   - @ConditionalOnProperty(prefix = "yudao.iot.gateway.protocol.mqtt-ws", name = "enabled", havingValue = "true")
167   - @Slf4j
168   - public static class MqttWsProtocolConfiguration {
169   -
170   - @Bean(name = "mqttWsVertx", destroyMethod = "close")
171   - public Vertx mqttWsVertx() {
172   - return Vertx.vertx();
173   - }
174   -
175   - @Bean
176   - public IotMqttWsUpstreamProtocol iotMqttWsUpstreamProtocol(IotGatewayProperties gatewayProperties,
177   - IotDeviceMessageService messageService,
178   - IotMqttWsConnectionManager connectionManager,
179   - @Qualifier("mqttWsVertx") Vertx mqttWsVertx) {
180   - return new IotMqttWsUpstreamProtocol(gatewayProperties.getProtocol().getMqttWs(),
181   - messageService, connectionManager, mqttWsVertx);
182   - }
183   -
184   - @Bean
185   - public IotMqttWsDownstreamHandler iotMqttWsDownstreamHandler(IotDeviceMessageService messageService,
186   - IotDeviceService deviceService,
187   - IotMqttWsConnectionManager connectionManager) {
188   - return new IotMqttWsDownstreamHandler(messageService, deviceService, connectionManager);
189   - }
190   -
191   - @Bean
192   - public IotMqttWsDownstreamSubscriber iotMqttWsDownstreamSubscriber(IotMqttWsUpstreamProtocol mqttWsUpstreamProtocol,
193   - IotMqttWsDownstreamHandler downstreamHandler,
194   - IotMessageBus messageBus) {
195   - return new IotMqttWsDownstreamSubscriber(mqttWsUpstreamProtocol, downstreamHandler, messageBus);
196   - }
197   -
198   - }
199   -
200   - /**
201 159 * IoT 网关 UDP 协议配置类
202 160 */
203 161 @Configuration
... ...
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqtt/manager/IotMqttConnectionManager.java
  View file @b87bc19
... ... @@ -2,6 +2,7 @@ package cn.iocoder.yudao.module.iot.gateway.protocol.mqtt.manager;
2 2  
3 3 import cn.hutool.core.util.StrUtil;
4 4 import io.netty.handler.codec.mqtt.MqttQoS;
  5 +import io.vertx.core.buffer.Buffer;
5 6 import io.vertx.mqtt.MqttEndpoint;
6 7 import lombok.Data;
7 8 import lombok.extern.slf4j.Slf4j;
... ... @@ -166,7 +167,7 @@ public class IotMqttConnectionManager {
166 167 }
167 168  
168 169 try {
169   - endpoint.publish(topic, io.vertx.core.buffer.Buffer.buffer(payload), MqttQoS.valueOf(qos), false, retain);
  170 + endpoint.publish(topic, Buffer.buffer(payload), MqttQoS.valueOf(qos), false, retain);
170 171 log.debug("[sendToDevice][发送消息成功，设备 ID: {}，主题: {}，QoS: {}]", deviceId, topic, qos);
171 172 return true;
172 173 } catch (Exception e) {
... ...
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/IotMqttWsDownstreamSubscriber.java deleted
View file @1b4ac9f
1   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws;
2   -
3   -import cn.hutool.core.util.StrUtil;
4   -import cn.iocoder.yudao.module.iot.core.messagebus.core.IotMessageBus;
5   -import cn.iocoder.yudao.module.iot.core.messagebus.core.IotMessageSubscriber;
6   -import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
7   -import cn.iocoder.yudao.module.iot.core.util.IotDeviceMessageUtils;
8   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.router.IotMqttWsDownstreamHandler;
9   -import jakarta.annotation.PostConstruct;
10   -import lombok.extern.slf4j.Slf4j;
11   -
12   -/**
13   - * IoT MQTT WebSocket 下行消息订阅器
14   - * <p>
15   - * 订阅消息总线的设备下行消息，并通过 WebSocket 发送到设备
16   - *
17   - * @author 芋道源码
18   - */
19   -@Slf4j
20   -public class IotMqttWsDownstreamSubscriber implements IotMessageSubscriber<IotDeviceMessage> {
21   -
22   - private final IotMqttWsUpstreamProtocol upstreamProtocol;
23   - private final IotMqttWsDownstreamHandler downstreamHandler;
24   - private final IotMessageBus messageBus;
25   -
26   - public IotMqttWsDownstreamSubscriber(IotMqttWsUpstreamProtocol upstreamProtocol,
27   - IotMqttWsDownstreamHandler downstreamHandler,
28   - IotMessageBus messageBus) {
29   - this.upstreamProtocol = upstreamProtocol;
30   - this.downstreamHandler = downstreamHandler;
31   - this.messageBus = messageBus;
32   - }
33   -
34   - @PostConstruct
35   - public void init() {
36   - messageBus.register(this);
37   - log.info("[init][MQTT WebSocket 下行消息订阅器已启动，topic: {}]", getTopic());
38   - }
39   -
40   - @Override
41   - public String getTopic() {
42   - return IotDeviceMessageUtils.buildMessageBusGatewayDeviceMessageTopic(upstreamProtocol.getServerId());
43   - }
44   -
45   - @Override
46   - public String getGroup() {
47   - // 保证点对点消费，需要保证独立的 Group，所以使用 Topic 作为 Group
48   - return getTopic();
49   - }
50   -
51   - @Override
52   - public void onMessage(IotDeviceMessage message) {
53   - log.debug("[onMessage][收到下行消息，deviceId: {}，method: {}]",
54   - message.getDeviceId(), message.getMethod());
55   - try {
56   - // 1. 校验
57   - String method = message.getMethod();
58   - if (StrUtil.isBlank(method)) {
59   - log.warn("[onMessage][消息方法为空，deviceId: {}]", message.getDeviceId());
60   - return;
61   - }
62   -
63   - // 2. 委托给下行处理器处理业务逻辑
64   - boolean success = downstreamHandler.handleDownstreamMessage(message);
65   - if (success) {
66   - log.debug("[onMessage][下行消息处理成功，deviceId: {}，method: {}]",
67   - message.getDeviceId(), message.getMethod());
68   - } else {
69   - log.warn("[onMessage][下行消息处理失败，deviceId: {}，method: {}]",
70   - message.getDeviceId(), message.getMethod());
71   - }
72   - } catch (Exception e) {
73   - log.error("[onMessage][处理下行消息失败，deviceId: {}，method: {}]",
74   - message.getDeviceId(), message.getMethod(), e);
75   - }
76   - }
77   -
78   -}
79   -
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/IotMqttWsUpstreamProtocol.java deleted
View file @1b4ac9f
1   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws;
2   -
3   -import cn.iocoder.yudao.module.iot.core.util.IotDeviceMessageUtils;
4   -import cn.iocoder.yudao.module.iot.gateway.config.IotGatewayProperties;
5   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.manager.IotMqttWsConnectionManager;
6   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.router.IotMqttWsUpstreamHandler;
7   -import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
8   -import io.vertx.core.Vertx;
9   -import io.vertx.core.http.HttpServer;
10   -import io.vertx.core.http.HttpServerOptions;
11   -import io.vertx.core.http.ServerWebSocket;
12   -import jakarta.annotation.PostConstruct;
13   -import jakarta.annotation.PreDestroy;
14   -import lombok.Getter;
15   -import lombok.extern.slf4j.Slf4j;
16   -
17   -/**
18   - * IoT 网关 MQTT WebSocket 协议：接收设备上行消息
19   - * <p>
20   - * 基于 Vert.x 实现 MQTT over WebSocket 服务端，支持：
21   - * - 标准 MQTT 3.1.1 协议
22   - * - WebSocket 协议升级
23   - * - SSL/TLS 加密（wss://）
24   - * - 设备认证与连接管理
25   - * - QoS 0/1/2 消息质量保证
26   - *
27   - * @author 芋道源码
28   - */
29   -@Slf4j
30   -public class IotMqttWsUpstreamProtocol {
31   -
32   - private final IotGatewayProperties.MqttWsProperties mqttWsProperties;
33   -
34   - private final IotDeviceMessageService messageService;
35   -
36   - private final IotMqttWsConnectionManager connectionManager;
37   -
38   - private final Vertx vertx;
39   -
40   - @Getter
41   - private final String serverId;
42   -
43   - private HttpServer httpServer;
44   -
45   - public IotMqttWsUpstreamProtocol(IotGatewayProperties.MqttWsProperties mqttWsProperties,
46   - IotDeviceMessageService messageService,
47   - IotMqttWsConnectionManager connectionManager,
48   - Vertx vertx) {
49   - this.mqttWsProperties = mqttWsProperties;
50   - this.messageService = messageService;
51   - this.connectionManager = connectionManager;
52   - this.vertx = vertx;
53   - this.serverId = IotDeviceMessageUtils.generateServerId(mqttWsProperties.getPort());
54   - }
55   -
56   - @PostConstruct
57   - public void start() {
58   - // 创建 HTTP 服务器选项
59   - HttpServerOptions options = new HttpServerOptions()
60   - .setPort(mqttWsProperties.getPort())
61   - .setIdleTimeout(mqttWsProperties.getKeepAliveTimeoutSeconds())
62   - .setMaxWebSocketFrameSize(mqttWsProperties.getMaxFrameSize())
63   - .setMaxWebSocketMessageSize(mqttWsProperties.getMaxMessageSize())
64   - // 配置 WebSocket 子协议支持
65   - .addWebSocketSubProtocol(mqttWsProperties.getSubProtocol());
66   -
67   - // 配置 SSL（如果启用）
68   - if (Boolean.TRUE.equals(mqttWsProperties.getSslEnabled())) {
69   - options.setSsl(true)
70   - .setKeyCertOptions(mqttWsProperties.getSslOptions().getKeyCertOptions())
71   - .setTrustOptions(mqttWsProperties.getSslOptions().getTrustOptions());
72   - log.info("[start][MQTT WebSocket 已启用 SSL/TLS (wss://)]");
73   - }
74   -
75   - // 创建 HTTP 服务器
76   - httpServer = vertx.createHttpServer(options);
77   -
78   - // 设置 WebSocket 处理器
79   - httpServer.webSocketHandler(this::handleWebSocketConnection);
80   -
81   - // 启动服务器
82   - try {
83   - httpServer.listen().result();
84   - log.info("[start][IoT 网关 MQTT WebSocket 协议启动成功，端口: {}，路径: {}，支持子协议: {}]",
85   - mqttWsProperties.getPort(), mqttWsProperties.getPath(),
86   - "mqtt, mqttv3.1, " + mqttWsProperties.getSubProtocol());
87   - } catch (Exception e) {
88   - log.error("[start][IoT 网关 MQTT WebSocket 协议启动失败]", e);
89   - throw e;
90   - }
91   - }
92   -
93   - @PreDestroy
94   - public void stop() {
95   - if (httpServer != null) {
96   - try {
97   - // 关闭所有连接
98   - connectionManager.closeAllConnections();
99   -
100   - // 关闭服务器
101   - httpServer.close().result();
102   - log.info("[stop][IoT 网关 MQTT WebSocket 协议已停止]");
103   - } catch (Exception e) {
104   - log.error("[stop][IoT 网关 MQTT WebSocket 协议停止失败]", e);
105   - }
106   - }
107   - }
108   -
109   - /**
110   - * 处理 WebSocket 连接请求
111   - *
112   - * @param socket WebSocket 连接
113   - */
114   - private void handleWebSocketConnection(ServerWebSocket socket) {
115   - String path = socket.path();
116   - String subProtocol = socket.subProtocol();
117   -
118   - log.info("[handleWebSocketConnection][收到 WebSocket 连接请求，path: {}，subProtocol: {}，remoteAddress: {}]",
119   - path, subProtocol, socket.remoteAddress());
120   -
121   - // 验证路径
122   - if (!mqttWsProperties.getPath().equals(path)) {
123   - log.warn("[handleWebSocketConnection][WebSocket 路径不匹配，拒绝连接，path: {}，期望: {}]",
124   - path, mqttWsProperties.getPath());
125   - socket.close();
126   - return;
127   - }
128   -
129   - // 验证子协议
130   - // Vert.x 已经自动进行了子协议协商，这里只需要验证是否为 MQTT 相关协议
131   - if (subProtocol != null && !subProtocol.startsWith("mqtt")) {
132   - log.warn("[handleWebSocketConnection][WebSocket 子协议不支持，拒绝连接，subProtocol: {}]", subProtocol);
133   - socket.close();
134   - return;
135   - }
136   -
137   - log.info("[handleWebSocketConnection][WebSocket 连接已接受，remoteAddress: {}，subProtocol: {}]",
138   - socket.remoteAddress(), subProtocol);
139   -
140   - // 创建处理器并处理连接
141   - IotMqttWsUpstreamHandler handler = new IotMqttWsUpstreamHandler(
142   - this, messageService, connectionManager);
143   - handler.handle(socket);
144   - }
145   -
146   -}
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/manager/IotMqttWsConnectionManager.java deleted
View file @1b4ac9f
1   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.manager;
2   -
3   -import cn.hutool.core.collection.CollUtil;
4   -import io.vertx.core.http.ServerWebSocket;
5   -import lombok.extern.slf4j.Slf4j;
6   -import org.springframework.stereotype.Component;
7   -
8   -import java.util.Map;
9   -import java.util.Set;
10   -import java.util.concurrent.ConcurrentHashMap;
11   -import java.util.concurrent.CopyOnWriteArraySet;
12   -
13   -/**
14   - * IoT MQTT WebSocket 连接管理器
15   - *
16   - * @author 芋道源码
17   - */
18   -@Slf4j
19   -@Component
20   -public class IotMqttWsConnectionManager {
21   -
22   - /**
23   - * 存储设备连接
24   - * Key: 设备标识（deviceKey）
25   - * Value: WebSocket 连接
26   - */
27   - private final Map<String, ServerWebSocket> connections = new ConcurrentHashMap<>();
28   -
29   - /**
30   - * 存储设备标识与 Socket ID 的映射
31   - * Key: 设备标识（deviceKey）
32   - * Value: Socket ID（UUID）
33   - */
34   - private final Map<String, String> deviceKeyToSocketId = new ConcurrentHashMap<>();
35   -
36   - /**
37   - * 存储 Socket ID 与设备标识的映射
38   - * Key: Socket ID（UUID）
39   - * Value: 设备标识（deviceKey）
40   - */
41   - private final Map<String, String> socketIdToDeviceKey = new ConcurrentHashMap<>();
42   -
43   - /**
44   - * 存储设备订阅的主题
45   - * Key: 设备标识（deviceKey）
46   - * Value: 订阅的主题集合
47   - */
48   - private final Map<String, Set<String>> deviceSubscriptions = new ConcurrentHashMap<>();
49   -
50   - /**
51   - * 添加连接
52   - *
53   - * @param deviceKey 设备标识
54   - * @param socket WebSocket 连接
55   - * @param socketId Socket ID（UUID）
56   - */
57   - public void addConnection(String deviceKey, ServerWebSocket socket, String socketId) {
58   - connections.put(deviceKey, socket);
59   - deviceKeyToSocketId.put(deviceKey, socketId);
60   - socketIdToDeviceKey.put(socketId, deviceKey);
61   - log.info("[addConnection][设备连接已添加，deviceKey: {}，socketId: {}，当前连接数: {}]",
62   - deviceKey, socketId, connections.size());
63   - }
64   -
65   - /**
66   - * 移除连接
67   - *
68   - * @param deviceKey 设备标识
69   - */
70   - public void removeConnection(String deviceKey) {
71   - ServerWebSocket socket = connections.remove(deviceKey);
72   - String socketId = deviceKeyToSocketId.remove(deviceKey);
73   - if (socketId != null) {
74   - socketIdToDeviceKey.remove(socketId);
75   - }
76   - if (socket != null) {
77   - log.info("[removeConnection][设备连接已移除，deviceKey: {}，socketId: {}，当前连接数: {}]",
78   - deviceKey, socketId, connections.size());
79   - }
80   - }
81   -
82   - /**
83   - * 根据 Socket ID 移除连接
84   - *
85   - * @param socketId WebSocket 文本框架 ID
86   - */
87   - public void removeConnectionBySocketId(String socketId) {
88   - String deviceKey = socketIdToDeviceKey.remove(socketId);
89   - if (deviceKey != null) {
90   - connections.remove(deviceKey);
91   - log.info("[removeConnectionBySocketId][设备连接已移除，socketId: {}，deviceKey: {}，当前连接数: {}]",
92   - socketId, deviceKey, connections.size());
93   - }
94   - }
95   -
96   - /**
97   - * 获取连接
98   - *
99   - * @param deviceKey 设备标识
100   - * @return WebSocket 连接
101   - */
102   - public ServerWebSocket getConnection(String deviceKey) {
103   - return connections.get(deviceKey);
104   - }
105   -
106   - /**
107   - * 根据 Socket ID 获取设备标识
108   - *
109   - * @param socketId WebSocket 文本框架 ID
110   - * @return 设备标识
111   - */
112   - public String getDeviceKeyBySocketId(String socketId) {
113   - return socketIdToDeviceKey.get(socketId);
114   - }
115   -
116   - /**
117   - * 检查设备是否在线
118   - *
119   - * @param deviceKey 设备标识
120   - * @return 是否在线
121   - */
122   - public boolean isOnline(String deviceKey) {
123   - return connections.containsKey(deviceKey);
124   - }
125   -
126   - /**
127   - * 获取当前连接数
128   - *
129   - * @return 连接数
130   - */
131   - public int getConnectionCount() {
132   - return connections.size();
133   - }
134   -
135   - /**
136   - * 关闭所有连接
137   - */
138   - public void closeAllConnections() {
139   - connections.forEach((deviceKey, socket) -> {
140   - try {
141   - socket.close();
142   - log.info("[closeAllConnections][关闭设备连接，deviceKey: {}]", deviceKey);
143   - } catch (Exception e) {
144   - log.error("[closeAllConnections][关闭设备连接失败，deviceKey: {}]", deviceKey, e);
145   - }
146   - });
147   - connections.clear();
148   - deviceKeyToSocketId.clear();
149   - socketIdToDeviceKey.clear();
150   - deviceSubscriptions.clear();
151   - log.info("[closeAllConnections][所有连接已关闭]");
152   - }
153   -
154   - // ==================== 订阅管理方法 ====================
155   -
156   - /**
157   - * 添加订阅
158   - *
159   - * @param deviceKey 设备标识
160   - * @param topic 订阅主题
161   - */
162   - public void addSubscription(String deviceKey, String topic) {
163   - deviceSubscriptions.computeIfAbsent(deviceKey, k -> new CopyOnWriteArraySet<>()).add(topic);
164   - log.debug("[addSubscription][设备订阅主题，deviceKey: {}，topic: {}]", deviceKey, topic);
165   - }
166   -
167   - /**
168   - * 移除订阅
169   - *
170   - * @param deviceKey 设备标识
171   - * @param topic 订阅主题
172   - */
173   - public void removeSubscription(String deviceKey, String topic) {
174   - Set<String> topics = deviceSubscriptions.get(deviceKey);
175   - if (topics != null) {
176   - topics.remove(topic);
177   - log.debug("[removeSubscription][设备取消订阅，deviceKey: {}，topic: {}]", deviceKey, topic);
178   - }
179   - }
180   -
181   - /**
182   - * 检查设备是否订阅了指定主题
183   - * 支持 MQTT 通配符匹配（+ 和 #）
184   - *
185   - * @param deviceKey 设备标识
186   - * @param topic 发布主题
187   - * @return 是否匹配
188   - */
189   - public boolean isSubscribed(String deviceKey, String topic) {
190   - Set<String> subscriptions = deviceSubscriptions.get(deviceKey);
191   - if (CollUtil.isEmpty(subscriptions)) {
192   - return false;
193   - }
194   -
195   - // 检查是否有匹配的订阅
196   - for (String subscription : subscriptions) {
197   - if (topicMatches(subscription, topic)) {
198   - return true;
199   - }
200   - }
201   - return false;
202   - }
203   -
204   - /**
205   - * 获取设备的所有订阅
206   - *
207   - * @param deviceKey 设备标识
208   - * @return 订阅主题集合
209   - */
210   - public Set<String> getSubscriptions(String deviceKey) {
211   - return deviceSubscriptions.get(deviceKey);
212   - }
213   -
214   - // TODO @haohao：这个方法，是不是也可以考虑抽到 IotMqttTopicUtils 里面去哈；感觉更简洁一点？
215   - /**
216   - * MQTT 主题匹配
217   - * 支持通配符：
218   - * - +：匹配单层主题
219   - * - #：匹配多层主题（必须在末尾）
220   - *
221   - * @param subscription 订阅主题（可能包含通配符）
222   - * @param topic 发布主题（不包含通配符）
223   - * @return 是否匹配
224   - */
225   - private boolean topicMatches(String subscription, String topic) {
226   - // 完全匹配
227   - if (subscription.equals(topic)) {
228   - return true;
229   - }
230   -
231   - // 不包含通配符
232   - // TODO @haohao：这里要不要枚举下哈；+ #
233   - if (!subscription.contains("+") && !subscription.contains("#")) {
234   - return false;
235   - }
236   -
237   - String[] subscriptionParts = subscription.split("/");
238   - String[] topicParts = topic.split("/");
239   - int i = 0;
240   - for (; i < subscriptionParts.length && i < topicParts.length; i++) {
241   - String subPart = subscriptionParts[i];
242   - String topicPart = topicParts[i];
243   -
244   - // # 匹配剩余所有层级，且必须在末尾
245   - if (subPart.equals("#")) {
246   - return i == subscriptionParts.length - 1;
247   - }
248   -
249   - // 不是通配符且不匹配
250   - if (!subPart.equals("+") && !subPart.equals(topicPart)) {
251   - return false;
252   - }
253   - }
254   -
255   - // 检查是否都匹配完
256   - return i == subscriptionParts.length && i == topicParts.length;
257   - }
258   -
259   -}
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/package-info.java deleted
View file @1b4ac9f
1   -/**
2   - * IoT 网关 MQTT WebSocket 协议实现
3   - * <p>
4   - * 基于 Vert.x 实现 MQTT over WebSocket 服务端，支持：
5   - * - 标准 MQTT 3.1.1 协议
6   - * - WebSocket 协议升级
7   - * - SSL/TLS 加密（wss://）
8   - * - 设备认证与连接管理
9   - * - QoS 0/1/2 消息质量保证
10   - * - 双向消息通信（上行/下行）
11   - *
12   - * @author 芋道源码
13   - */
14   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws;
15   -
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/router/IotMqttWsDownstreamHandler.java deleted
View file @1b4ac9f
1   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.router;
2   -
3   -import cn.hutool.core.util.StrUtil;
4   -import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
5   -import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
6   -import cn.iocoder.yudao.module.iot.core.util.IotDeviceMessageUtils;
7   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.manager.IotMqttWsConnectionManager;
8   -import cn.iocoder.yudao.module.iot.gateway.service.device.IotDeviceService;
9   -import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
10   -import cn.iocoder.yudao.module.iot.gateway.util.IotMqttTopicUtils;
11   -import io.vertx.core.buffer.Buffer;
12   -import io.vertx.core.http.ServerWebSocket;
13   -import lombok.extern.slf4j.Slf4j;
14   -
15   -import java.util.concurrent.atomic.AtomicInteger;
16   -
17   -/**
18   - * IoT MQTT WebSocket 下行消息处理器
19   - * <p>
20   - * 处理从消息总线发送到设备的消息，包括：
21   - * - 属性设置
22   - * - 服务调用
23   - * - 事件通知
24   - *
25   - * @author 芋道源码
26   - */
27   -@Slf4j
28   -public class IotMqttWsDownstreamHandler {
29   -
30   - private final IotDeviceMessageService deviceMessageService;
31   -
32   - private final IotDeviceService deviceService;
33   -
34   - private final IotMqttWsConnectionManager connectionManager;
35   -
36   - /**
37   - * 消息 ID 生成器（用于发布消息）
38   - */
39   - private final AtomicInteger messageIdGenerator = new AtomicInteger(1);
40   -
41   - public IotMqttWsDownstreamHandler(IotDeviceMessageService deviceMessageService,
42   - IotDeviceService deviceService,
43   - IotMqttWsConnectionManager connectionManager) {
44   - this.deviceMessageService = deviceMessageService;
45   - this.deviceService = deviceService;
46   - this.connectionManager = connectionManager;
47   - }
48   -
49   - /**
50   - * 处理下行消息
51   - *
52   - * @param message 设备消息
53   - * @return 是否处理成功
54   - */
55   - public boolean handleDownstreamMessage(IotDeviceMessage message) {
56   - try {
57   - // 1. 基础校验
58   - if (message == null || message.getDeviceId() == null) {
59   - log.warn("[handleDownstreamMessage][消息或设备 ID 为空，忽略处理]");
60   - return false;
61   - }
62   -
63   - // 2. 获取设备信息
64   - IotDeviceRespDTO deviceInfo = deviceService.getDeviceFromCache(message.getDeviceId());
65   - if (deviceInfo == null) {
66   - log.warn("[handleDownstreamMessage][设备不存在，设备 ID：{}]", message.getDeviceId());
67   - return false;
68   - }
69   -
70   - // 3. 构建设备标识
71   - String deviceKey = deviceInfo.getProductKey() + ":" + deviceInfo.getDeviceName();
72   -
73   - // 4. 检查设备是否在线
74   - if (!connectionManager.isOnline(deviceKey)) {
75   - log.warn("[handleDownstreamMessage][设备离线，无法发送消息，deviceKey: {}]", deviceKey);
76   - return false;
77   - }
78   -
79   - // 5. 构建主题
80   - String topic = buildDownstreamTopic(message, deviceInfo);
81   - if (StrUtil.isBlank(topic)) {
82   - log.warn("[handleDownstreamMessage][主题构建失败，设备 ID：{}，方法：{}]",
83   - message.getDeviceId(), message.getMethod());
84   - return false;
85   - }
86   -
87   - // 6. 检查设备是否订阅了该主题
88   - if (!connectionManager.isSubscribed(deviceKey, topic)) {
89   - log.warn("[handleDownstreamMessage][设备未订阅该主题，deviceKey: {}，topic: {}]", deviceKey, topic);
90   - return false;
91   - }
92   -
93   - // 8. 编码消息
94   - byte[] payload = deviceMessageService.encodeDeviceMessage(message,
95   - deviceInfo.getProductKey(), deviceInfo.getDeviceName());
96   - if (payload == null || payload.length == 0) {
97   - log.warn("[handleDownstreamMessage][消息编码失败，设备 ID：{}]", message.getDeviceId());
98   - return false;
99   - }
100   -
101   - // 9. 发送消息到设备
102   - return sendMessageToDevice(deviceKey, topic, payload, 1);
103   - } catch (Exception e) {
104   - if (message != null) {
105   - log.error("[handleDownstreamMessage][处理下行消息异常，设备 ID：{}，错误：{}]",
106   - message.getDeviceId(), e.getMessage(), e);
107   - }
108   - return false;
109   - }
110   - }
111   -
112   - /**
113   - * 构建下行消息主题
114   - *
115   - * @param message 设备消息
116   - * @param deviceInfo 设备信息
117   - * @return 主题
118   - */
119   - private String buildDownstreamTopic(IotDeviceMessage message, IotDeviceRespDTO deviceInfo) {
120   - String method = message.getMethod();
121   - if (StrUtil.isBlank(method)) {
122   - return null;
123   - }
124   -
125   - // 使用工具类构建主题，支持回复消息处理
126   - boolean isReply = IotDeviceMessageUtils.isReplyMessage(message);
127   - return IotMqttTopicUtils.buildTopicByMethod(method, deviceInfo.getProductKey(),
128   - deviceInfo.getDeviceName(), isReply);
129   - }
130   -
131   - /**
132   - * 发送消息到设备
133   - *
134   - * @param deviceKey 设备标识（productKey:deviceName）
135   - * @param topic 主题
136   - * @param payload 消息内容
137   - * @param qos QoS 级别
138   - * @return 是否发送成功
139   - */
140   - private boolean sendMessageToDevice(String deviceKey, String topic, byte[] payload, int qos) {
141   - // 获取设备连接
142   - ServerWebSocket socket = connectionManager.getConnection(deviceKey);
143   - if (socket == null) {
144   - log.warn("[sendMessageToDevice][设备未连接，deviceKey: {}]", deviceKey);
145   - return false;
146   - }
147   -
148   - try {
149   - int messageId = qos > 0 ? generateMessageId() : 0;
150   -
151   - // 手动编码 MQTT PUBLISH 消息
152   - io.netty.buffer.ByteBuf byteBuf = io.netty.buffer.Unpooled.buffer();
153   -
154   - // 固定头：消息类型(PUBLISH=3) + DUP(0) + QoS + RETAIN
155   - int fixedHeaderByte1 = 0x30 | (qos << 1); // PUBLISH类型
156   - byteBuf.writeByte(fixedHeaderByte1);
157   -
158   - // 计算剩余长度
159   - int topicLength = topic.getBytes().length;
160   - int remainingLength = 2 + topicLength + (qos > 0 ? 2 : 0) + payload.length;
161   -
162   - // 写入剩余长度（简化版本，假设小于 128 字节）
163   - if (remainingLength < 128) {
164   - byteBuf.writeByte(remainingLength);
165   - } else {
166   - // 处理大于 127 的情况
167   - int x = remainingLength;
168   - do {
169   - int encodedByte = x % 128;
170   - x = x / 128;
171   - if (x > 0) {
172   - encodedByte = encodedByte | 128;
173   - }
174   - byteBuf.writeByte(encodedByte);
175   - } while (x > 0);
176   - }
177   -
178   - // 可变头：主题名称
179   - byteBuf.writeShort(topicLength);
180   - byteBuf.writeBytes(topic.getBytes());
181   -
182   - // 可变头：消息 ID（仅 QoS > 0 时）
183   - if (qos > 0) {
184   - byteBuf.writeShort(messageId);
185   - }
186   -
187   - // 有效载荷
188   - byteBuf.writeBytes(payload);
189   -
190   - // 发送
191   - byte[] bytes = new byte[byteBuf.readableBytes()];
192   - byteBuf.readBytes(bytes);
193   - byteBuf.release();
194   - socket.writeBinaryMessage(Buffer.buffer(bytes));
195   -
196   - log.info("[sendMessageToDevice][消息已发送到设备，deviceKey: {}，topic: {}，qos: {}，messageId: {}]",
197   - deviceKey, topic, qos, messageId);
198   - return true;
199   - } catch (Exception e) {
200   - log.error("[sendMessageToDevice][发送消息到设备失败，deviceKey: {}，topic: {}]", deviceKey, topic, e);
201   - return false;
202   - }
203   - }
204   -
205   - /**
206   - * 生成消息 ID
207   - *
208   - * @return 消息 ID
209   - */
210   - private int generateMessageId() {
211   - int id = messageIdGenerator.getAndIncrement();
212   - // MQTT 消息 ID 范围是 1-65535
213   - // TODO @haohao：并发可能有问题；
214   - if (id > 65535) {
215   - messageIdGenerator.set(1);
216   - return 1;
217   - }
218   - return id;
219   - }
220   -
221   -}
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/mqttws/router/IotMqttWsUpstreamHandler.java deleted
View file @1b4ac9f
1   -package cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.router;
2   -
3   -import cn.hutool.core.util.BooleanUtil;
4   -import cn.hutool.core.util.IdUtil;
5   -import cn.hutool.core.util.StrUtil;
6   -import cn.hutool.extra.spring.SpringUtil;
7   -import cn.iocoder.yudao.framework.common.pojo.CommonResult;
8   -import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
9   -import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
10   -import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
11   -import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
12   -import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
13   -import cn.iocoder.yudao.module.iot.core.topic.IotDeviceIdentity;
14   -import cn.iocoder.yudao.module.iot.core.util.IotDeviceAuthUtils;
15   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.IotMqttWsUpstreamProtocol;
16   -import cn.iocoder.yudao.module.iot.gateway.protocol.mqttws.manager.IotMqttWsConnectionManager;
17   -import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
18   -import io.netty.buffer.ByteBuf;
19   -import io.netty.buffer.Unpooled;
20   -import io.netty.channel.embedded.EmbeddedChannel;
21   -import io.netty.handler.codec.DecoderException;
22   -import io.netty.handler.codec.mqtt.*;
23   -import io.vertx.core.buffer.Buffer;
24   -import io.vertx.core.http.ServerWebSocket;
25   -import lombok.extern.slf4j.Slf4j;
26   -
27   -import java.nio.charset.StandardCharsets;
28   -import java.util.concurrent.ConcurrentHashMap;
29   -import java.util.concurrent.atomic.AtomicInteger;
30   -
31   -/**
32   - * IoT MQTT WebSocket 上行消息处理器
33   - * <p>
34   - * 处理来自设备的 MQTT 消息，包括：
35   - * - CONNECT：设备连接认证
36   - * - PUBLISH：设备发布消息
37   - * - SUBSCRIBE：设备订阅主题
38   - * - UNSUBSCRIBE：设备取消订阅
39   - * - PINGREQ：心跳请求
40   - * - DISCONNECT：设备断开连接
41   - *
42   - * @author 芋道源码
43   - */
44   -@Slf4j
45   -public class IotMqttWsUpstreamHandler {
46   -
47   - private final IotMqttWsUpstreamProtocol upstreamProtocol;
48   -
49   - private final IotDeviceCommonApi deviceApi;
50   -
51   - private final IotDeviceMessageService messageService;
52   -
53   - private final IotMqttWsConnectionManager connectionManager;
54   -
55   - /**
56   - * 存储 WebSocket 连接到 Socket ID 的映射
57   - * Key: WebSocket 对象
58   - * Value: Socket ID（UUID）
59   - */
60   - private final ConcurrentHashMap<ServerWebSocket, String> socketIdMap = new ConcurrentHashMap<>();
61   -
62   - /**
63   - * 存储 Socket ID 对应的设备信息
64   - * Key: Socket ID（UUID）
65   - * Value: 设备信息
66   - */
67   - private final ConcurrentHashMap<String, IotDeviceRespDTO> socketDeviceMap = new ConcurrentHashMap<>();
68   -
69   - /**
70   - * 存储设备的消息 ID 生成器（用于 QoS > 0 的消息）
71   - */
72   - private final ConcurrentHashMap<String, AtomicInteger> deviceMessageIdMap = new ConcurrentHashMap<>();
73   -
74   - /**
75   - * MQTT 解码通道（用于解析 WebSocket 中的 MQTT 二进制消息）
76   - */
77   - private final ThreadLocal<EmbeddedChannel> decoderChannelThreadLocal = ThreadLocal
78   - .withInitial(() -> new EmbeddedChannel(new MqttDecoder()));
79   -
80   - /**
81   - * MQTT 编码通道（用于编码 MQTT 响应消息）
82   - */
83   - private final ThreadLocal<EmbeddedChannel> encoderChannelThreadLocal = ThreadLocal
84   - .withInitial(() -> new EmbeddedChannel(MqttEncoder.INSTANCE));
85   -
86   - public IotMqttWsUpstreamHandler(IotMqttWsUpstreamProtocol upstreamProtocol,
87   - IotDeviceMessageService messageService,
88   - IotMqttWsConnectionManager connectionManager) {
89   - this.upstreamProtocol = upstreamProtocol;
90   - this.deviceApi = SpringUtil.getBean(IotDeviceCommonApi.class);
91   - this.messageService = messageService;
92   - this.connectionManager = connectionManager;
93   - }
94   -
95   - /**
96   - * 处理 WebSocket 连接
97   - *
98   - * @param socket WebSocket 连接
99   - */
100   - public void handle(ServerWebSocket socket) {
101   - // 生成唯一的 Socket ID（因为 MQTT 使用二进制协议，textHandlerID() 会返回 null）
102   - String socketId = IdUtil.simpleUUID();
103   - socketIdMap.put(socket, socketId);
104   -
105   - log.info("[handle][WebSocket 连接建立，socketId: {}，remoteAddress: {}]",
106   - socketId, socket.remoteAddress());
107   -
108   - // 设置二进制数据处理器
109   - socket.binaryMessageHandler(buffer -> {
110   - try {
111   - handleMqttMessage(socket, buffer);
112   - } catch (Exception e) {
113   - log.error("[handle][处理 MQTT 消息异常，socketId: {}]", socketId, e);
114   - socket.close();
115   - }
116   - });
117   -
118   - // 设置关闭处理器
119   - socket.closeHandler(v -> {
120   - socketIdMap.remove(socket);
121   - IotDeviceRespDTO device = socketDeviceMap.remove(socketId);
122   - if (device != null) {
123   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
124   - connectionManager.removeConnection(deviceKey);
125   - deviceMessageIdMap.remove(deviceKey);
126   - // 发送设备离线消息
127   - sendOfflineMessage(device);
128   - log.info("[handle][WebSocket 连接关闭，deviceKey: {}，socketId: {}]", deviceKey, socketId);
129   - }
130   - });
131   -
132   - // 设置异常处理器
133   - socket.exceptionHandler(e -> {
134   - log.error("[handle][WebSocket 连接异常，socketId: {}]", socketId, e);
135   - socketIdMap.remove(socket);
136   - IotDeviceRespDTO device = socketDeviceMap.remove(socketId);
137   - if (device != null) {
138   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
139   - connectionManager.removeConnection(deviceKey);
140   - deviceMessageIdMap.remove(deviceKey);
141   - }
142   - socket.close();
143   - });
144   - }
145   -
146   - /**
147   - * 处理 MQTT 消息
148   - *
149   - * @param socket WebSocket 连接
150   - * @param buffer 消息缓冲区
151   - */
152   - private void handleMqttMessage(ServerWebSocket socket, Buffer buffer) {
153   - String socketId = socketIdMap.get(socket);
154   - ByteBuf byteBuf = Unpooled.wrappedBuffer(buffer.getBytes());
155   -
156   - try {
157   - // 使用 EmbeddedChannel 解码 MQTT 消息
158   - EmbeddedChannel decoderChannel = decoderChannelThreadLocal.get();
159   - decoderChannel.writeInbound(byteBuf.retain());
160   -
161   - // 读取解码后的消息
162   - MqttMessage mqttMessage = decoderChannel.readInbound();
163   - if (mqttMessage == null) {
164   - log.warn("[handleMqttMessage][MQTT 消息解码失败，socketId: {}]", socketId);
165   - return;
166   - }
167   -
168   - MqttMessageType messageType = mqttMessage.fixedHeader().messageType();
169   - log.debug("[handleMqttMessage][收到 MQTT 消息，类型: {}，socketId: {}]", messageType, socketId);
170   -
171   - // 根据消息类型分发处理
172   - switch (messageType) {
173   - case CONNECT:
174   - handleConnect(socket, (MqttConnectMessage) mqttMessage);
175   - break;
176   - case PUBLISH:
177   - handlePublish(socket, (MqttPublishMessage) mqttMessage);
178   - break;
179   - case PUBACK:
180   - handlePubAck(socket, mqttMessage);
181   - break;
182   - case PUBREC:
183   - handlePubRec(socket, mqttMessage);
184   - break;
185   - case PUBREL:
186   - handlePubRel(socket, mqttMessage);
187   - break;
188   - case PUBCOMP:
189   - handlePubComp(socket, mqttMessage);
190   - break;
191   - case SUBSCRIBE:
192   - handleSubscribe(socket, (MqttSubscribeMessage) mqttMessage);
193   - break;
194   - case UNSUBSCRIBE:
195   - handleUnsubscribe(socket, (MqttUnsubscribeMessage) mqttMessage);
196   - break;
197   - case PINGREQ:
198   - handlePingReq(socket);
199   - break;
200   - case DISCONNECT:
201   - handleDisconnect(socket);
202   - break;
203   - default:
204   - log.warn("[handleMqttMessage][不支持的消息类型: {}，socketId: {}]", messageType, socketId);
205   - }
206   - } catch (DecoderException e) {
207   - log.error("[handleMqttMessage][MQTT 消息解码异常，socketId: {}]", socketId, e);
208   - socket.close();
209   - } catch (Exception e) {
210   - log.error("[handleMqttMessage][处理 MQTT 消息失败，socketId: {}]", socketId, e);
211   - socket.close();
212   - } finally {
213   - byteBuf.release();
214   - }
215   - }
216   -
217   - /**
218   - * 处理 CONNECT 消息（设备认证）
219   - */
220   - private void handleConnect(ServerWebSocket socket, MqttConnectMessage message) {
221   - String socketId = socketIdMap.get(socket);
222   - try {
223   - // 1. 解析 CONNECT 消息
224   - MqttConnectPayload payload = message.payload();
225   - String clientId = payload.clientIdentifier();
226   - String username = payload.userName();
227   - String password = payload.passwordInBytes() != null
228   - ? new String(payload.passwordInBytes(), StandardCharsets.UTF_8)
229   - : null;
230   -
231   - log.info("[handleConnect][收到 CONNECT 消息，clientId: {}，username: {}，socketId: {}]",
232   - clientId, username, socketId);
233   -
234   - // 2. 设备认证
235   - IotDeviceRespDTO device = authenticateDevice(clientId, username, password);
236   - if (device == null) {
237   - log.warn("[handleConnect][设备认证失败，clientId: {}，socketId: {}]", clientId, socketId);
238   - sendConnAck(socket, MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USER_NAME_OR_PASSWORD);
239   - socket.close();
240   - return;
241   - }
242   -
243   - // 3. 保存设备信息
244   - socketDeviceMap.put(socketId, device);
245   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
246   - connectionManager.addConnection(deviceKey, socket, socketId);
247   - deviceMessageIdMap.put(deviceKey, new AtomicInteger(1));
248   -
249   - log.info("[handleConnect][设备认证成功，deviceId: {}，deviceKey: {}，socketId: {}]",
250   - device.getId(), deviceKey, socketId);
251   -
252   - // 4. 发送 CONNACK
253   - sendConnAck(socket, MqttConnectReturnCode.CONNECTION_ACCEPTED);
254   -
255   - // 5. 发送设备上线消息
256   - sendOnlineMessage(device);
257   - } catch (Exception e) {
258   - log.error("[handleConnect][处理 CONNECT 消息失败，socketId: {}]", socketId, e);
259   - sendConnAck(socket, MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE);
260   - socket.close();
261   - }
262   - }
263   -
264   - /**
265   - * 处理 PUBLISH 消息（设备发布消息）
266   - */
267   - private void handlePublish(ServerWebSocket socket, MqttPublishMessage message) {
268   - String socketId = socketIdMap.get(socket);
269   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
270   -
271   - if (device == null) {
272   - log.warn("[handlePublish][设备未认证，socketId: {}]", socketId);
273   - socket.close();
274   - return;
275   - }
276   -
277   - try {
278   - // 1. 解析 PUBLISH 消息
279   - MqttFixedHeader fixedHeader = message.fixedHeader();
280   - MqttPublishVariableHeader variableHeader = message.variableHeader();
281   - ByteBuf payload = message.payload();
282   -
283   - String topic = variableHeader.topicName();
284   - int messageId = variableHeader.packetId();
285   - MqttQoS qos = fixedHeader.qosLevel();
286   -
287   - log.debug("[handlePublish][收到 PUBLISH 消息，topic: {}，messageId: {}，QoS: {}，deviceId: {}]",
288   - topic, messageId, qos, device.getId());
289   -
290   - // 2. 读取 payload
291   - byte[] payloadBytes = new byte[payload.readableBytes()];
292   - payload.readBytes(payloadBytes);
293   -
294   - // 3. 解码并发送消息
295   - IotDeviceMessage deviceMessage = messageService.decodeDeviceMessage(payloadBytes,
296   - device.getProductKey(), device.getDeviceName());
297   - if (deviceMessage != null) {
298   - deviceMessage.setServerId(upstreamProtocol.getServerId());
299   - messageService.sendDeviceMessage(deviceMessage, device.getProductKey(),
300   - device.getDeviceName(), upstreamProtocol.getServerId());
301   - log.info("[handlePublish][设备消息已发送，method: {}，deviceId: {}]",
302   - deviceMessage.getMethod(), device.getId());
303   - }
304   -
305   - // 4. 根据 QoS 级别发送相应的确认消息
306   - if (qos == MqttQoS.AT_LEAST_ONCE) {
307   - // QoS 1：发送 PUBACK
308   - sendPubAck(socket, messageId);
309   - } else if (qos == MqttQoS.EXACTLY_ONCE) {
310   - // QoS 2：发送 PUBREC
311   - sendPubRec(socket, messageId);
312   - }
313   - // QoS 0 无需确认
314   - } catch (Exception e) {
315   - log.error("[handlePublish][处理 PUBLISH 消息失败，deviceId: {}]", device.getId(), e);
316   - }
317   - }
318   -
319   - /**
320   - * 处理 PUBACK 消息（QoS 1 确认）
321   - */
322   - private void handlePubAck(ServerWebSocket socket, MqttMessage message) {
323   - String socketId = socketIdMap.get(socket);
324   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
325   - if (device == null) {
326   - log.warn("[handlePubAck][设备未认证，socketId: {}]", socketId);
327   - socket.close();
328   - return;
329   - }
330   -
331   - int messageId = ((MqttMessageIdVariableHeader) message.variableHeader()).messageId();
332   - log.debug("[handlePubAck][收到 PUBACK，messageId: {}，deviceId: {}]", messageId, device.getId());
333   - }
334   -
335   - /**
336   - * 处理 PUBREC 消息（QoS 2 第一步确认）
337   - */
338   - private void handlePubRec(ServerWebSocket socket, MqttMessage message) {
339   - String socketId = socketIdMap.get(socket);
340   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
341   - if (device == null) {
342   - log.warn("[handlePubRec][设备未认证，socketId: {}]", socketId);
343   - socket.close();
344   - return;
345   - }
346   -
347   - int messageId = ((MqttMessageIdVariableHeader) message.variableHeader()).messageId();
348   - log.debug("[handlePubRec][收到 PUBREC，messageId: {}，deviceId: {}]", messageId, device.getId());
349   - // 发送 PUBREL
350   - sendPubRel(socket, messageId);
351   - }
352   -
353   - /**
354   - * 处理 PUBREL 消息（QoS 2 第二步）
355   - */
356   - private void handlePubRel(ServerWebSocket socket, MqttMessage message) {
357   - String socketId = socketIdMap.get(socket);
358   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
359   -
360   - if (device == null) {
361   - log.warn("[handlePubRel][设备未认证，socketId: {}]", socketId);
362   - socket.close();
363   - return;
364   - }
365   -
366   - int messageId = ((MqttMessageIdVariableHeader) message.variableHeader()).messageId();
367   - log.debug("[handlePubRel][收到 PUBREL，messageId: {}，deviceId: {}]", messageId, device.getId());
368   - // 发送 PUBCOMP
369   - sendPubComp(socket, messageId);
370   - }
371   -
372   - /**
373   - * 处理 PUBCOMP 消息（QoS 2 完成确认）
374   - */
375   - private void handlePubComp(ServerWebSocket socket, MqttMessage message) {
376   - String socketId = socketIdMap.get(socket);
377   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
378   -
379   - if (device == null) {
380   - log.warn("[handlePubComp][设备未认证，socketId: {}]", socketId);
381   - socket.close();
382   - return;
383   - }
384   -
385   - int messageId = ((MqttMessageIdVariableHeader) message.variableHeader()).messageId();
386   - log.debug("[handlePubComp][收到 PUBCOMP，messageId: {}，deviceId: {}]", messageId, device.getId());
387   - }
388   -
389   - /**
390   - * 处理 SUBSCRIBE 消息（设备订阅主题）
391   - */
392   - private void handleSubscribe(ServerWebSocket socket, MqttSubscribeMessage message) {
393   - String socketId = socketIdMap.get(socket);
394   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
395   - if (device == null) {
396   - log.warn("[handleSubscribe][设备未认证，socketId: {}]", socketId);
397   - socket.close();
398   - return;
399   - }
400   -
401   - try {
402   - // 1. 解析 SUBSCRIBE 消息
403   - int messageId = message.variableHeader().messageId();
404   - MqttSubscribePayload payload = message.payload();
405   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
406   -
407   - log.info("[handleSubscribe][设备订阅请求，deviceKey: {}，messageId: {}，主题数量: {}]",
408   - deviceKey, messageId, payload.topicSubscriptions().size());
409   -
410   - // 2. 构建 QoS 列表并记录订阅信息
411   - int[] grantedQosList = new int[payload.topicSubscriptions().size()];
412   - for (int i = 0; i < payload.topicSubscriptions().size(); i++) {
413   - MqttTopicSubscription subscription = payload.topicSubscriptions().get(i);
414   - String topic = subscription.topicFilter();
415   - grantedQosList[i] = subscription.qualityOfService().value();
416   -
417   - // 记录订阅信息到连接管理器
418   - connectionManager.addSubscription(deviceKey, topic);
419   -
420   - log.info("[handleSubscribe][订阅主题: {}，QoS: {}，deviceKey: {}]",
421   - topic, subscription.qualityOfService(), deviceKey);
422   - }
423   -
424   - // 3. 发送 SUBACK
425   - sendSubAck(socket, messageId, grantedQosList);
426   - } catch (Exception e) {
427   - log.error("[handleSubscribe][处理 SUBSCRIBE 消息失败，deviceId: {}]", device.getId(), e);
428   - }
429   - }
430   -
431   - /**
432   - * 处理 UNSUBSCRIBE 消息（设备取消订阅）
433   - */
434   - private void handleUnsubscribe(ServerWebSocket socket, MqttUnsubscribeMessage message) {
435   - String socketId = socketIdMap.get(socket);
436   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
437   - if (device == null) {
438   - log.warn("[handleUnsubscribe][设备未认证，socketId: {}]", socketId);
439   - socket.close();
440   - return;
441   - }
442   -
443   - try {
444   - // 1. 解析 UNSUBSCRIBE 消息
445   - int messageId = message.variableHeader().messageId();
446   - MqttUnsubscribePayload payload = message.payload();
447   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
448   -
449   - log.info("[handleUnsubscribe][设备取消订阅，deviceKey: {}，messageId: {}，主题数量: {}]",
450   - deviceKey, messageId, payload.topics().size());
451   -
452   - // 2. 移除订阅信息
453   - for (String topic : payload.topics()) {
454   - connectionManager.removeSubscription(deviceKey, topic);
455   - log.info("[handleUnsubscribe][取消订阅主题: {}，deviceKey: {}]", topic, deviceKey);
456   - }
457   -
458   - // 3. 发送 UNSUBACK
459   - sendUnsubAck(socket, messageId);
460   - } catch (Exception e) {
461   - log.error("[handleUnsubscribe][处理 UNSUBSCRIBE 消息失败，deviceId: {}]", device.getId(), e);
462   - }
463   - }
464   -
465   - /**
466   - * 处理 PINGREQ 消息（心跳请求）
467   - */
468   - private void handlePingReq(ServerWebSocket socket) {
469   - String socketId = socketIdMap.get(socket);
470   - IotDeviceRespDTO device = socketDeviceMap.get(socketId);
471   - if (device == null) {
472   - log.warn("[handlePingReq][设备未认证，socketId: {}]", socketId);
473   - socket.close();
474   - return;
475   - }
476   -
477   - log.debug("[handlePingReq][收到心跳请求，deviceId: {}]", device.getId());
478   - // 发送 PINGRESP
479   - sendPingResp(socket);
480   - }
481   -
482   - /**
483   - * 处理 DISCONNECT 消息（设备断开连接）
484   - */
485   - private void handleDisconnect(ServerWebSocket socket) {
486   - String socketId = socketIdMap.get(socket);
487   - IotDeviceRespDTO device = socketDeviceMap.remove(socketId);
488   - if (device != null) {
489   - String deviceKey = device.getProductKey() + ":" + device.getDeviceName();
490   - connectionManager.removeConnection(deviceKey);
491   - deviceMessageIdMap.remove(deviceKey);
492   - sendOfflineMessage(device);
493   - log.info("[handleDisconnect][设备主动断开连接，deviceKey: {}]", deviceKey);
494   - }
495   -
496   - socket.close();
497   - }
498   -
499   - // ==================== 设备认证和状态相关方法 ====================
500   -
501   - /**
502   - * 设备认证
503   - */
504   - private IotDeviceRespDTO authenticateDevice(String clientId, String username, String password) {
505   - try {
506   - // 1. 参数校验
507   - if (StrUtil.hasEmpty(clientId, username, password)) {
508   - log.warn("[authenticateDevice][认证参数不完整，clientId: {}，username: {}]", clientId, username);
509   - return null;
510   - }
511   -
512   - // 2. 构建认证参数并调用 API
513   - IotDeviceAuthReqDTO authParams = new IotDeviceAuthReqDTO()
514   - .setClientId(clientId)
515   - .setUsername(username)
516   - .setPassword(password);
517   -
518   - CommonResult<Boolean> authResult = deviceApi.authDevice(authParams);
519   - if (!authResult.isSuccess() || !BooleanUtil.isTrue(authResult.getData())) {
520   - log.warn("[authenticateDevice][设备认证失败，clientId: {}]", clientId);
521   - return null;
522   - }
523   -
524   - // 3. 获取设备信息
525   - IotDeviceIdentity deviceInfo = IotDeviceAuthUtils.parseUsername(username);
526   - if (deviceInfo == null) {
527   - log.warn("[authenticateDevice][用户名格式不正确，username: {}]", username);
528   - return null;
529   - }
530   -
531   - IotDeviceGetReqDTO getReqDTO = new IotDeviceGetReqDTO()
532   - .setProductKey(deviceInfo.getProductKey())
533   - .setDeviceName(deviceInfo.getDeviceName());
534   -
535   - CommonResult<IotDeviceRespDTO> deviceResult = deviceApi.getDevice(getReqDTO);
536   - if (!deviceResult.isSuccess() || deviceResult.getData() == null) {
537   - log.warn("[authenticateDevice][获取设备信息失败，username: {}]", username);
538   - return null;
539   - }
540   -
541   - return deviceResult.getData();
542   - } catch (Exception e) {
543   - log.error("[authenticateDevice][设备认证异常，clientId: {}]", clientId, e);
544   - return null;
545   - }
546   - }
547   -
548   - /**
549   - * 发送设备上线消息
550   - */
551   - private void sendOnlineMessage(IotDeviceRespDTO device) {
552   - try {
553   - IotDeviceMessage onlineMessage = IotDeviceMessage.buildStateUpdateOnline();
554   - messageService.sendDeviceMessage(onlineMessage, device.getProductKey(),
555   - device.getDeviceName(), upstreamProtocol.getServerId());
556   - log.info("[sendOnlineMessage][设备上线，deviceId: {}]", device.getId());
557   - } catch (Exception e) {
558   - log.error("[sendOnlineMessage][发送设备上线消息失败，deviceId: {}]", device.getId(), e);
559   - }
560   - }
561   -
562   - /**
563   - * 发送设备离线消息
564   - */
565   - private void sendOfflineMessage(IotDeviceRespDTO device) {
566   - try {
567   - IotDeviceMessage offlineMessage = IotDeviceMessage.buildStateOffline();
568   - messageService.sendDeviceMessage(offlineMessage, device.getProductKey(),
569   - device.getDeviceName(), upstreamProtocol.getServerId());
570   - log.info("[sendOfflineMessage][设备离线，deviceId: {}]", device.getId());
571   - } catch (Exception e) {
572   - log.error("[sendOfflineMessage][发送设备离线消息失败，deviceId: {}]", device.getId(), e);
573   - }
574   - }
575   -
576   - // ==================== 发送响应消息的辅助方法 ====================
577   -
578   - /**
579   - * 发送 CONNACK 消息
580   - */
581   - private void sendConnAck(ServerWebSocket socket, MqttConnectReturnCode returnCode) {
582   - try {
583   - // 构建 CONNACK 消息
584   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
585   - MqttMessageType.CONNACK, false, MqttQoS.AT_MOST_ONCE, false, 0);
586   - MqttConnAckVariableHeader variableHeader = new MqttConnAckVariableHeader(returnCode, false);
587   - MqttConnAckMessage connAckMessage = new MqttConnAckMessage(fixedHeader, variableHeader);
588   -
589   - // 编码并发送
590   - sendMqttMessage(socket, connAckMessage);
591   - log.debug("[sendConnAck][发送 CONNACK 消息，returnCode: {}]", returnCode);
592   - } catch (Exception e) {
593   - log.error("[sendConnAck][发送 CONNACK 消息失败]", e);
594   - }
595   - }
596   -
597   - /**
598   - * 发送 PUBACK 消息（QoS 1 确认）
599   - */
600   - private void sendPubAck(ServerWebSocket socket, int messageId) {
601   - try {
602   - // 构建 PUBACK 消息
603   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
604   - MqttMessageType.PUBACK, false, MqttQoS.AT_MOST_ONCE, false, 0);
605   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
606   - MqttMessage pubAckMessage = new MqttMessage(fixedHeader, variableHeader);
607   -
608   - // 编码并发送
609   - sendMqttMessage(socket, pubAckMessage);
610   - log.debug("[sendPubAck][发送 PUBACK 消息，messageId: {}]", messageId);
611   - } catch (Exception e) {
612   - log.error("[sendPubAck][发送 PUBACK 消息失败，messageId: {}]", messageId, e);
613   - }
614   - }
615   -
616   - /**
617   - * 发送 PUBREC 消息（QoS 2 第一步确认）
618   - */
619   - private void sendPubRec(ServerWebSocket socket, int messageId) {
620   - try {
621   - // 构建 PUBREC 消息
622   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
623   - MqttMessageType.PUBREC, false, MqttQoS.AT_MOST_ONCE, false, 0);
624   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
625   - MqttMessage pubRecMessage = new MqttMessage(fixedHeader, variableHeader);
626   -
627   - // 编码并发送
628   - sendMqttMessage(socket, pubRecMessage);
629   - log.debug("[sendPubRec][发送 PUBREC 消息，messageId: {}]", messageId);
630   - } catch (Exception e) {
631   - log.error("[sendPubRec][发送 PUBREC 消息失败，messageId: {}]", messageId, e);
632   - }
633   - }
634   -
635   - /**
636   - * 发送 PUBREL 消息（QoS 2 第二步）
637   - */
638   - private void sendPubRel(ServerWebSocket socket, int messageId) {
639   - try {
640   - // 构建 PUBREL 消息
641   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
642   - MqttMessageType.PUBREL, false, MqttQoS.AT_LEAST_ONCE, false, 0);
643   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
644   - MqttMessage pubRelMessage = new MqttMessage(fixedHeader, variableHeader);
645   -
646   - // 编码并发送
647   - sendMqttMessage(socket, pubRelMessage);
648   - log.debug("[sendPubRel][发送 PUBREL 消息，messageId: {}]", messageId);
649   - } catch (Exception e) {
650   - log.error("[sendPubRel][发送 PUBREL 消息失败，messageId: {}]", messageId, e);
651   - }
652   - }
653   -
654   - /**
655   - * 发送 PUBCOMP 消息（QoS 2 完成确认）
656   - */
657   - private void sendPubComp(ServerWebSocket socket, int messageId) {
658   - try {
659   - // 构建 PUBCOMP 消息
660   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
661   - MqttMessageType.PUBCOMP, false, MqttQoS.AT_MOST_ONCE, false, 0);
662   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
663   - MqttMessage pubCompMessage = new MqttMessage(fixedHeader, variableHeader);
664   -
665   - // 编码并发送
666   - sendMqttMessage(socket, pubCompMessage);
667   - log.debug("[sendPubComp][发送 PUBCOMP 消息，messageId: {}]", messageId);
668   - } catch (Exception e) {
669   - log.error("[sendPubComp][发送 PUBCOMP 消息失败，messageId: {}]", messageId, e);
670   - }
671   - }
672   -
673   - /**
674   - * 发送 SUBACK 消息
675   - */
676   - private void sendSubAck(ServerWebSocket socket, int messageId, int[] grantedQosList) {
677   - try {
678   - // 构建 SUBACK 消息
679   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
680   - MqttMessageType.SUBACK, false, MqttQoS.AT_MOST_ONCE, false, 0);
681   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
682   - MqttSubAckPayload payload = new MqttSubAckPayload(grantedQosList);
683   - MqttSubAckMessage subAckMessage = new MqttSubAckMessage(fixedHeader, variableHeader, payload);
684   -
685   - // 编码并发送
686   - sendMqttMessage(socket, subAckMessage);
687   - log.debug("[sendSubAck][发送 SUBACK 消息，messageId: {}，主题数量: {}]", messageId, grantedQosList.length);
688   - } catch (Exception e) {
689   - log.error("[sendSubAck][发送 SUBACK 消息失败，messageId: {}]", messageId, e);
690   - }
691   - }
692   -
693   - /**
694   - * 发送 UNSUBACK 消息
695   - */
696   - private void sendUnsubAck(ServerWebSocket socket, int messageId) {
697   - try {
698   - // 构建 UNSUBACK 消息
699   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
700   - MqttMessageType.UNSUBACK, false, MqttQoS.AT_MOST_ONCE, false, 0);
701   - MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(messageId);
702   - MqttUnsubAckMessage unsubAckMessage = new MqttUnsubAckMessage(fixedHeader, variableHeader);
703   -
704   - // 编码并发送
705   - sendMqttMessage(socket, unsubAckMessage);
706   - log.debug("[sendUnsubAck][发送 UNSUBACK 消息，messageId: {}]", messageId);
707   - } catch (Exception e) {
708   - log.error("[sendUnsubAck][发送 UNSUBACK 消息失败，messageId: {}]", messageId, e);
709   - }
710   - }
711   -
712   - /**
713   - * 发送 PINGRESP 消息
714   - */
715   - private void sendPingResp(ServerWebSocket socket) {
716   - try {
717   - // 构建 PINGRESP 消息
718   - MqttFixedHeader fixedHeader = new MqttFixedHeader(
719   - MqttMessageType.PINGRESP, false, MqttQoS.AT_MOST_ONCE, false, 0);
720   - MqttMessage pingRespMessage = new MqttMessage(fixedHeader);
721   -
722   - // 编码并发送
723   - sendMqttMessage(socket, pingRespMessage);
724   - log.debug("[sendPingResp][发送 PINGRESP 消息]");
725   - } catch (Exception e) {
726   - log.error("[sendPingResp][发送 PINGRESP 消息失败]", e);
727   - }
728   - }
729   -
730   - /**
731   - * 发送 MQTT 消息到 WebSocket
732   - */
733   - private void sendMqttMessage(ServerWebSocket socket, MqttMessage mqttMessage) {
734   - ByteBuf byteBuf = null;
735   - try {
736   - // 使用 EmbeddedChannel 编码 MQTT 消息
737   - EmbeddedChannel encoderChannel = encoderChannelThreadLocal.get();
738   - encoderChannel.writeOutbound(mqttMessage);
739   -
740   - // 读取编码后的 ByteBuf
741   - byteBuf = encoderChannel.readOutbound();
742   - if (byteBuf != null) {
743   - byte[] bytes = new byte[byteBuf.readableBytes()];
744   - byteBuf.readBytes(bytes);
745   - socket.writeBinaryMessage(Buffer.buffer(bytes));
746   - }
747   - } finally {
748   - if (byteBuf != null) {
749   - byteBuf.release();
750   - }
751   - }
752   - }
753   -
754   -}
yudao-module-iot/yudao-module-iot-gateway/src/main/resources/application.yaml
  View file @b87bc19
... ... @@ -115,23 +115,10 @@ yudao:
115 115 connect-timeout-seconds: 60
116 116 ssl-enabled: false
117 117 # ====================================
118   - # 针对引入的 MQTT WebSocket 组件的配置
119   - # ====================================
120   - mqtt-ws:
121   - enabled: false # 是否启用 MQTT WebSocket
122   - port: 8083 # WebSocket 服务端口
123   - path: /mqtt # WebSocket 路径
124   - max-message-size: 8192 # 最大消息大小（字节）
125   - max-frame-size: 65536 # 最大帧大小（字节）
126   - connect-timeout-seconds: 60 # 连接超时时间（秒）
127   - keep-alive-timeout-seconds: 300 # 保持连接超时时间（秒）
128   - ssl-enabled: false # 是否启用 SSL（wss://）
129   - sub-protocol: mqtt # WebSocket 子协议
130   - # ====================================
131 118 # 针对引入的 CoAP 组件的配置
132 119 # ====================================
133 120 coap:
134   - enabled: true # 是否启用 CoAP 协议
  121 + enabled: false # 是否启用 CoAP 协议
135 122 port: 5683 # CoAP 服务端口（默认 5683）
136 123 max-message-size: 1024 # 最大消息大小（字节）
137 124 ack-timeout: 2000 # ACK 超时时间（毫秒）
... ...