package cn.iocoder.yudao.module.iot.gateway.protocol.tcp;
|
|
import cn.hutool.core.collection.ListUtil;
|
import cn.hutool.core.map.MapUtil;
|
import cn.hutool.core.util.IdUtil;
|
import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
|
import cn.iocoder.yudao.module.iot.core.enums.IotDeviceMessageMethodEnum;
|
import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
|
import cn.iocoder.yudao.module.iot.core.topic.IotDeviceIdentity;
|
import cn.iocoder.yudao.module.iot.core.topic.auth.IotSubDeviceRegisterReqDTO;
|
import cn.iocoder.yudao.module.iot.core.topic.property.IotDevicePropertyPackPostReqDTO;
|
import cn.iocoder.yudao.module.iot.core.topic.topo.IotDeviceTopoAddReqDTO;
|
import cn.iocoder.yudao.module.iot.core.topic.topo.IotDeviceTopoDeleteReqDTO;
|
import cn.iocoder.yudao.module.iot.core.topic.topo.IotDeviceTopoGetReqDTO;
|
import cn.iocoder.yudao.module.iot.core.util.IotDeviceAuthUtils;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.codec.IotTcpCodecTypeEnum;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.codec.IotTcpFrameCodec;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.tcp.codec.IotTcpFrameCodecFactory;
|
import cn.iocoder.yudao.module.iot.gateway.serialize.IotMessageSerializer;
|
import cn.iocoder.yudao.module.iot.gateway.serialize.json.IotJsonSerializer;
|
import io.vertx.core.Vertx;
|
import io.vertx.core.buffer.Buffer;
|
import io.vertx.core.net.NetClient;
|
import io.vertx.core.net.NetClientOptions;
|
import io.vertx.core.net.NetSocket;
|
import io.vertx.core.parsetools.RecordParser;
|
import lombok.extern.slf4j.Slf4j;
|
import org.junit.jupiter.api.AfterAll;
|
import org.junit.jupiter.api.BeforeAll;
|
import org.junit.jupiter.api.Disabled;
|
import org.junit.jupiter.api.Test;
|
|
import java.util.Collections;
|
import java.util.Map;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* IoT 网关设备 TCP 协议集成测试（手动测试）
|
*
|
* <p>测试场景：网关设备（IotProductDeviceTypeEnum 的 GATEWAY 类型）通过 TCP 协议管理子设备拓扑关系
|
*
|
* <p>使用步骤：
|
* <ol>
|
* <li>启动 yudao-module-iot-gateway 服务（TCP 端口 8091）</li>
|
* <li>运行以下测试方法：
|
* <ul>
|
* <li>{@link #testAuth()} - 网关设备认证</li>
|
* <li>{@link #testTopoAdd()} - 添加子设备拓扑关系</li>
|
* <li>{@link #testTopoDelete()} - 删除子设备拓扑关系</li>
|
* <li>{@link #testTopoGet()} - 获取子设备拓扑关系</li>
|
* <li>{@link #testSubDeviceRegister()} - 子设备动态注册</li>
|
* <li>{@link #testPropertyPackPost()} - 批量上报属性（网关 + 子设备）</li>
|
* </ul>
|
* </li>
|
* </ol>
|
*
|
* <p>注意：TCP 协议是有状态的长连接，认证成功后同一连接上的后续请求无需再携带认证信息
|
*
|
* @author 芋道源码
|
*/
|
@Slf4j
|
@Disabled
|
public class IotGatewayDeviceTcpProtocolIntegrationTest {
|
|
private static final String SERVER_HOST = "127.0.0.1";
|
private static final int SERVER_PORT = 8091;
|
private static final int TIMEOUT_MS = 5000;
|
|
private static Vertx vertx;
|
private static NetClient netClient;
|
|
// ===================== 编解码器 =====================
|
|
/**
|
* 消息序列化器
|
*/
|
private static final IotMessageSerializer SERIALIZER = new IotJsonSerializer();
|
|
/**
|
* TCP 帧编解码器
|
*/
|
private static final IotTcpFrameCodec FRAME_CODEC = IotTcpFrameCodecFactory.create(
|
new IotTcpConfig.CodecConfig()
|
.setType(IotTcpCodecTypeEnum.DELIMITER.getType())
|
.setDelimiter("\\n")
|
// .setType(IotTcpCodecTypeEnum.LENGTH_FIELD.getType())
|
// .setLengthFieldOffset(0)
|
// .setLengthFieldLength(4)
|
// .setLengthAdjustment(0)
|
// .setInitialBytesToStrip(4)
|
// .setType(IotTcpCodecTypeEnum.LENGTH_FIELD.getType())
|
// .setFixedLength(256)
|
);
|
|
// ===================== 网关设备信息（根据实际情况修改，从 iot_device 表查询网关设备） =====================
|
|
private static final String GATEWAY_PRODUCT_KEY = "m6XcS1ZJ3TW8eC0v";
|
private static final String GATEWAY_DEVICE_NAME = "sub-ddd";
|
private static final String GATEWAY_DEVICE_SECRET = "b3d62c70f8a4495487ed1d35d61ac2b3";
|
|
// ===================== 子设备信息（根据实际情况修改，从 iot_device 表查询子设备） =====================
|
|
private static final String SUB_DEVICE_PRODUCT_KEY = "jAufEMTF1W6wnPhn";
|
private static final String SUB_DEVICE_NAME = "chazuo-it";
|
private static final String SUB_DEVICE_SECRET = "d46ef9b28ab14238b9c00a3a668032af";
|
|
@BeforeAll
|
static void setUp() {
|
vertx = Vertx.vertx();
|
NetClientOptions options = new NetClientOptions()
|
.setConnectTimeout(TIMEOUT_MS)
|
.setIdleTimeout(TIMEOUT_MS);
|
netClient = vertx.createNetClient(options);
|
}
|
|
@AfterAll
|
static void tearDown() {
|
if (netClient != null) {
|
netClient.close();
|
}
|
if (vertx != null) {
|
vertx.close();
|
}
|
}
|
|
// ===================== 认证测试 =====================
|
|
/**
|
* 网关设备认证测试：获取网关设备 Token
|
*/
|
@Test
|
public void testAuth() throws Exception {
|
// 1. 构建认证消息
|
IotDeviceAuthReqDTO authInfo = IotDeviceAuthUtils.getAuthInfo(
|
GATEWAY_PRODUCT_KEY, GATEWAY_DEVICE_NAME, GATEWAY_DEVICE_SECRET);
|
IotDeviceAuthReqDTO authReqDTO = new IotDeviceAuthReqDTO()
|
.setClientId(authInfo.getClientId())
|
.setUsername(authInfo.getUsername())
|
.setPassword(authInfo.getPassword());
|
IotDeviceMessage request = IotDeviceMessage.requestOf("auth", authReqDTO);
|
|
// 2. 发送并接收响应
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testAuth][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 拓扑管理测试 =====================
|
|
/**
|
* 添加子设备拓扑关系测试
|
*/
|
@Test
|
public void testTopoAdd() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先进行认证
|
IotDeviceMessage authResponse = authenticate(socket);
|
log.info("[testTopoAdd][认证响应: {}]", authResponse);
|
|
// 2.1 构建子设备认证信息
|
IotDeviceAuthReqDTO subAuthInfo = IotDeviceAuthUtils.getAuthInfo(
|
SUB_DEVICE_PRODUCT_KEY, SUB_DEVICE_NAME, SUB_DEVICE_SECRET);
|
IotDeviceAuthReqDTO subDeviceAuth = new IotDeviceAuthReqDTO()
|
.setClientId(subAuthInfo.getClientId())
|
.setUsername(subAuthInfo.getUsername())
|
.setPassword(subAuthInfo.getPassword());
|
// 2.2 构建请求参数
|
IotDeviceTopoAddReqDTO params = new IotDeviceTopoAddReqDTO();
|
params.setSubDevices(Collections.singletonList(subDeviceAuth));
|
IotDeviceMessage request = IotDeviceMessage.requestOf(
|
IdUtil.fastSimpleUUID(),
|
IotDeviceMessageMethodEnum.TOPO_ADD.getMethod(),
|
params);
|
|
// 3. 发送并接收响应
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testTopoAdd][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
/**
|
* 删除子设备拓扑关系测试
|
*/
|
@Test
|
public void testTopoDelete() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先进行认证
|
IotDeviceMessage authResponse = authenticate(socket);
|
log.info("[testTopoDelete][认证响应: {}]", authResponse);
|
|
// 2. 构建请求参数
|
IotDeviceTopoDeleteReqDTO params = new IotDeviceTopoDeleteReqDTO();
|
params.setSubDevices(Collections.singletonList(
|
new IotDeviceIdentity(SUB_DEVICE_PRODUCT_KEY, SUB_DEVICE_NAME)));
|
IotDeviceMessage request = IotDeviceMessage.requestOf(
|
IotDeviceMessageMethodEnum.TOPO_DELETE.getMethod(),
|
params);
|
|
// 3. 发送并接收响应
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testTopoDelete][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
/**
|
* 获取子设备拓扑关系测试
|
*/
|
@Test
|
public void testTopoGet() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先进行认证
|
IotDeviceMessage authResponse = authenticate(socket);
|
log.info("[testTopoGet][认证响应: {}]", authResponse);
|
|
// 2. 构建请求参数
|
IotDeviceTopoGetReqDTO params = new IotDeviceTopoGetReqDTO();
|
IotDeviceMessage request = IotDeviceMessage.requestOf(
|
IotDeviceMessageMethodEnum.TOPO_GET.getMethod(),
|
params);
|
|
// 3. 发送并接收响应
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testTopoGet][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 子设备注册测试 =====================
|
|
/**
|
* 子设备动态注册测试
|
*/
|
@Test
|
public void testSubDeviceRegister() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先进行认证
|
IotDeviceMessage authResponse = authenticate(socket);
|
log.info("[testSubDeviceRegister][认证响应: {}]", authResponse);
|
|
// 2. 构建请求参数
|
IotSubDeviceRegisterReqDTO subDevice = new IotSubDeviceRegisterReqDTO()
|
.setProductKey(SUB_DEVICE_PRODUCT_KEY)
|
.setDeviceName("mougezishebei");
|
IotDeviceMessage request = IotDeviceMessage.requestOf(
|
IotDeviceMessageMethodEnum.SUB_DEVICE_REGISTER.getMethod(),
|
Collections.singletonList(subDevice));
|
|
// 3. 发送并接收响应
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testSubDeviceRegister][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 批量上报测试 =====================
|
|
/**
|
* 批量上报属性测试（网关 + 子设备）
|
*/
|
@Test
|
public void testPropertyPackPost() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先进行认证
|
IotDeviceMessage authResponse = authenticate(socket);
|
log.info("[testPropertyPackPost][认证响应: {}]", authResponse);
|
|
// 2.1 构建【网关设备】自身属性
|
Map<String, Object> gatewayProperties = MapUtil.<String, Object>builder()
|
.put("temperature", 25.5)
|
.build();
|
// 2.2 构建【网关设备】自身事件
|
IotDevicePropertyPackPostReqDTO.EventValue gatewayEvent = new IotDevicePropertyPackPostReqDTO.EventValue()
|
.setValue(MapUtil.builder().put("message", "gateway started").build())
|
.setTime(System.currentTimeMillis());
|
Map<String, IotDevicePropertyPackPostReqDTO.EventValue> gatewayEvents = MapUtil.<String, IotDevicePropertyPackPostReqDTO.EventValue>builder()
|
.put("statusReport", gatewayEvent)
|
.build();
|
// 2.3 构建【网关子设备】属性
|
Map<String, Object> subDeviceProperties = MapUtil.<String, Object>builder()
|
.put("power", 100)
|
.build();
|
// 2.4 构建【网关子设备】事件
|
IotDevicePropertyPackPostReqDTO.EventValue subDeviceEvent = new IotDevicePropertyPackPostReqDTO.EventValue()
|
.setValue(MapUtil.builder().put("errorCode", 0).build())
|
.setTime(System.currentTimeMillis());
|
Map<String, IotDevicePropertyPackPostReqDTO.EventValue> subDeviceEvents = MapUtil.<String, IotDevicePropertyPackPostReqDTO.EventValue>builder()
|
.put("healthCheck", subDeviceEvent)
|
.build();
|
// 2.5 构建子设备数据
|
IotDevicePropertyPackPostReqDTO.SubDeviceData subDeviceData = new IotDevicePropertyPackPostReqDTO.SubDeviceData()
|
.setIdentity(new IotDeviceIdentity(SUB_DEVICE_PRODUCT_KEY, SUB_DEVICE_NAME))
|
.setProperties(subDeviceProperties)
|
.setEvents(subDeviceEvents);
|
// 2.6 构建请求参数
|
IotDevicePropertyPackPostReqDTO params = new IotDevicePropertyPackPostReqDTO();
|
params.setProperties(gatewayProperties);
|
params.setEvents(gatewayEvents);
|
params.setSubDevices(ListUtil.of(subDeviceData));
|
IotDeviceMessage request = IotDeviceMessage.requestOf(
|
IotDeviceMessageMethodEnum.PROPERTY_PACK_POST.getMethod(),
|
params);
|
|
// 3. 发送并接收响应
|
IotDeviceMessage response = sendAndReceive(socket, request);
|
log.info("[testPropertyPackPost][响应消息: {}]", response);
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 辅助方法 =====================
|
|
/**
|
* 建立 TCP 连接
|
*
|
* @return 连接 Future
|
*/
|
private CompletableFuture<NetSocket> connect() {
|
CompletableFuture<NetSocket> future = new CompletableFuture<>();
|
netClient.connect(SERVER_PORT, SERVER_HOST)
|
.onSuccess(future::complete)
|
.onFailure(future::completeExceptionally);
|
return future;
|
}
|
|
/**
|
* 执行网关设备认证
|
*
|
* @param socket TCP 连接
|
* @return 认证响应消息
|
*/
|
private IotDeviceMessage authenticate(NetSocket socket) throws Exception {
|
IotDeviceAuthReqDTO authInfo = IotDeviceAuthUtils.getAuthInfo(
|
GATEWAY_PRODUCT_KEY, GATEWAY_DEVICE_NAME, GATEWAY_DEVICE_SECRET);
|
IotDeviceMessage request = IotDeviceMessage.requestOf("auth", authInfo);
|
return sendAndReceive(socket, request);
|
}
|
|
/**
|
* 发送消息并接收响应（复用 IotTcpFrameCodec 编解码逻辑）
|
*
|
* @param socket TCP 连接
|
* @param request 请求消息
|
* @return 响应消息
|
*/
|
private IotDeviceMessage sendAndReceive(NetSocket socket, IotDeviceMessage request) throws Exception {
|
// 1. 使用 FRAME_CODEC 创建解码器（复用 gateway 的拆包逻辑）
|
CompletableFuture<IotDeviceMessage> responseFuture = new CompletableFuture<>();
|
RecordParser parser = FRAME_CODEC.createDecodeParser(buffer -> {
|
try {
|
// 反序列化响应
|
IotDeviceMessage response = SERIALIZER.deserialize(buffer.getBytes());
|
responseFuture.complete(response);
|
} catch (Exception e) {
|
responseFuture.completeExceptionally(e);
|
}
|
});
|
socket.handler(parser);
|
|
// 2.1 序列化 + 帧编码
|
byte[] serializedData = SERIALIZER.serialize(request);
|
Buffer frameData = FRAME_CODEC.encode(serializedData);
|
log.info("[sendAndReceive][发送消息: {}，数据长度: {} 字节]", request.getMethod(), frameData.length());
|
// 2.2 发送请求
|
socket.write(frameData);
|
|
// 3. 等待响应
|
IotDeviceMessage response = responseFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
log.info("[sendAndReceive][收到响应，数据长度: {} 字节]",
|
SERIALIZER.serialize(response).length);
|
return response;
|
}
|
|
}
|
