阶段提交：梳理checker无用统一引用，需要补充的逻辑catch 异常，便于发现

src/main/java/com/yunfeiyun/agmp/iots/config/TestConst.java

@@ -1,10 +1,23 @@
 package com.yunfeiyun.agmp.iots.config;
 
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.exception.BizException;
 import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
+import lombok.extern.slf4j.Slf4j;
 
+@Slf4j
 public class TestConst {
     // 数据库测报灯的
     public static final String connectionId="0b006e8d-0193-1000-e000-01aac0a83801";
     public static final String serviceName= ServiceNameConst.SERVICE_YF_CBD;
     public static final String deviceId= "864865062128484";
+
+    public static void printError(String msg){
+        //TODO
+        try {
+            throw new BizException(ErrorCode.FAILURE.getCode(), msg);
+        } catch (Exception e) {
+            log.error("{}", e);
+        }
+    }
 }

src/main/java/com/yunfeiyun/agmp/iots/core/cmd/core/task/CmdTaskService.java

@@ -1,7 +1,9 @@
 package com.yunfeiyun.agmp.iots.core.cmd.core.task;
 
 import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
 import com.yunfeiyun.agmp.common.enums.RedisCacheKey;
+import com.yunfeiyun.agmp.common.exception.BizException;
 import com.yunfeiyun.agmp.common.framework.manager.RedisCacheManager;
 import com.yunfeiyun.agmp.common.utils.DateUtils;
 import com.yunfeiyun.agmp.common.utils.JSONUtils;
@@ -25,6 +27,7 @@ import com.yunfeiyun.agmp.iots.device.common.Device;
 import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
 import com.yunfeiyun.agmp.iots.core.manager.MqttManager;
 
+import com.yunfeiyun.agmp.iots.exception.IotException;
 import com.yunfeiyun.agmp.iots.service.*;
 import com.yunfeiyun.agmp.iots.service.checker.CmdResultCheckService;
 import lombok.extern.slf4j.Slf4j;
@@ -94,8 +97,8 @@ public class CmdTaskService {
             log.info("任务标识:【{}】,开始执行最小任务单元:{}", taskId, cmdModel);
             IotDevice iotDevice = iotDeviceMap.get(cmdModel.getDeviceId());
             //【需要补充】需要换出来ServiceName
-            log.info("！！！！！！！！！！【看这里：临时测试】这里的serviceName写死了SERVICE_YF_CBD，对接业务时候换掉，取出来");
-            String serviceName= TestConst.serviceName;
+            TestConst.printError("！！！！！！！！！！【看这里：临时测试】这里的serviceName写死了SERVICE_YF_CBD，对接业务时候换掉，取出来");
+            String serviceName = TestConst.serviceName;
             if (StringUtils.isEmpty(serviceName)) {
                 cmdExecModel.setCmdStatus(CmdStatus.CMD_STATUS_FAIL.getCode());
                 cmdExecModel.setErrmsg("指令下发失败：设备：" + iotDevice.getDevCode() + "的对应厂家配置异常，请检查");
@@ -236,7 +239,7 @@ public class CmdTaskService {
             // 获取当前正在执行的指令集
             List<SerialTaskModel> serialTaskModels = getSerialTaskModels(cmdExecModel, iotCmdtask);
             if (serialTaskModels.isEmpty()) {
-                log.error("执行完了？？？");
+                log.error("执行完了");
                 // 该流程的触发原因：
                 // 1.任务已完成，设备多次上报指令执行结果
                 return;
@@ -416,7 +419,6 @@ public class CmdTaskService {
 
         // 更新任务状态
         log.info("resultCallback 更新任务状态为【{}】，任务id{}", cmdgroupStatus, taskId);
-        //iotCmdtaskService.handleIotCmdTaskResult(taskId, cmdgroupStatus.getCode());
         IotCmdtask iotCmdtask = new IotCmdtask();
         iotCmdtask.setCtBid(taskId);
         iotCmdtask.setCtStatus(cmdgroupStatus.getCode());
@@ -435,7 +437,9 @@ public class CmdTaskService {
         taskResult.setErrMsg(errMsg);
         taskResult.setCompleteDate(DateUtils.dateTimeNow());
         //TODO
-        //   iotsMqService.sendTaskResultMsg(taskResult);
+        // iotsMqService.sendTaskResultMsg(taskResult);
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】需要完善mq发送回执消息");
+
     }
 
     private void resetResultCallback(CmdExecModel cmdExecModel, CmdgroupStatus cmdgroupStatus) {
@@ -446,7 +450,6 @@ public class CmdTaskService {
 
         // 更新任务状态
         log.info("resetResultCallback 更新任务状态为【{}】，任务id{}", cmdgroupStatus, cmdExecModel.getTaskUuid());
-        //iotCmdtaskService.handleIotCmdTaskResult(cmdExecModel.getTaskUuid(), cmdgroupStatus.getCode());
 
         IotCmdtask findItem = iotCmdtaskService.selectIotCmdtaskByCtBid(cmdExecModel.getTaskUuid());
         if (findItem == null) {
@@ -473,12 +476,13 @@ public class CmdTaskService {
         taskResult.setCompleteDate(DateUtils.dateTimeNow());
 
         JSONObject ext = new JSONObject();
-        ext.put("ctDescribe",findItem.getCtDescribe());
-        ext.put("ctDevtype",findItem.getCtDevtype());
-        ext.put("ctDevcode",findItem.getCtDevcode());
+        ext.put("ctDescribe", findItem.getCtDescribe());
+        ext.put("ctDevtype", findItem.getCtDevtype());
+        ext.put("ctDevcode", findItem.getCtDevcode());
         taskResult.setExtraBody(ext);
         // TODO
         // iotsMqService.sendTaskResultMsg(taskResult);
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】需要完善mq发送回执消息");
     }
 
     public static long getTimeDifference(String datetime1, String datetime2) {

src/main/java/com/yunfeiyun/agmp/iots/core/manager/MqttManager.java

@@ -55,8 +55,7 @@ public class MqttManager {
     @Resource
     private Map<String, Device> deviceHandlerMap;
 
-    @Resource
-    private CmdResultCheckService cmdResultCheckService;
+
 
 
     /**
@@ -102,7 +101,6 @@ public class MqttManager {
         // 查询topics【需要实现：重新更改获取该型号下的设备】
         String connectionId=iotDeviceconnResVo.getDevconnBid();
         String[] topics = deviceTopicService.getBatchTopic(serviceName, deviceTopicService.getDeviceCodesByConectionId(connectionId));
-        //String[] topics = deviceTopicService.getBatchTopic(serviceName, new String[]{"", "", ""});
         cfgYf.setSubTopic(topics);
         cfgYf.setServiceName(serviceName);
         log.info("【初始化厂商加载配置】 {} {} {}", firmName, type, Arrays.toString(topics));
@@ -113,7 +111,7 @@ public class MqttManager {
 
         // 构建MqttCore
         try {
-            mqttCore.buildMqttCore(cfgYf, cmdResultCheckService);
+            mqttCore.buildMqttCore(cfgYf);
             log.info("【成功构建MqttCore】 mqttCore: {}", mqttCore);
         } catch (MqttException e) {
             log.error("【构建MqttCore失败】 异常信息: {}", e.getMessage(), e);
@@ -550,14 +548,4 @@ public class MqttManager {
         }
     }
 
-    /**
-     * 模拟异步发送
-     *
-     * @param msg
-     */
-    @Async
-    public void receiveMsg(String msg) throws InterruptedException {
-        Thread.sleep(5000);
-
-    }
 }

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/network/MqttCore.java

@@ -111,13 +111,13 @@ public class MqttCore {
      * @param mqttConfig
      * @throws MqttException
      */
-    public void buildMqttCore(MqttConfig mqttConfig, CmdResultCheckService cmdResultCheckService) throws MqttException {
+    public void buildMqttCore(MqttConfig mqttConfig) throws MqttException {
         log.info("【初始化】MQTT CORE {},{},{},{},{},", mqttConfig.getDeviceType(), mqttConfig.getIp(), mqttConfig.getPort(), mqttConfig.getUsername(), mqttConfig.getPassword());
         this.mqttConfig = mqttConfig;
         buildClient();
         connection();
         buildPublisher();
-        buildSubscriber(cmdResultCheckService);
+        buildSubscriber();
 
     }
 
@@ -155,9 +155,9 @@ public class MqttCore {
      *
      * @throws MqttException
      */
-    private void buildSubscriber(CmdResultCheckService cmdResultCheckService) throws MqttException {
+    private void buildSubscriber() throws MqttException {
         MqttSubscriber mqttSubscriber = new MqttSubscriber();
-        mqttSubscriber.init(this, cmdResultCheckService);
+        mqttSubscriber.init(this);
         this.mqttSubscriber = mqttSubscriber;
         log.info("【初始化】构建 MQTT subscriber");
     }

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/network/MqttSubscriber.java

@@ -20,25 +20,17 @@ public class MqttSubscriber implements MqttCallbackExtended {
 
     private MqttCore mqttCore;
 
-    private CmdResultCheckService checkService;
 
-
-    public void init(MqttCore mqttCore, CmdResultCheckService cmdResultCheckService) throws MqttException {
+    public void init(MqttCore mqttCore) throws MqttException {
         this.mqttCore = mqttCore;
         this.mqttClient = mqttCore.getClient();
-        //this.checkService = cmdResultCheckService;
-
-        this.checkService = SpringUtils.getBean(CmdResultCheckService.class);
-
         String[] topics = mqttCore.getSubTopic();
         mqttClient.setCallback(this);
         for (String topic : topics) {
-
             //TODO 测试设备乱发离线指令，暂时不订阅它
             if ("/yfkj/cbd/offline/861551058867599".equals(topic)) {
                 continue;
             }
-
             mqttClient.subscribe(topic);
             log.debug("mqtt 主题已订阅 {},{}", mqttCore.getServiceType(), topic);
         }
@@ -70,7 +62,7 @@ public class MqttSubscriber implements MqttCallbackExtended {
             log.info("【上报数据：处理结果】{}", result);
             //如果是“设备属性”消息，进行执行结果检查
             if (device.isDeviceProps(obj)) {
-                checkService.check(device.findIotDevice(topic, obj), obj);
+                SpringUtils.getBean(CmdResultCheckService.class).check(device.findIotDevice(topic, obj), obj);
             } else {
                 log.error("其它数据");
             }

src/main/java/com/yunfeiyun/agmp/iots/device/serviceImp/CqCbdDeviceImpl.java

@@ -209,6 +209,7 @@ public class CqCbdDeviceImpl implements ICbdDevice {
 
     public void cmdData(JSONObject ext, String devUpdateddate) throws Exception {
         log.info("【测报灯】数据解析 {}", ext.toString());
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】这里的connectionId写死了，对接业务时候换掉，取出来");
         String devtypeBid = mqttManager.getDeviceTypeBizId(connectionId);
         String firmBid = mqttManager.getFirmBizId(connectionId);
         boolean isCbd = true;

src/main/java/com/yunfeiyun/agmp/iots/service/checker/CmdResultCheckService.java

@@ -4,26 +4,23 @@ import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.iot.common.constant.devicetype.IotDeviceDictConst;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iots.config.TestConst;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdDispatcherService;
 import com.yunfeiyun.agmp.iots.core.cmd.model.CmdExecModel;
-import com.yunfeiyun.agmp.iots.service.IIotDeviceService;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdCheckScheduledFuture;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdResultTimedout;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.http.util.TextUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import javax.annotation.Resource;
 import java.util.concurrent.*;
 
 @Slf4j
 @Service
 public class CmdResultCheckService {
 
-    @Resource
-    private IIotDeviceService iIotDeviceService;
-
-    @Resource
+    @Autowired
     private CmdDispatcherService cmdDispatcherService;
 
 
@@ -54,7 +51,7 @@ public class CmdResultCheckService {
 
         String deviceID = cmdExecModel.getCmdModel().getDeviceId();
         log.info("任务id【{}】Checker : 创建, 设备id:{}, 指令：{}", cmdExecModel.getTaskUuid(), deviceID, cmdExecModel.getCmdModel().getCmdDistribution());
-
+        //这里需要该，根据新的判断逻辑，创建对应的checker
         CmdResultChecker cmdResultChecker = newChecker(iotDevice, cmdExecModel);
         log.info("任务id【{}】,创建结果：{}", cmdExecModel.getTaskUuid(), cmdResultChecker);
 
@@ -62,14 +59,14 @@ public class CmdResultCheckService {
             log.error("任务id【{}】,【指令结果检查器】创建异常！");
             return;
         }
-
-        if (hmChecker.get(deviceID) != null) {
-            hmChecker.get(deviceID).put(cmdExecModel.getCeBid(), cmdResultChecker);
+        ConcurrentHashMap<String, CmdResultChecker> checkerMap = hmChecker.get(deviceID);
+        if (checkerMap != null) {
+            checkerMap.put(cmdExecModel.getCeBid(), cmdResultChecker);
             log.info("任务id【{}】,在已有list中添加item", cmdExecModel.getTaskUuid());
         } else {
-            ConcurrentHashMap<String, CmdResultChecker> list = new ConcurrentHashMap<>();
-            list.put(cmdExecModel.getCeBid(), cmdResultChecker);
-            hmChecker.put(deviceID, list);
+            checkerMap = new ConcurrentHashMap<>();
+            checkerMap.put(cmdExecModel.getCeBid(), cmdResultChecker);
+            hmChecker.put(deviceID, checkerMap);
             log.info("任务id【{}】,新建list，在里面添加一个item", cmdExecModel.getTaskUuid());
         }
 
@@ -80,12 +77,13 @@ public class CmdResultCheckService {
                 , TimeUnit.SECONDS
         );
         CmdCheckScheduledFuture future = new CmdCheckScheduledFuture(cmdExecModel, scheduledFuture);
-        if (hmFuture.get(deviceID) != null) {
-            hmFuture.get(deviceID).put(cmdExecModel.getCeBid(), future);
+        ConcurrentHashMap<String, CmdCheckScheduledFuture> checkScheduledFutureMap = hmFuture.get(deviceID);
+        if (checkScheduledFutureMap != null) {
+            checkScheduledFutureMap.put(cmdExecModel.getCeBid(), future);
         } else {
-            ConcurrentHashMap<String, CmdCheckScheduledFuture> list = new ConcurrentHashMap<>();
-            list.put(cmdExecModel.getCeBid(), future);
-            hmFuture.put(deviceID, list);
+            checkScheduledFutureMap = new ConcurrentHashMap<>();
+            checkScheduledFutureMap.put(cmdExecModel.getCeBid(), future);
+            hmFuture.put(deviceID, checkScheduledFutureMap);
         }
         log.debug("任务id【{}】,指令执行结果检查器 已添加  指令：{}", cmdExecModel.getTaskUuid(), cmdExecModel);
     }
@@ -96,8 +94,8 @@ public class CmdResultCheckService {
      * @param cmdExecModel
      */
     public void onChecked(CmdExecModel cmdExecModel) {
-        if(true){
-            log.info("！！！！！！！！！！【看这里：临时测试】checker 因为iots直接下发指令测试，没有塞缓存task，先强制关闭，联调到iotm iots，再打开");
+        if (true) {
+            TestConst.printError("！！！！！！！！！！【看这里：临时测试】checker 因为iots直接下发指令测试，没有塞缓存task，先强制关闭，联调到iotm iots，再打开");
             return;
         }
         if (cmdExecModel == null) {
@@ -197,15 +195,9 @@ public class CmdResultCheckService {
     private void removeChecker(CmdExecModel cmdExecModel) {
         CmdResultChecker findItem = null;
         ConcurrentHashMap<String, CmdResultChecker> list = hmChecker.get(cmdExecModel.getCmdModel().getDeviceId());
-        log.info("111遍历cheker{}", list);
         if (list != null) {
-            log.info("222遍历cheker{}", list);
             for (CmdResultChecker item : list.values()) {
-                log.info("设备标识{},当前指令执行bid{},当前检查器关联指令执行{}"
-                        , cmdExecModel.getCmdModel().getDeviceId()
-                        , cmdExecModel.getCeBid()
-                        , item.getCmdExecModel()
-                );
+                log.info("设备标识{},当前指令执行bid{},当前检查器关联指令执行{}", cmdExecModel.getCmdModel().getDeviceId(), cmdExecModel.getCeBid(), item.getCmdExecModel());
                 if (cmdExecModel.getCeBid().equals(item.getCmdExecModel().getCeBid())) {
                     findItem = item;
                     break;
@@ -242,11 +234,10 @@ public class CmdResultCheckService {
      * @return
      */
     private CmdResultChecker newChecker(IotDevice iotDevice, CmdExecModel cmdExecModel) {
-        //TODO 临时逻辑  ，需要机制缓存相关对应关系
         if (IotDeviceDictConst.TYPE_YF_CBD.equals(iotDevice.getDevtypeBid()) || IotDeviceDictConst.TYPE_YF_GKCBD.equals(iotDevice.getDevtypeBid())) {
-            return new YfCbdCmdResultChecker(cmdExecModel, this, cmdDispatcherService);
-        }  else if (IotDeviceDictConst.TYPE_YF_JKSB.equals(iotDevice.getDevtypeBid())) {
-            return new EzvizCmdResultChecker(cmdExecModel, this, cmdDispatcherService);
+            return new YfCbdCmdResultChecker(cmdExecModel);
+        } else if (IotDeviceDictConst.TYPE_YF_JKSB.equals(iotDevice.getDevtypeBid())) {
+            return new EzvizCmdResultChecker(cmdExecModel);
         }
         return null;
     }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/CmdResultChecker.java

@@ -1,7 +1,6 @@
 package com.yunfeiyun.agmp.iots.service.checker;
 
 
-
 import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.common.utils.spring.SpringUtils;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
@@ -24,116 +23,74 @@ import java.util.concurrent.ScheduledFuture;
 
 /**
  * 单条指令执行结果检查器基类
- *
- *
+ * <p>
+ * <p>
  * 当指令集中存在“结束指令”时：
- *
+ * <p>
  * 当单个“普通指令（未标记为finally）”执行成功时，执行“指令集继续处理”；
  * 当单个“普通指令（未标记为finally）”执行出错、失败、超时时，执行finally指令组；
  * 当finally指令组（一组指令，可能只有一个，本组的全部指令）执行成功时，标志着整个任务执行成功（如果是因为前面的指令出错、失败、超时等原因直接跳到finally指令的，整个任务的状态为“已失败”），执行出错、失败、超时时，标志着整个任务状态为“复位失败”
- *
+ * <p>
  * 当指令集中不存在“结束指令”时：
- *  当单个“普通指令“执行成功时，执行“指令集继续处理”；
- *  当单个“普通指令”执行出错、失败、超时时，认为整个任务执行失败；
- *  当最后一组指令（可能只有一个）全部执行成功时，认为整个任务执行成功。
- *
- *
+ * 当单个“普通指令“执行成功时，执行“指令集继续处理”；
+ * 当单个“普通指令”执行出错、失败、超时时，认为整个任务执行失败；
+ * 当最后一组指令（可能只有一个）全部执行成功时，认为整个任务执行成功。
  */
 @Data
 @Slf4j
-public class CmdResultChecker{
-
-
+public class CmdResultChecker {
 
     /**
      * 该条指令
      */
     private CmdExecModel cmdExecModel;
 
-    //private ScheduledFuture<Boolean> timeoutFuture;
-
-    private CmdDispatcherService cmdDispatcherService;
-
-    private CmdResultCheckService cmdResultCheckService;
-
     /**
      * 知道结果或等待结果超时后，变更此标记为true
      */
     private boolean isDone;
 
-    public CmdResultChecker(CmdExecModel cmdExecModel,CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
+    public CmdResultChecker(CmdExecModel cmdExecModel) {
         this.cmdExecModel = cmdExecModel;
-        //this.cmdResultCheckService = cmdResultCheckService;
-        this.cmdResultCheckService = SpringUtils.getBean(CmdResultCheckService.class);
-        this.cmdDispatcherService = cmdDispatcherService;
     }
 
-    public void configRetry(int retry){
+    public void configRetry(int retry) {
 
     }
 
-    public void configTimedout(int timedout){
+    public void configTimedout(int timedout) {
 
     }
 
     /**
      * 有的设备需要发送查询指令，以触发设备立即上报数据
      */
-    public void reqData(){
+    public void reqData() {
 
     }
 
-    /**
-     * 启动
-     */
-/*    public void start(){
-
-        //执行结果检查是被动的：设备下次上报数据时执行
-
-        //超时处理是主动的
-        try {
-            Boolean isTimeout = timeoutFuture.get();
-
-            if(isTimeout){
-                onResult(CmdStatus.CMD_STATUS_FAIL,"等待指令["+cmdExecModel.getCmdModel().getTag()+"]执行结果超时");
-            }
-        } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-        } catch (ExecutionException e) {
-            throw new RuntimeException(e);
-        }
-    }*/
 
     /**
      * 得到单条指令执行结果后的处理
      */
-    public void onResult(CmdStatus cmdStatus, String errMsg){
-
-        log.debug(""+this+", "+cmdResultCheckService+"，得到指令的执行结果："+cmdStatus+"，错误信息（如果有的话）："+errMsg);
-
-        isDone = true;  //checker一旦得到结果，它的使命就结束了
-
-        //TODO 更新指令执行记录表
+    public void onResult(CmdStatus cmdStatus, String errMsg) {
+        log.debug("得到指令的执行结果：" + cmdStatus + "，错误信息（如果有的话）：" + errMsg);
+        isDone = true;
+        // 更新指令执行记录表
         cmdExecModel.setCmdStatus(cmdStatus.getCode());
         cmdExecModel.setErrmsg(errMsg);
-
         //告诉checkservie我知道结果了
-        cmdResultCheckService.onChecked(cmdExecModel);
-
-
-
-        //TODO 更新指令执行记录表
-        //cmdDispatcherService.onCmdResult(cmdExecModel);
+        SpringUtils.getBean(CmdResultCheckService.class).onChecked(cmdExecModel);
     }
 
 
     /**
      * 单条指令执行结果检查
-     *  (收到设备发来的消息时，根据上报消息中的数据进行比对，来判断指令是否已执行成功)
+     * (收到设备发来的消息时，根据上报消息中的数据进行比对，来判断指令是否已执行成功)
+     *
      * @param jobjMsg
      */
-    public void check(IotDevice iotDevice, JSONObject jobjMsg){
-
+    public void check(IotDevice iotDevice, JSONObject jobjMsg) {
 
 
     }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/EzvizCmdResultChecker.java

@@ -3,43 +3,32 @@ package com.yunfeiyun.agmp.iots.service.checker;
 import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
-import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
-import com.yunfeiyun.agmp.iots.core.cmd.core.CmdDispatcherService;
 import com.yunfeiyun.agmp.iots.core.cmd.model.CmdExecModel;
-import com.yunfeiyun.agmp.iots.service.IIotCmdlogService;
 import lombok.extern.slf4j.Slf4j;
 
-import javax.annotation.Resource;
 
 @Slf4j
 public class EzvizCmdResultChecker extends CmdResultChecker {
-    public EzvizCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public EzvizCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Resource
-    private IIotCmdlogService iIotCmdlogService;
-
-    private static final String SERVICE_NAME = ServiceNameConst.SERVICE_Ht_SF;
 
     @Override
     public void reqData() {
-        //云飞测报灯不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
+
     }
 
     /**
-     * 宏泰水肥的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
      */
     @Override
     public void check(IotDevice iotDevice, JSONObject jobjMsg) {
         log.debug("萤石云平台设备 指令执行结果检查");
-        //对于config指令，支持一次设置一个或多个设置项，要判断上报的设置数据中，所有要设置的设置项的值，都已相同，才认为是设置成功
-        CmdExecModel cmdExecModel = getCmdExecModel();
     }
 
     @Override
-    public void onResult(CmdStatus cmdStatus, String errMsg){
+    public void onResult(CmdStatus cmdStatus, String errMsg) {
         super.onResult(cmdStatus, errMsg);
     }
 }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/YfBzyCmdResultChecker.java

@@ -17,18 +17,11 @@ import java.util.Set;
 @Slf4j
 public class YfBzyCmdResultChecker extends CmdResultChecker {
 
-    private final IIotCmdlogService iIotCmdlogService = SpringUtils.getBean("iotCmdlogServiceImpl");
 
-    public YfBzyCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public YfBzyCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Override
-    public void reqData() {
-        //云飞孢子仪不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
-    }
-
-
     /**
      * 孢子仪的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
@@ -94,7 +87,7 @@ public class YfBzyCmdResultChecker extends CmdResultChecker {
                 cmdModel.setClogValidresult(clogValidresult);
                 cmdModel.setClogDesc(clogDesc);
 
-                iIotCmdlogService.insertSuccessCmdlog(cmdModel);
+                SpringUtils.getBean(IIotCmdlogService.class).insertSuccessCmdlog(cmdModel);
             } else {
                 log.info("TODO 其它指令：" + cmd.getFunc());
             }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/YfCbdCmdResultChecker.java

@@ -17,18 +17,11 @@ import java.util.Set;
 @Slf4j
 public class YfCbdCmdResultChecker extends CmdResultChecker {
 
-    private final IIotCmdlogService iIotCmdlogService = SpringUtils.getBean("iotCmdlogServiceImpl");
 
-    public YfCbdCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public YfCbdCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Override
-    public void reqData() {
-        //云飞测报灯不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
-    }
-
-
     /**
      * 测报灯的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
@@ -36,7 +29,6 @@ public class YfCbdCmdResultChecker extends CmdResultChecker {
     @Override
     public void check(IotDevice iotDevice, JSONObject jobjMsg) {
 
-
         log.debug("云飞测报灯 指令执行结果检查");
         //对于config指令，支持一次设置一个或多个设置项，要判断上报的设置数据中，所有要设置的设置项的值，都已相同，才认为是设置成功
 
@@ -94,7 +86,7 @@ public class YfCbdCmdResultChecker extends CmdResultChecker {
                 cmdModel.setClogValidresult(clogValidresult);
                 cmdModel.setClogDesc(clogDesc);
 
-                iIotCmdlogService.insertSuccessCmdlog(cmdModel);
+                SpringUtils.getBean(IIotCmdlogService.class).insertSuccessCmdlog(cmdModel);
             } else {
                 log.debug("TODO 其它指令：" + cmd.getFunc());
             }