reactor：【IoT 物联网】优化设备缓存的加载逻辑

YunaiV
1 parent 66b42367
Showing 26 changed files with 352 additions and 550 deletions
yudao-module-iot/yudao-module-iot-api/src/main/java/cn/iocoder/yudao/module/iot/enums/DictTypeConstants.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/api/device/IoTDeviceApiImpl.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/dataobject/product/IotProductDO.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/redis/RedisKeyConstants.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/mq/consumer/device/IotDeviceMessageSubscriber.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceService.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceServiceImpl.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/product/IotProductService.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/product/IotProductServiceImpl.java
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/rule/action/IotRuleSceneDeviceControlAction.java
yudao-module-iot/yudao-module-iot-biz/src/main/resources/mapper/device/IotDeviceMessageMapper.xml
yudao-module-iot/yudao-module-iot-core/src/main/java/cn/iocoder/yudao/module/iot/core/biz/IotDeviceCommonApi.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/enums/ErrorCodeConstants.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/http/router/IotHttpAbstractHandler.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/http/router/IotHttpAuthHandler.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/protocol/http/router/IotHttpUpstreamHandler.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/service/auth/IotDeviceTokenServiceImpl.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/service/device/IotDeviceCacheService.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/service/device/IotDeviceCacheServiceImpl.java
yudao-module-iot/yudao-module-iot-gateway/src/main/java/cn/iocoder/yudao/module/iot/gateway/service/device/IotDeviceService.java
@@ -16,4 +16,6 @@ public class DictTypeConstants {
     public static final String DEVICE_STATE = "iot_device_state";
+    public static final String CODEC_TYPE = "iot_codec_type";
+
 }
@@ -2,12 +2,15 @@ package cn.iocoder.yudao.module.iot.api.device;
 import cn.iocoder.yudao.framework.common.enums.RpcConstants;
 import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
 import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
 import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
+import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
 import cn.iocoder.yudao.module.iot.service.device.IotDeviceService;
+import cn.iocoder.yudao.module.iot.service.product.IotProductService;
 import jakarta.annotation.Resource;
 import jakarta.annotation.security.PermitAll;
 import org.springframework.context.annotation.Primary;
@@ -30,6 +33,8 @@ public class IoTDeviceApiImpl implements IotDeviceCommonApi {
     @Resource
     private IotDeviceService deviceService;
+    @Resource
+    private IotProductService productService;
     @Override
     @PostMapping(RpcConstants.RPC_API_PREFIX + "/iot/device/auth")
@@ -39,24 +44,17 @@ public class IoTDeviceApiImpl implements IotDeviceCommonApi {
     }
     @Override
-    @PostMapping(RpcConstants.RPC_API_PREFIX + "/iot/device/info")
+    @PostMapping(RpcConstants.RPC_API_PREFIX + "/iot/device/get") // 特殊：方便调用，暂时使用 POST，实际更推荐 GET
     @PermitAll
-    public CommonResult<IotDeviceInfoRespDTO> getDeviceInfo(@RequestBody IotDeviceInfoReqDTO infoReqDTO) {
-        IotDeviceDO device = deviceService.getDeviceByProductKeyAndDeviceNameFromCache(
-                infoReqDTO.getProductKey(), infoReqDTO.getDeviceName());
-
-        if (device == null) {
-            return success(null);
-        }
-
-        IotDeviceInfoRespDTO respDTO = new IotDeviceInfoRespDTO();
-        respDTO.setDeviceId(device.getId());
-        respDTO.setProductKey(device.getProductKey());
-        respDTO.setDeviceName(device.getDeviceName());
-        respDTO.setDeviceKey(device.getDeviceKey());
-        respDTO.setTenantId(device.getTenantId());
-
-        return success(respDTO);
+    public CommonResult<IotDeviceRespDTO> getDevice(@RequestBody IotDeviceGetReqDTO getReqDTO) {
+        IotDeviceDO device = getReqDTO.getId() != null ? deviceService.getDeviceFromCache(getReqDTO.getId())
+                : deviceService.getDeviceFromCache(getReqDTO.getProductKey(), getReqDTO.getDeviceName());
+        return success(BeanUtils.toBean(device, IotDeviceRespDTO.class, deviceDTO -> {
+            IotProductDO product = productService.getProductFromCache(deviceDTO.getProductId());
+            if (product != null) {
+                deviceDTO.setCodecType(product.getCodecType());
+            }
+        }));
     }
 }
 \ No newline at end of file
@@ -71,6 +71,12 @@ public class IotProductDO extends TenantBaseDO {
     private Integer netType;
     /**
+     * 编解码器类型
+     *
+     * 字典 {@link cn.iocoder.yudao.module.iot.enums.DictTypeConstants#CODEC_TYPE}
+     */
+    private String codecType;
+    /**
      * 接入网关协议
      * <p>
      * 枚举 {@link cn.iocoder.yudao.module.iot.enums.product.IotProtocolTypeEnum}
@@ -39,12 +39,21 @@ public interface RedisKeyConstants {
     /**
      * 设备信息的数据缓存，使用 Spring Cache 操作（忽略租户）
      *
-     * KEY 格式：device_${productKey}_${deviceName}
+     * KEY 格式 1：device_${id}
+     * KEY 格式 2：device_${productKey}_${deviceName}
      * VALUE 数据类型：String(JSON)
      */
     String DEVICE = "iot:device";
     /**
+     * 产品信息的数据缓存，使用 Spring Cache 操作（忽略租户）
+     *
+     * KEY 格式：product_${id}
+     * VALUE 数据类型：String(JSON)
+     */
+    String PRODUCT = "iot:product";
+
+    /**
      * 物模型的数据缓存，使用 Spring Cache 操作（忽略租户）
      *
      * KEY 格式：thing_model_${productKey}
@@ -2,6 +2,7 @@ package cn.iocoder.yudao.module.iot.mq.consumer.device;
 import cn.hutool.core.util.ObjectUtil;
 import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
+import cn.iocoder.yudao.framework.tenant.core.util.TenantUtils;
 import cn.iocoder.yudao.module.iot.core.enums.IotDeviceMessageMethodEnum;
 import cn.iocoder.yudao.module.iot.core.enums.IotDeviceStateEnum;
 import cn.iocoder.yudao.module.iot.core.messagebus.core.IotMessageBus;
@@ -61,18 +62,19 @@ public class IotDeviceMessageSubscriber implements IotMessageSubscriber&lt;IotDevic
             return;
         }
-        // 1.1 更新设备的最后时间
-        // TODO 芋艿：后续加缓存；
-        IotDeviceDO device = deviceService.validateDeviceExists(message.getDeviceId());
-        devicePropertyService.updateDeviceReportTime(device.getProductKey(), device.getDeviceName(), LocalDateTime.now());
-        // 1.2 更新设备的连接 server
-        devicePropertyService.updateDeviceServerId(device.getProductKey(), device.getDeviceName(), message.getServerId());
+        TenantUtils.execute(message.getTenantId(), () -> {
+            // 1.1 更新设备的最后时间
+            IotDeviceDO device = deviceService.validateDeviceExistsFromCache(message.getDeviceId());
+            devicePropertyService.updateDeviceReportTime(device.getProductKey(), device.getDeviceName(), LocalDateTime.now());
+            // 1.2 更新设备的连接 server
+            devicePropertyService.updateDeviceServerId(device.getProductKey(), device.getDeviceName(), message.getServerId());
-        // 2. 未上线的设备，强制上线
-        forceDeviceOnline(message, device);
+            // 2. 未上线的设备，强制上线
+            forceDeviceOnline(message, device);
-        // 3. 核心：处理消息
-        deviceMessageService.handleUpstreamDeviceMessage(message, device);
+            // 3. 核心：处理消息
+            deviceMessageService.handleUpstreamDeviceMessage(message, device);
+        });
     }
     private void forceDeviceOnline(IotDeviceMessage message, IotDeviceDO device) {
@@ -106,6 +106,14 @@ public interface IotDeviceService {
     IotDeviceDO validateDeviceExists(Long id);
     /**
+     * 【缓存】校验设备是否存在
+     *
+     * @param id 设备 ID
+     * @return 设备对象
+     */
+    IotDeviceDO validateDeviceExistsFromCache(Long id);
+
+    /**
      * 获得设备
      *
      * @param id 编号
@@ -114,6 +122,27 @@ public interface IotDeviceService {
     IotDeviceDO getDevice(Long id);
     /**
+     * 【缓存】获得设备信息
+     * <p>
+     * 注意：该方法会忽略租户信息，所以调用时，需要确认会不会有跨租户访问的风险！！！
+     *
+     * @param id 编号
+     * @return IoT 设备
+     */
+    IotDeviceDO getDeviceFromCache(Long id);
+
+    /**
+     * 【缓存】根据产品 key 和设备名称，获得设备信息
+     * <p>
+     * 注意：该方法会忽略租户信息，所以调用时，需要确认会不会有跨租户访问的风险！！！
+     *
+     * @param productKey 产品 key
+     * @param deviceName 设备名称
+     * @return 设备信息
+     */
+    IotDeviceDO getDeviceFromCache(String productKey, String deviceName);
+
+    /**
      * 根据设备 key 获得设备
      *
      * @param deviceKey 编号
@@ -178,17 +207,6 @@ public interface IotDeviceService {
     Long getDeviceCountByGroupId(Long groupId);
     /**
-     * 【缓存】根据产品 key 和设备名称，获得设备信息
-     * <p>
-     * 注意：该方法会忽略租户信息，所以调用时，需要确认会不会有跨租户访问的风险！！！
-     *
-     * @param productKey 产品 key
-     * @param deviceName 设备名称
-     * @return 设备信息
-     */
-    IotDeviceDO getDeviceByProductKeyAndDeviceNameFromCache(String productKey, String deviceName);
-
-    /**
      * 导入设备
      *
      * @param importDevices 导入设备列表
@@ -28,6 +28,7 @@ import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -221,6 +222,15 @@ public class IotDeviceServiceImpl implements IotDeviceService {
         return device;
     }
+    @Override
+    public IotDeviceDO validateDeviceExistsFromCache(Long id) {
+        IotDeviceDO device = getSelf().getDeviceFromCache(id);
+        if (device == null) {
+            throw exception(DEVICE_NOT_EXISTS);
+        }
+        return device;
+    }
+
     /**
      * 校验网关设备是否存在
      *
@@ -242,6 +252,20 @@ public class IotDeviceServiceImpl implements IotDeviceService {
     }
     @Override
+    @Cacheable(value = RedisKeyConstants.DEVICE, key = "#id", unless = "#result == null")
+    @TenantIgnore // 忽略租户信息
+    public IotDeviceDO getDeviceFromCache(Long id) {
+        return deviceMapper.selectById(id);
+    }
+
+    @Override
+    @Cacheable(value = RedisKeyConstants.DEVICE, key = "#productKey + '_' + #deviceName", unless = "#result == null")
+    @TenantIgnore // 忽略租户信息，跨租户 productKey + deviceName 是唯一的
+    public IotDeviceDO getDeviceFromCache(String productKey, String deviceName) {
+        return deviceMapper.selectByProductKeyAndDeviceName(productKey, deviceName);
+    }
+
+    @Override
     public IotDeviceDO getDeviceByDeviceKey(String deviceKey) {
         return deviceMapper.selectByDeviceKey(deviceKey);
     }
@@ -308,13 +332,6 @@ public class IotDeviceServiceImpl implements IotDeviceService {
         return deviceMapper.selectCountByGroupId(groupId);
     }
-    @Override
-    @Cacheable(value = RedisKeyConstants.DEVICE, key = "#productKey + '_' + #deviceName", unless = "#result == null")
-    @TenantIgnore // 忽略租户信息，跨租户 productKey + deviceName 是唯一的
-    public IotDeviceDO getDeviceByProductKeyAndDeviceNameFromCache(String productKey, String deviceName) {
-        return deviceMapper.selectByProductKeyAndDeviceName(productKey, deviceName);
-    }
-
     /**
      * 生成 deviceKey
      *
@@ -425,14 +442,13 @@ public class IotDeviceServiceImpl implements IotDeviceService {
         devices.forEach(this::deleteDeviceCache);
     }
-    @CacheEvict(value = RedisKeyConstants.DEVICE, key = "#device.productKey + '_' + #device.deviceName")
+    @Caching(evict = {
+        @CacheEvict(value = RedisKeyConstants.DEVICE, key = "#device.id"),
+        @CacheEvict(value = RedisKeyConstants.DEVICE, key = "#device.productKey + '_' + #device.deviceName")
+    })
     public void deleteDeviceCache0(IotDeviceDO device) {
     }
-    private IotDeviceServiceImpl getSelf() {
-        return SpringUtil.getBean(getClass());
-    }
-
     @Override
     public Long getDeviceCount(LocalDateTime createTime) {
         return deviceMapper.selectCountByCreateTime(createTime);
@@ -477,7 +493,7 @@ public class IotDeviceServiceImpl implements IotDeviceService {
         }
         String deviceName = deviceInfo.getDeviceName();
         String productKey = deviceInfo.getProductKey();
-        IotDeviceDO device = getSelf().getDeviceByProductKeyAndDeviceNameFromCache(productKey, deviceName);
+        IotDeviceDO device = getSelf().getDeviceFromCache(productKey, deviceName);
         if (device == null) {
             log.warn("[authDevice][设备({}/{}) 不存在]", productKey, deviceName);
             return false;
@@ -492,4 +508,8 @@ public class IotDeviceServiceImpl implements IotDeviceService {
         return true;
     }
+    private IotDeviceServiceImpl getSelf() {
+        return SpringUtil.getBean(getClass());
+    }
+
 }
@@ -48,6 +48,16 @@ public interface IotProductService {
     IotProductDO getProduct(Long id);
     /**
+     * 【缓存】获得产品
+     * <p>
+     * 注意：该方法会忽略租户信息，所以调用时，需要确认会不会有跨租户访问的风险！！！
+     *
+     * @param id 编号
+     * @return 产品
+     */
+    IotProductDO getProductFromCache(Long id);
+
+    /**
      * 根据产品 key 获得产品
      *
      * @param productKey 产品 key
@@ -2,15 +2,19 @@ package cn.iocoder.yudao.module.iot.service.product;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
+import cn.iocoder.yudao.framework.tenant.core.aop.TenantIgnore;
 import cn.iocoder.yudao.framework.tenant.core.util.TenantUtils;
 import cn.iocoder.yudao.module.iot.controller.admin.product.vo.product.IotProductPageReqVO;
 import cn.iocoder.yudao.module.iot.controller.admin.product.vo.product.IotProductSaveReqVO;
 import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
 import cn.iocoder.yudao.module.iot.dal.mysql.product.IotProductMapper;
+import cn.iocoder.yudao.module.iot.dal.redis.RedisKeyConstants;
 import cn.iocoder.yudao.module.iot.enums.product.IotProductStatusEnum;
 import cn.iocoder.yudao.module.iot.service.device.property.IotDevicePropertyService;
 import com.baomidou.dynamic.datasource.annotation.DSTransactional;
 import jakarta.annotation.Resource;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.validation.annotation.Validated;
@@ -56,6 +60,7 @@ public class IotProductServiceImpl implements IotProductService {
     }
     @Override
+    @CacheEvict(value = RedisKeyConstants.PRODUCT, key = "#updateReqVO.id")
     public void updateProduct(IotProductSaveReqVO updateReqVO) {
         updateReqVO.setProductKey(null); // 不更新产品标识
         // 1.1 校验存在
@@ -68,6 +73,7 @@ public class IotProductServiceImpl implements IotProductService {
     }
     @Override
+    @CacheEvict(value = RedisKeyConstants.PRODUCT, key = "#id")
     public void deleteProduct(Long id) {
         // 1.1 校验存在
         IotProductDO iotProductDO = validateProductExists(id);
@@ -107,6 +113,13 @@ public class IotProductServiceImpl implements IotProductService {
     }
     @Override
+    @Cacheable(value = RedisKeyConstants.PRODUCT, key = "#id", unless = "#result == null")
+    @TenantIgnore // 忽略租户信息
+    public IotProductDO getProductFromCache(Long id) {
+        return productMapper.selectById(id);
+    }
+
+    @Override
     public IotProductDO getProductByProductKey(String productKey) {
         return productMapper.selectByProductKey(productKey);
     }
@@ -118,6 +131,7 @@ public class IotProductServiceImpl implements IotProductService {
     @Override
     @DSTransactional(rollbackFor = Exception.class)
+    @CacheEvict(value = RedisKeyConstants.PRODUCT, key = "#id")
     public void updateProductStatus(Long id, Integer status) {
         // 1. 校验存在
         validateProductExists(id);
@@ -143,5 +157,4 @@ public class IotProductServiceImpl implements IotProductService {
         return productMapper.selectCountByCreateTime(createTime);
     }
-
 }
 \ No newline at end of file
@@ -31,7 +31,7 @@ public class IotRuleSceneDeviceControlAction implements IotRuleSceneAction {
         Assert.notNull(control, "设备控制配置不能为空");
         // 遍历每个设备，下发消息
         control.getDeviceNames().forEach(deviceName -> {
-            IotDeviceDO device = deviceService.getDeviceByProductKeyAndDeviceNameFromCache(control.getProductKey(), deviceName);
+            IotDeviceDO device = deviceService.getDeviceFromCache(control.getProductKey(), deviceName);
             if (device == null) {
                 log.error("[execute][message({}) config({}) 对应的设备不存在]", message, config);
                 return;
@@ -9,7 +9,6 @@
             ts TIMESTAMP,
             id NCHAR(50),
             report_time TIMESTAMP,
-            device_id BIGINT,
             tenant_id BIGINT,
             server_id NCHAR(50),
             upstream BOOL,
@@ -29,21 +28,21 @@
     <insert id="insert">
         INSERT INTO device_message_${deviceId} (
-            ts, id, report_time, device_id, tenant_id,
-            server_id, upstream, request_id, method, params,
-            data, code
+            ts, id, report_time, tenant_id, server_id,
+            upstream, request_id, method, params, data,
+            code
         )
         USING device_message
         TAGS (#{deviceId})
         VALUES (
-            #{ts}, #{id}, #{reportTime}, #{deviceId}, #{tenantId},
-            #{serverId}, #{upstream}, #{requestId}, #{method}, #{params},
-            #{data}, #{code}
+            #{ts}, #{id}, #{reportTime}, #{tenantId},  #{serverId},
+            #{upstream}, #{requestId}, #{method}, #{params}, #{data},
+            #{code}
         )
     </insert>
     <select id="selectPage" resultType="cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceMessageDO">
-        SELECT ts, id, report_time, device_id, tenant_id, server_id, upstream, 
+        SELECT ts, id, report_time, device_id, tenant_id, server_id, upstream,
                request_id, method, params, data, code
         FROM device_message_${reqVO.deviceId}
         <where>
@@ -125,4 +124,4 @@
         ORDER BY time ASC
     </select>
-</mapper> 
 \ No newline at end of file
+</mapper>
 \ No newline at end of file
@@ -2,8 +2,8 @@ package cn.iocoder.yudao.module.iot.core.biz;
 import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
 /**
  * IoT 设备通用 API
@@ -26,6 +26,6 @@ public interface IotDeviceCommonApi {
      * @param infoReqDTO 设备信息请求
      * @return 设备信息
      */
-    CommonResult<IotDeviceInfoRespDTO> getDeviceInfo(IotDeviceInfoReqDTO infoReqDTO);
+    CommonResult<IotDeviceRespDTO> getDevice(IotDeviceGetReqDTO infoReqDTO);
 }
 package cn.iocoder.yudao.module.iot.core.biz.dto;
-import jakarta.validation.constraints.NotBlank;
 import lombok.Data;
 /**
@@ -9,18 +8,20 @@ import lombok.Data;
  * @author 芋道源码
  */
 @Data
-public class IotDeviceInfoReqDTO {
+public class IotDeviceGetReqDTO {
+
+    /**
+     * 设备编号
+     */
+    private Long id;
     /**
      * 产品标识
      */
-    @NotBlank(message = "产品标识不能为空")
     private String productKey;
-
     /**
      * 设备名称
      */
-    @NotBlank(message = "设备名称不能为空")
     private String deviceName;
 }
 \ No newline at end of file
@@ -8,31 +8,34 @@ import lombok.Data;
  * @author 芋道源码
  */
 @Data
-public class IotDeviceInfoRespDTO {
+public class IotDeviceRespDTO {
     /**
      * 设备编号
      */
-    private Long deviceId;
-
+    private Long id;
     /**
      * 产品标识
      */
     private String productKey;
-
     /**
      * 设备名称
      */
     private String deviceName;
-
     /**
-     * 设备密钥
+     * 租户编号
      */
-    private String deviceKey;
+    private Long tenantId;
+
+    // ========== 产品相关字段 ==========
     /**
-     * 租户编号
+     * 产品编号
      */
-    private Long tenantId;
+    private Long productId;
+    /**
+     * 编解码器类型
+     */
+    private String codecType;
 }
 \ No newline at end of file
@@ -13,4 +13,7 @@ public interface ErrorCodeConstants {
     ErrorCode DEVICE_AUTH_FAIL = new ErrorCode(1_051_001_000, "设备鉴权失败"); // 对应阿里云 20000
     ErrorCode DEVICE_TOKEN_EXPIRED = new ErrorCode(1_051_001_002, "token 失效。需重新调用 auth 进行鉴权，获取token"); // 对应阿里云 20001
+    // ========== 设备信息 1-050-002-000 ============
+    ErrorCode DEVICE_NOT_EXISTS = new ErrorCode(1_051_002_001, "设备({}/{}) 不存在");
+
 }
 \ No newline at end of file
@@ -36,14 +36,10 @@ public abstract class IotHttpAbstractHandler implements Handler&lt;RoutingContext&gt; 
     public final void handle(RoutingContext context) {
         try {
             // 1. 前置处理
-            CommonResult<Object> result = beforeHandle(context);
-            if (result != null) {
-                writeResponse(context, result);
-                return;
-            }
+            beforeHandle(context);
             // 2. 执行逻辑
-            result = handle0(context);
+            CommonResult<Object> result = handle0(context);
             writeResponse(context, result);
         } catch (ServiceException e) {
             writeResponse(context, CommonResult.error(e.getCode(), e.getMessage()));
@@ -55,11 +51,11 @@ public abstract class IotHttpAbstractHandler implements Handler&lt;RoutingContext&gt; 
     protected abstract CommonResult<Object> handle0(RoutingContext context);
-    private CommonResult<Object> beforeHandle(RoutingContext context) {
+    private void beforeHandle(RoutingContext context) {
         // 如果不需要认证，则不走前置处理
         String path = context.request().path();
         if (ObjUtil.equal(path, IotHttpAuthHandler.PATH)) {
-            return null;
+            return;
         }
         // 解析参数
@@ -84,7 +80,6 @@ public abstract class IotHttpAbstractHandler implements Handler&lt;RoutingContext&gt; 
                 || ObjUtil.notEqual(deviceName, deviceInfo.getDeviceName())) {
             throw exception(FORBIDDEN);
         }
-        return null;
     }
     @SuppressWarnings("deprecation")
@@ -9,11 +9,10 @@ import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
 import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
-import cn.iocoder.yudao.module.iot.core.mq.producer.IotDeviceMessageProducer;
 import cn.iocoder.yudao.module.iot.core.util.IotDeviceAuthUtils;
 import cn.iocoder.yudao.module.iot.gateway.protocol.http.IotHttpUpstreamProtocol;
 import cn.iocoder.yudao.module.iot.gateway.service.auth.IotDeviceTokenService;
-import cn.iocoder.yudao.module.iot.gateway.service.message.IotDeviceMessageService;
+import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
 import io.vertx.core.json.JsonObject;
 import io.vertx.ext.web.RoutingContext;
@@ -35,19 +34,16 @@ public class IotHttpAuthHandler extends IotHttpAbstractHandler {
     private final IotHttpUpstreamProtocol protocol;
-    private final IotDeviceMessageProducer deviceMessageProducer;
-
     private final IotDeviceTokenService deviceTokenService;
-    private final IotDeviceCommonApi deviceClientService;
+    private final IotDeviceCommonApi deviceApi;
     private final IotDeviceMessageService deviceMessageService;
     public IotHttpAuthHandler(IotHttpUpstreamProtocol protocol) {
         this.protocol = protocol;
-        this.deviceMessageProducer = SpringUtil.getBean(IotDeviceMessageProducer.class);
         this.deviceTokenService = SpringUtil.getBean(IotDeviceTokenService.class);
-        this.deviceClientService = SpringUtil.getBean(IotDeviceCommonApi.class);
+        this.deviceApi = SpringUtil.getBean(IotDeviceCommonApi.class);
         this.deviceMessageService = SpringUtil.getBean(IotDeviceMessageService.class);
     }
@@ -69,9 +65,9 @@ public class IotHttpAuthHandler extends IotHttpAbstractHandler {
         }
         // 2.1 执行认证
-        CommonResult<Boolean> result = deviceClientService.authDevice(new IotDeviceAuthReqDTO()
+        CommonResult<Boolean> result = deviceApi.authDevice(new IotDeviceAuthReqDTO()
                 .setClientId(clientId).setUsername(username).setPassword(password));
-        result.checkError();;
+        result.checkError();
         if (!BooleanUtil.isTrue(result.getData())) {
             throw exception(DEVICE_AUTH_FAIL);
         }
@@ -82,9 +78,9 @@ public class IotHttpAuthHandler extends IotHttpAbstractHandler {
         Assert.notBlank(token, "生成 token 不能为空位");
         // 3. 执行上线
-        IotDeviceMessage message = deviceMessageService.buildDeviceMessageOfStateOnline(
+        IotDeviceMessage message = IotDeviceMessage.buildStateOnline();
+        deviceMessageService.sendDeviceMessage(message,
                 deviceInfo.getProductKey(), deviceInfo.getDeviceName(), protocol.getServerId());
-        deviceMessageProducer.sendDeviceMessage(message);
         // 构建响应数据
         return success(MapUtil.of("token", token));
@@ -8,7 +8,7 @@ import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
 import cn.iocoder.yudao.module.iot.core.mq.producer.IotDeviceMessageProducer;
 import cn.iocoder.yudao.module.iot.gateway.protocol.http.IotHttpUpstreamProtocol;
-import cn.iocoder.yudao.module.iot.gateway.service.message.IotDeviceMessageService;
+import cn.iocoder.yudao.module.iot.gateway.service.device.message.IotDeviceMessageService;
 import io.vertx.ext.web.RoutingContext;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -61,7 +61,7 @@ public class IotDeviceTokenServiceImpl implements IotDeviceTokenService {
         JSONObject payload = jwt.getPayloads();
         // 检查过期时间
         Long exp = payload.getLong("exp");
-        if (exp == null || exp > System.currentTimeMillis() / 1000) {
+        if (exp == null || exp < System.currentTimeMillis() / 1000) {
             throw exception(DEVICE_TOKEN_EXPIRED);
         }
         String productKey = payload.getStr("productKey");
-package cn.iocoder.yudao.module.iot.gateway.service.device;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-/**
- * IoT 设备缓存 Service 接口
- *
- * @author 芋道源码
- */
-public interface IotDeviceCacheService {
-
-    /**
-     * 设备信息
-     */
-    @Data
-    @AllArgsConstructor
-    @NoArgsConstructor
-    class DeviceInfo {
-        /**
-         * 设备编号
-         */
-        private Long deviceId;
-        /**
-         * 产品标识
-         */
-        private String productKey;
-        /**
-         * 设备名称
-         */
-        private String deviceName;
-        /**
-         * 设备密钥
-         */
-        private String deviceKey;
-        /**
-         * 租户编号
-         */
-        private Long tenantId;
-    }
-
-    /**
-     * 根据 productKey 和 deviceName 获取设备信息
-     *
-     * @param productKey 产品标识
-     * @param deviceName 设备名称
-     * @return 设备信息，如果不存在返回 null
-     */
-    DeviceInfo getDeviceInfo(String productKey, String deviceName);
-
-    /**
-     * 根据 deviceId 获取设备信息
-     *
-     * @param deviceId 设备编号
-     * @return 设备信息，如果不存在返回 null
-     */
-    DeviceInfo getDeviceInfoById(Long deviceId);
-
-    /**
-     * 清除设备缓存
-     *
-     * @param deviceId 设备编号
-     */
-    void evictDeviceCache(Long deviceId);
-
-    /**
-     * 清除设备缓存
-     *
-     * @param productKey 产品标识
-     * @param deviceName 设备名称
-     */
-    void evictDeviceCache(String productKey, String deviceName);
-
-}
 \ No newline at end of file
-package cn.iocoder.yudao.module.iot.gateway.service.device;
-
-import cn.hutool.core.util.StrUtil;
-import cn.hutool.extra.spring.SpringUtil;
-import cn.iocoder.yudao.framework.common.pojo.CommonResult;
-import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoRespDTO;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * IoT 设备缓存 Service 实现类
- * <p>
- * 使用本地缓存 + 远程 API 的方式获取设备信息，提高性能并避免敏感信息传输
- *
- * @author 芋道源码
- */
-@Service
-@Slf4j
-public class IotDeviceCacheServiceImpl implements IotDeviceCacheService {
-
-    /**
-     * 设备信息本地缓存
-     * Key: deviceId
-     * Value: DeviceInfo
-     */
-    private final ConcurrentHashMap<Long, DeviceInfo> deviceIdCache = new ConcurrentHashMap<>();
-
-    /**
-     * 设备名称到设备ID的映射缓存
-     * Key: productKey:deviceName
-     * Value: deviceId
-     */
-    private final ConcurrentHashMap<String, Long> deviceNameCache = new ConcurrentHashMap<>();
-
-    /**
-     * 锁对象，防止并发请求同一设备信息
-     */
-    private final ConcurrentHashMap<String, ReentrantLock> lockMap = new ConcurrentHashMap<>();
-
-    @Override
-    public DeviceInfo getDeviceInfo(String productKey, String deviceName) {
-        if (StrUtil.isEmpty(productKey) || StrUtil.isEmpty(deviceName)) {
-            log.warn("[getDeviceInfo][参数为空][productKey: {}][deviceName: {}]", productKey, deviceName);
-            return null;
-        }
-
-        String cacheKey = buildDeviceNameCacheKey(productKey, deviceName);
-
-        // 1. 先从缓存获取 deviceId
-        Long deviceId = deviceNameCache.get(cacheKey);
-        if (deviceId != null) {
-            DeviceInfo deviceInfo = deviceIdCache.get(deviceId);
-            if (deviceInfo != null) {
-                log.debug("[getDeviceInfo][缓存命中][productKey: {}][deviceName: {}][deviceId: {}]",
-                        productKey, deviceName, deviceId);
-                return deviceInfo;
-            }
-        }
-
-        // 2. 缓存未命中，从远程 API 获取
-        return loadDeviceInfoFromApi(productKey, deviceName, cacheKey);
-    }
-
-    @Override
-    public DeviceInfo getDeviceInfoById(Long deviceId) {
-        if (deviceId == null) {
-            log.warn("[getDeviceInfoById][deviceId 为空]");
-            return null;
-        }
-
-        // 1. 先从缓存获取
-        DeviceInfo deviceInfo = deviceIdCache.get(deviceId);
-        if (deviceInfo != null) {
-            log.debug("[getDeviceInfoById][缓存命中][deviceId: {}]", deviceId);
-            return deviceInfo;
-        }
-
-        // 2. 缓存未命中，从远程 API 获取
-        return loadDeviceInfoByIdFromApi(deviceId);
-    }
-
-    @Override
-    public void evictDeviceCache(Long deviceId) {
-        if (deviceId == null) {
-            return;
-        }
-
-        DeviceInfo deviceInfo = deviceIdCache.remove(deviceId);
-        if (deviceInfo != null) {
-            String cacheKey = buildDeviceNameCacheKey(deviceInfo.getProductKey(), deviceInfo.getDeviceName());
-            deviceNameCache.remove(cacheKey);
-            log.info("[evictDeviceCache][清除设备缓存][deviceId: {}]", deviceId);
-        }
-    }
-
-    @Override
-    public void evictDeviceCache(String productKey, String deviceName) {
-        if (StrUtil.isEmpty(productKey) || StrUtil.isEmpty(deviceName)) {
-            return;
-        }
-
-        String cacheKey = buildDeviceNameCacheKey(productKey, deviceName);
-        Long deviceId = deviceNameCache.remove(cacheKey);
-        if (deviceId != null) {
-            deviceIdCache.remove(deviceId);
-            log.info("[evictDeviceCache][清除设备缓存][productKey: {}][deviceName: {}]", productKey, deviceName);
-        }
-    }
-
-    /**
-     * 从远程 API 加载设备信息
-     *
-     * @param productKey 产品标识
-     * @param deviceName 设备名称
-     * @param cacheKey   缓存键
-     * @return 设备信息
-     */
-    private DeviceInfo loadDeviceInfoFromApi(String productKey, String deviceName, String cacheKey) {
-        // 使用锁防止并发请求同一设备信息
-        ReentrantLock lock = lockMap.computeIfAbsent(cacheKey, k -> new ReentrantLock());
-        lock.lock();
-        try {
-            // 双重检查，防止重复请求
-            Long deviceId = deviceNameCache.get(cacheKey);
-            if (deviceId != null) {
-                DeviceInfo deviceInfo = deviceIdCache.get(deviceId);
-                if (deviceInfo != null) {
-                    return deviceInfo;
-                }
-            }
-
-            log.info("[loadDeviceInfoFromApi][从远程API获取设备信息][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-
-            try {
-                // 调用远程 API 获取设备信息
-                IotDeviceCommonApi deviceCommonApi = SpringUtil.getBean(IotDeviceCommonApi.class);
-                IotDeviceInfoReqDTO reqDTO = new IotDeviceInfoReqDTO();
-                reqDTO.setProductKey(productKey);
-                reqDTO.setDeviceName(deviceName);
-
-                CommonResult<IotDeviceInfoRespDTO> result = deviceCommonApi.getDeviceInfo(reqDTO);
-
-                if (result == null || !result.isSuccess() || result.getData() == null) {
-                    log.warn("[loadDeviceInfoFromApi][远程API调用失败][productKey: {}][deviceName: {}][result: {}]",
-                            productKey, deviceName, result);
-                    return null;
-                }
-
-                IotDeviceInfoRespDTO respDTO = result.getData();
-                DeviceInfo deviceInfo = new DeviceInfo(
-                        respDTO.getDeviceId(),
-                        respDTO.getProductKey(),
-                        respDTO.getDeviceName(),
-                        respDTO.getDeviceKey(),
-                        respDTO.getTenantId());
-
-                // 缓存设备信息
-                cacheDeviceInfo(deviceInfo, cacheKey);
-
-                log.info("[loadDeviceInfoFromApi][设备信息获取成功并已缓存][deviceInfo: {}]", deviceInfo);
-                return deviceInfo;
-
-            } catch (Exception e) {
-                log.error("[loadDeviceInfoFromApi][远程API调用异常][productKey: {}][deviceName: {}]",
-                        productKey, deviceName, e);
-                return null;
-            }
-        } finally {
-            lock.unlock();
-            // 清理锁对象，避免内存泄漏
-            if (lockMap.size() > 1000) { // 简单的清理策略
-                lockMap.entrySet().removeIf(entry -> !entry.getValue().hasQueuedThreads());
-            }
-        }
-    }
-
-    /**
-     * 从远程 API 根据 deviceId 加载设备信息
-     *
-     * @param deviceId 设备编号
-     * @return 设备信息
-     */
-    private DeviceInfo loadDeviceInfoByIdFromApi(Long deviceId) {
-        String lockKey = "deviceId:" + deviceId;
-        ReentrantLock lock = lockMap.computeIfAbsent(lockKey, k -> new ReentrantLock());
-        lock.lock();
-        try {
-            // 双重检查
-            DeviceInfo deviceInfo = deviceIdCache.get(deviceId);
-            if (deviceInfo != null) {
-                return deviceInfo;
-            }
-
-            log.info("[loadDeviceInfoByIdFromApi][从远程API获取设备信息][deviceId: {}]", deviceId);
-
-            try {
-                // TODO: 这里需要添加根据 deviceId 获取设备信息的 API
-                // 暂时返回 null，等待 API 完善
-                log.warn("[loadDeviceInfoByIdFromApi][根据deviceId获取设备信息的API尚未实现][deviceId: {}]", deviceId);
-                return null;
-
-            } catch (Exception e) {
-                log.error("[loadDeviceInfoByIdFromApi][远程API调用异常][deviceId: {}]", deviceId, e);
-                return null;
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
-    /**
-     * 缓存设备信息
-     *
-     * @param deviceInfo 设备信息
-     * @param cacheKey   缓存键
-     */
-    private void cacheDeviceInfo(DeviceInfo deviceInfo, String cacheKey) {
-        if (deviceInfo != null && deviceInfo.getDeviceId() != null) {
-            deviceIdCache.put(deviceInfo.getDeviceId(), deviceInfo);
-            deviceNameCache.put(cacheKey, deviceInfo.getDeviceId());
-        }
-    }
-
-    /**
-     * 构建设备名称缓存键
-     *
-     * @param productKey 产品标识
-     * @param deviceName 设备名称
-     * @return 缓存键
-     */
-    private String buildDeviceNameCacheKey(String productKey, String deviceName) {
-        return productKey + ":" + deviceName;
-    }
-
-}
 \ No newline at end of file
+package cn.iocoder.yudao.module.iot.gateway.service.device;
+
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
+
+/**
+ * IoT 设备信息 Service 接口
+ *
+ * @author 芋道源码
+ */
+public interface IotDeviceService {
+
+    /**
+     * 根据 productKey 和 deviceName 获取设备信息
+     *
+     * @param productKey 产品标识
+     * @param deviceName 设备名称
+     * @return 设备信息
+     */
+    IotDeviceRespDTO getDeviceFromCache(String productKey, String deviceName);
+
+    /**
+     * 根据 id 获取设备信息
+     *
+     * @param id 设备编号
+     * @return 设备信息
+     */
+    IotDeviceRespDTO getDeviceFromCache(Long id);
+
+}
 \ No newline at end of file
+package cn.iocoder.yudao.module.iot.gateway.service.device;
+
+import cn.hutool.core.lang.Assert;
+import cn.iocoder.yudao.framework.common.core.KeyValue;
+import cn.iocoder.yudao.framework.common.pojo.CommonResult;
+import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import jakarta.annotation.Resource;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+
+import static cn.iocoder.yudao.framework.common.util.cache.CacheUtils.buildAsyncReloadingCache;
+
+/**
+ * IoT 设备信息 Service 实现类
+ *
+ * @author 芋道源码
+ */
+@Service
+@Slf4j
+public class IotDeviceServiceImpl implements IotDeviceService {
+
+    private static final Duration CACHE_EXPIRE = Duration.ofMinutes(1);
+
+    /**
+     * 通过 id 查询设备的缓存
+     */
+    private final LoadingCache<Long, IotDeviceRespDTO> deviceCaches = buildAsyncReloadingCache(
+            CACHE_EXPIRE,
+            new CacheLoader<>() {
+
+                @Override
+                public IotDeviceRespDTO load(Long id) {
+                    CommonResult<IotDeviceRespDTO> result = deviceApi.getDevice(new IotDeviceGetReqDTO().setId(id));
+                    IotDeviceRespDTO device = result.getCheckedData();
+                    Assert.notNull(device, "设备({}) 不能为空", id);
+                    // 相互缓存
+                    deviceCaches2.put(new KeyValue<>(device.getProductKey(), device.getDeviceName()), device);
+                    return device;
+                }
+
+            });
+
+    /**
+     * 通过 productKey + deviceName 查询设备的缓存
+     */
+    private final LoadingCache<KeyValue<String, String>, IotDeviceRespDTO> deviceCaches2 = buildAsyncReloadingCache(
+            CACHE_EXPIRE,
+            new CacheLoader<>() {
+
+                @Override
+                public IotDeviceRespDTO load(KeyValue<String, String> kv) {
+                    CommonResult<IotDeviceRespDTO> result = deviceApi.getDevice(new IotDeviceGetReqDTO()
+                            .setProductKey(kv.getKey()).setDeviceName(kv.getValue()));
+                    IotDeviceRespDTO device = result.getCheckedData();
+                    Assert.notNull(device, "设备({}/{}) 不能为空", kv.getKey(), kv.getValue());
+                    // 相互缓存
+                    deviceCaches.put(device.getId(), device);
+                    return device;
+                }
+            });
+
+    @Resource
+    private IotDeviceCommonApi deviceApi;
+
+    @Override
+    public IotDeviceRespDTO getDeviceFromCache(String productKey, String deviceName) {
+        return deviceCaches2.getUnchecked(new KeyValue<>(productKey, deviceName));
+    }
+
+    @Override
+    public IotDeviceRespDTO getDeviceFromCache(Long id) {
+        return deviceCaches.getUnchecked(id);
+    }
+
+}
 \ No newline at end of file
-package cn.iocoder.yudao.module.iot.gateway.service.message;
+package cn.iocoder.yudao.module.iot.gateway.service.device.message;
 import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
@@ -26,30 +26,20 @@ public interface IotDeviceMessageService {
      * @param bytes      消息内容
      * @param productKey 产品 Key
      * @param deviceName 设备名称
-     * @param serverId   设备连接的 serverId
      * @return 解码后的消息内容
      */
     IotDeviceMessage decodeDeviceMessage(byte[] bytes,
-                                         String productKey, String deviceName, String serverId);
+                                         String productKey, String deviceName);
     /**
-     * 构建【设备上线】消息
+     * 发送消息
      *
+     * @param message 消息
      * @param productKey 产品 Key
      * @param deviceName 设备名称
-     * @param serverId   设备连接的 serverId
-     * @return 消息
+     * @param serverId 设备连接的 serverId
      */
-    IotDeviceMessage buildDeviceMessageOfStateOnline(String productKey, String deviceName, String serverId);
-
-    /**
-     * 构建【设备下线】消息
-     *
-     * @param productKey 产品 Key
-     * @param deviceName 设备名称
-     * @param serverId   设备连接的 serverId
-     * @return 消息
-     */
-    IotDeviceMessage buildDeviceMessageOfStateOffline(String productKey, String deviceName, String serverId);
+    void sendDeviceMessage(IotDeviceMessage message,
+                           String productKey, String deviceName, String serverId);
 }
-package cn.iocoder.yudao.module.iot.gateway.service.message;
+package cn.iocoder.yudao.module.iot.gateway.service.device.message;
 import cn.hutool.core.util.StrUtil;
 import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
-import cn.iocoder.yudao.module.iot.core.enums.IotDeviceMessageMethodEnum;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
 import cn.iocoder.yudao.module.iot.core.mq.message.IotDeviceMessage;
+import cn.iocoder.yudao.module.iot.core.mq.producer.IotDeviceMessageProducer;
 import cn.iocoder.yudao.module.iot.core.util.IotDeviceMessageUtils;
 import cn.iocoder.yudao.module.iot.gateway.codec.alink.IotAlinkDeviceMessageCodec;
-import cn.iocoder.yudao.module.iot.gateway.service.device.IotDeviceCacheService;
+import cn.iocoder.yudao.module.iot.gateway.service.device.IotDeviceService;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -15,6 +16,9 @@ import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.iot.gateway.enums.ErrorCodeConstants.DEVICE_NOT_EXISTS;
+
 /**
  * IoT 设备消息 Service 实现类
  *
@@ -30,7 +34,10 @@ public class IotDeviceMessageServiceImpl implements IotDeviceMessageService {
     private final Map<String, IotAlinkDeviceMessageCodec> codes;
     @Resource
-    private IotDeviceCacheService deviceCacheService;
+    private IotDeviceService deviceService;
+
+    @Resource
+    private IotDeviceMessageProducer deviceMessageProducer;
     public IotDeviceMessageServiceImpl(List<IotAlinkDeviceMessageCodec> codes) {
         this.codes = CollectionUtils.convertMap(codes, IotAlinkDeviceMessageCodec::type);
@@ -39,82 +46,51 @@ public class IotDeviceMessageServiceImpl implements IotDeviceMessageService {
     @Override
     public byte[] encodeDeviceMessage(IotDeviceMessage message,
                                       String productKey, String deviceName) {
-        // 获取设备信息以确定编解码类型
-        IotDeviceCacheService.DeviceInfo deviceInfo = deviceCacheService.getDeviceInfo(productKey, deviceName);
-        if (deviceInfo == null) {
-            log.warn("[encodeDeviceMessage][设备信息不存在][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-            return null;
+        // 1.1 获取设备信息
+        IotDeviceRespDTO device = deviceService.getDeviceFromCache(productKey, deviceName);
+        if (device == null) {
+            throw exception(DEVICE_NOT_EXISTS, productKey, deviceName);
         }
-
-        String codecType = "alink"; // 默认使用 alink 编解码器
-        IotAlinkDeviceMessageCodec codec = codes.get(codecType);
+        // 1.2 获取编解码器
+        IotAlinkDeviceMessageCodec codec = codes.get(device.getCodecType());
         if (codec == null) {
-            log.error("[encodeDeviceMessage][编解码器不存在][codecType: {}]", codecType);
-            return null;
+            throw new IllegalArgumentException(StrUtil.format("编解码器({}) 不存在", device.getCodecType()));
         }
+        // 2. 编码消息
         return codec.encode(message);
     }
     @Override
     public IotDeviceMessage decodeDeviceMessage(byte[] bytes,
-                                                String productKey, String deviceName, String serverId) {
-        // 获取设备信息
-        IotDeviceCacheService.DeviceInfo deviceInfo = deviceCacheService.getDeviceInfo(productKey, deviceName);
-        if (deviceInfo == null) {
-            log.warn("[decodeDeviceMessage][设备信息不存在][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-            return null;
+                                                String productKey, String deviceName) {
+        // 1.1 获取设备信息
+        IotDeviceRespDTO device = deviceService.getDeviceFromCache(productKey, deviceName);
+        if (device == null) {
+            throw exception(DEVICE_NOT_EXISTS, productKey, deviceName);
         }
-
-        String codecType = "alink"; // 默认使用 alink 编解码器
-        IotAlinkDeviceMessageCodec codec = codes.get(codecType);
+        // 1.2 获取编解码器
+        IotAlinkDeviceMessageCodec codec = codes.get(device.getCodecType());
         if (codec == null) {
-            log.error("[decodeDeviceMessage][编解码器不存在][codecType: {}]", codecType);
-            return null;
-        }
-
-        IotDeviceMessage message = codec.decode(bytes);
-        if (message == null) {
-            log.warn("[decodeDeviceMessage][消息解码失败][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-            return null;
+            throw new IllegalArgumentException(StrUtil.format("编解码器({}) 不存在", device.getCodecType()));
         }
-        // 补充后端字段
-        return appendDeviceMessage(message, deviceInfo, serverId);
-    }
-
-    @Override
-    public IotDeviceMessage buildDeviceMessageOfStateOnline(String productKey, String deviceName, String serverId) {
-        // 获取设备信息
-        IotDeviceCacheService.DeviceInfo deviceInfo = deviceCacheService.getDeviceInfo(productKey, deviceName);
-        if (deviceInfo == null) {
-            log.warn("[buildDeviceMessageOfStateOnline][设备信息不存在][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-            return null;
-        }
-
-        IotDeviceMessage message = IotDeviceMessage.requestOf(null,
-                IotDeviceMessageMethodEnum.STATE_ONLINE.getMethod(), null);
-
-        return appendDeviceMessage(message, deviceInfo, serverId);
+        // 2. 解码消息
+        return codec.decode(bytes);
     }
     @Override
-    public IotDeviceMessage buildDeviceMessageOfStateOffline(String productKey, String deviceName, String serverId) {
-        // 获取设备信息
-        IotDeviceCacheService.DeviceInfo deviceInfo = deviceCacheService.getDeviceInfo(productKey, deviceName);
-        if (deviceInfo == null) {
-            log.warn("[buildDeviceMessageOfStateOffline][设备信息不存在][productKey: {}][deviceName: {}]",
-                    productKey, deviceName);
-            return null;
+    public void sendDeviceMessage(IotDeviceMessage message,
+                                  String productKey, String deviceName, String serverId) {
+        // 1. 获取设备信息
+        IotDeviceRespDTO device = deviceService.getDeviceFromCache(productKey, deviceName);
+        if (device == null) {
+            throw exception(DEVICE_NOT_EXISTS, productKey, deviceName);
         }
-        IotDeviceMessage message = IotDeviceMessage.requestOf(IotDeviceMessageMethodEnum.STATE_OFFLINE.getMethod(),
-                null);
-        return appendDeviceMessage(message, deviceInfo, serverId);
+        // 2. 发送消息
+        appendDeviceMessage(message, device, serverId);
+        deviceMessageProducer.sendDeviceMessage(message);
     }
     /**
@@ -126,9 +102,9 @@ public class IotDeviceMessageServiceImpl implements IotDeviceMessageService {
      * @return 消息
      */
     private IotDeviceMessage appendDeviceMessage(IotDeviceMessage message,
-                                                 IotDeviceCacheService.DeviceInfo device, String serverId) {
+                                                 IotDeviceRespDTO device, String serverId) {
         message.setId(IotDeviceMessageUtils.generateMessageId()).setReportTime(LocalDateTime.now())
-                .setDeviceId(device.getDeviceId()).setTenantId(device.getTenantId()).setServerId(serverId);
+                .setDeviceId(device.getId()).setTenantId(device.getTenantId()).setServerId(serverId);
         // 特殊：如果设备没有指定 requestId，则使用 messageId
         if (StrUtil.isEmpty(message.getRequestId())) {
             message.setRequestId(message.getId());
-package cn.iocoder.yudao.module.iot.gateway.service.device;
+package cn.iocoder.yudao.module.iot.gateway.service.device.remote;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.bean.BeanUtil;
 import cn.iocoder.yudao.framework.common.pojo.CommonResult;
 import cn.iocoder.yudao.module.iot.core.biz.IotDeviceCommonApi;
 import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoReqDTO;
-import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceInfoRespDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceGetReqDTO;
+import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceRespDTO;
 import cn.iocoder.yudao.module.iot.gateway.config.IotGatewayProperties;
 import jakarta.annotation.PostConstruct;
 import jakarta.annotation.Resource;
@@ -19,8 +18,6 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.RestTemplate;
-import java.util.LinkedHashMap;
-
 import static cn.iocoder.yudao.framework.common.exception.enums.GlobalErrorCodeConstants.INTERNAL_SERVER_ERROR;
 /**
@@ -30,7 +27,7 @@ import static cn.iocoder.yudao.framework.common.exception.enums.GlobalErrorCodeC
  */
 @Service
 @Slf4j
-public class IotDeviceClientServiceImpl implements IotDeviceCommonApi {
+public class IotDeviceApiImpl implements IotDeviceCommonApi {
     @Resource
     private IotGatewayProperties gatewayProperties;
@@ -49,57 +46,27 @@ public class IotDeviceClientServiceImpl implements IotDeviceCommonApi {
     @Override
     public CommonResult<Boolean> authDevice(IotDeviceAuthReqDTO authReqDTO) {
-        return doPost("/auth", authReqDTO);
+        return doPost("/auth", authReqDTO, new ParameterizedTypeReference<>() { });
     }
     @Override
-    public CommonResult<IotDeviceInfoRespDTO> getDeviceInfo(IotDeviceInfoReqDTO infoReqDTO) {
-        return doPostForDeviceInfo("/info", infoReqDTO);
+    public CommonResult<IotDeviceRespDTO> getDevice(IotDeviceGetReqDTO getReqDTO) {
+        return doPost("/get", getReqDTO, new ParameterizedTypeReference<>() { });
     }
-    @SuppressWarnings("unchecked")
-    private <T> CommonResult<Boolean> doPost(String url, T requestBody) {
+    private <T, R> CommonResult<R> doPost(String url, T body,
+                                          ParameterizedTypeReference<CommonResult<R>> responseType) {
         try {
-            CommonResult<Boolean> result = restTemplate.postForObject(url, requestBody,
-                    (Class<CommonResult<Boolean>>) (Class<?>) CommonResult.class);
-            log.info("[doPost][url({}) requestBody({}) result({})]", url, requestBody, result);
+            // 请求
+            HttpEntity<T> requestEntity = new HttpEntity<>(body);
+            ResponseEntity<CommonResult<R>> response = restTemplate.exchange(
+                    url, HttpMethod.POST, requestEntity, responseType);
+            // 响应
+            CommonResult<R> result = response.getBody();
             Assert.notNull(result, "请求结果不能为空");
             return result;
         } catch (Exception e) {
-            log.error("[doPost][url({}) requestBody({}) 发生异常]", url, requestBody, e);
-            return CommonResult.error(INTERNAL_SERVER_ERROR);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private <T> CommonResult<IotDeviceInfoRespDTO> doPostForDeviceInfo(String url, T requestBody) {
-        try {
-            // 使用 ParameterizedTypeReference 来处理泛型类型
-            ParameterizedTypeReference<CommonResult<LinkedHashMap<String, Object>>> typeRef = new ParameterizedTypeReference<CommonResult<LinkedHashMap<String, Object>>>() {
-            };
-
-            HttpEntity<T> requestEntity = new HttpEntity<>(requestBody);
-            ResponseEntity<CommonResult<LinkedHashMap<String, Object>>> response = restTemplate.exchange(url,
-                    HttpMethod.POST, requestEntity, typeRef);
-
-            CommonResult<LinkedHashMap<String, Object>> rawResult = response.getBody();
-            log.info("[doPostForDeviceInfo][url({}) requestBody({}) rawResult({})]", url, requestBody, rawResult);
-            Assert.notNull(rawResult, "请求结果不能为空");
-
-            // 手动转换数据类型
-            CommonResult<IotDeviceInfoRespDTO> result = new CommonResult<>();
-            result.setCode(rawResult.getCode());
-            result.setMsg(rawResult.getMsg());
-
-            if (rawResult.isSuccess() && rawResult.getData() != null) {
-                // 将 LinkedHashMap 转换为 IotDeviceInfoRespDTO
-                IotDeviceInfoRespDTO deviceInfo = BeanUtil.toBean(rawResult.getData(), IotDeviceInfoRespDTO.class);
-                result.setData(deviceInfo);
-            }
-
-            return result;
-        } catch (Exception e) {
-            log.error("[doPostForDeviceInfo][url({}) requestBody({}) 发生异常]", url, requestBody, e);
+            log.error("[doPost][url({}) body({}) 发生异常]", url, body, e);
             return CommonResult.error(INTERNAL_SERVER_ERROR);
         }
     }