消息回复代码优化

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/alarm/service/impl/IotAlarmRuleServiceImpl.java

@@ -23,6 +23,8 @@ import com.xunmei.host.websocket.service.WebsocketService;
 import com.xunmei.system.api.util.LogUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.util.List;
@@ -54,9 +56,10 @@ public class IotAlarmRuleServiceImpl extends ServiceImpl<IotAlarmRuleMapper, Iot
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         final JSONObject jsb = receiveAndUpdateAlarmRule(req);
-        return WebsocketResult.reply(req,jsb);
+        return WebsocketResult.reply(req, jsb);
     }
 
     @Override
@@ -121,7 +124,7 @@ public class IotAlarmRuleServiceImpl extends ServiceImpl<IotAlarmRuleMapper, Iot
             }
         } catch (Exception e) {
             LogUtils.ALARM_RULE_LOG.error("保存告警规则失败", e);
-            return WebsocketResult.getErrorPayload(e.getMessage());
+            throw new RuntimeException("保存告警规则失败", e);
         }
         return WebsocketResult.getSuccessPayload();
     }

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/dayilcheck/service/impl/IotDailyCheckDataServiceImpl.java

@@ -23,6 +23,7 @@ import com.xunmei.host.websocket.enums.ProductEnums;
 import com.xunmei.host.websocket.service.RouterService;
 import com.xunmei.system.api.util.LogUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
@@ -58,7 +59,7 @@ public class IotDailyCheckDataServiceImpl extends ServiceImpl<IotDailyCheckDataM
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         JSONObject jsonObject = new JSONObject();
         try {
@@ -71,7 +72,7 @@ public class IotDailyCheckDataServiceImpl extends ServiceImpl<IotDailyCheckDataM
             jsonObject = dealData(type, excelData, resultData, serverInfo);
         } catch (Exception e) {
             LogUtils.SOCKET_DAILY_HEALTH.error("[网点客户端自检结果上报],处理失败", e);
-            return WebsocketResult.replyError(req,String.format("处理失败:%s",e));
+           throw new RuntimeException("[网点客户端自检结果上报],处理失败",e);
         }
 
         return WebsocketResult.reply(req, jsonObject);

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/iot/service/impl/IotDeviceInfoServiceImpl.java

@@ -10,6 +10,7 @@ import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.google.common.collect.Sets;
 import com.xunmei.common.core.constant.Constants;
+import com.xunmei.common.core.constant.ErrorMsgConstants;
 import com.xunmei.common.core.domain.iot.domain.IotAlarmDefenceArea;
 import com.xunmei.common.core.domain.iot.domain.IotAlarmSubsystem;
 import com.xunmei.common.core.domain.iot.domain.IotServerInfo;
@@ -50,6 +51,7 @@ import org.redisson.api.RLock;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.io.IOException;
@@ -345,40 +347,41 @@ public class IotDeviceInfoServiceImpl extends ServiceImpl<IotDeviceInfoMapper, I
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
-        LogUtils.SOCKET_BASE_DEVICE_INFO.info("收到消息:{}", JacksonUtils.toJSONString(req));
-        Object data = req.getData();
-        JSONArray dataArray = (JSONArray) data;
-        if (ObjectUtil.isEmpty(dataArray)) {
-            return WebsocketResult.replySuccess(req);
-        }
-        IotServerInfo serverInfo = req.getServerInfo();
-        if (ObjectUtil.isEmpty(serverInfo)) {
-            LogUtils.WEBSOCKET_MSG.error("未查询到token为 {} 的服务器信息", serverInfo.getIotCode());
-            return null;
-        }
-        String event = req.getEvent();
-        switch (event) {
-            case WebSocketConstants.DEVICES_EVENT:
-            case WebSocketConstants.GET_DEVICES_SERVICES:
-                List<DvsBaseInfo> dataList = dataArray.toJavaList(DvsBaseInfo.class);
-
-                List<IotDeviceInfo> syncToAssetDeviceList = new ArrayList<>();
-                handleDvsAndFSUDeviceInfo(dataList, serverInfo, syncToAssetDeviceList);
-                handleAlarmHostDeviceInfo(dataList, serverInfo, syncToAssetDeviceList);
-
-                handelAssetDeviceInfo(syncToAssetDeviceList);
-
+        try {
+            LogUtils.SOCKET_BASE_DEVICE_INFO.info("收到消息:{}", JacksonUtils.toJSONString(req));
+            Object data = req.getData();
+            JSONArray dataArray = (JSONArray) data;
+            if (ObjectUtil.isEmpty(dataArray)) {
                 return WebsocketResult.replySuccess(req);
-            case WebSocketConstants.DEVICES_STATUS_EVENT:
-                List<DeviceStatusInfo> statusInfos = dataArray.toJavaList(DeviceStatusInfo.class);
-                deviceStatusChange(statusInfos, serverInfo);
-                break;
-            default:
-                break;
-        }
-        return null;
+            }
+            IotServerInfo serverInfo = req.getServerInfo();
+            String event = req.getEvent();
+            switch (event) {
+                case WebSocketConstants.DEVICES_EVENT:
+                case WebSocketConstants.GET_DEVICES_SERVICES:
+                    List<DvsBaseInfo> dataList = dataArray.toJavaList(DvsBaseInfo.class);
+
+                    List<IotDeviceInfo> syncToAssetDeviceList = new ArrayList<>();
+                    handleDvsAndFSUDeviceInfo(dataList, serverInfo, syncToAssetDeviceList);
+                    handleAlarmHostDeviceInfo(dataList, serverInfo, syncToAssetDeviceList);
+
+                    handelAssetDeviceInfo(syncToAssetDeviceList);
+
+                    return WebsocketResult.replySuccess(req);
+                case WebSocketConstants.DEVICES_STATUS_EVENT:
+                    List<DeviceStatusInfo> statusInfos = dataArray.toJavaList(DeviceStatusInfo.class);
+                    deviceStatusChange(statusInfos, serverInfo);
+                    break;
+                default:
+                    return WebsocketResult.replyError(req, ErrorMsgConstants.ERROR_ROUTE);
+            }
+        } catch (Exception e) {
+            LogUtils.SOCKET_BASE_DEVICE_INFO.error("设备基础数据,处理失败", e);
+            throw new RuntimeException("设备基础数据,处理失败",e);
+        }
+        return WebsocketResult.replySuccess(req);
     }
 
     private void handelAssetDeviceInfo(List<IotDeviceInfo> syncToAssetDeviceList) {

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/iot/service/impl/IotDeviceStatusServiceImpl.java

@@ -9,6 +9,7 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.xunmei.common.core.constant.Constants;
+import com.xunmei.common.core.constant.ErrorMsgConstants;
 import com.xunmei.common.core.domain.mediator.domain.IotAlarmData;
 import com.xunmei.common.core.domain.mediator.domain.IotAlarmSystemField;
 import com.xunmei.common.core.enums.iot.BaseDeviceTypeEnum;
@@ -36,8 +37,11 @@ import com.xunmei.system.api.domain.iot.IotDeviceStatus;
 import com.xunmei.system.api.util.LogUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
+import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.time.LocalDateTime;
@@ -167,6 +171,7 @@ public class IotDeviceStatusServiceImpl extends ServiceImpl<IotDeviceStatusMappe
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         final String event = req.getEvent();
         switch (event) {
@@ -175,76 +180,80 @@ public class IotDeviceStatusServiceImpl extends ServiceImpl<IotDeviceStatusMappe
             case WebSocketConstants.SUB_DEVICE_ALARM:
                 return dealDeviceAlarm(req);
             default:
-                throw new RuntimeException("未知的消息类型");
+                return WebsocketResult.replyError(req, ErrorMsgConstants.ERROR_ROUTE);
         }
     }
 
     private WebsocketResult dealDeviceAlarm(WebsocketExecuteReq req) {
-        final String iotCode = req.getServerInfo().getIotCode();
-        final SysOrg sysOrg = serverInfoService.selectOrgByToken(iotCode);
-        if (ObjectUtil.isNull(sysOrg)) {
-            LogUtils.SOCKET_DEVICE_ALARM_DATA.error("收到设备报警消息,根据token:{}未查询到机构信息", iotCode);
-            return null;
-        }
-        List<IotAlarmSystemField> fieldList = alarmSystemFieldMapper.selectList(new LambdaQueryWrapper<>());
-
-        final JSONArray data = (JSONArray) req.getData();
-        final List<AlarmDataReq> dataReqList = data.toJavaList(AlarmDataReq.class);
-        if (dataReqList == null || dataReqList.isEmpty()) {
-            return null;
-        }
-        final Date date = new Date();
-        for (AlarmDataReq dataReq : dataReqList) {
-            IotDeviceInfo deviceInfo = iotDeviceInfoService.selectByTokenProductAndDeviceCode(iotCode, req.getProductName(), req.getDeviceName());
-            if (ObjectUtil.isNull(deviceInfo)) {
-                LogUtils.SOCKET_DEVICE_ALARM_DATA.error("收到设备报警消息,根据token:{},productName:{},deviceName:{}未查询到设备信息", iotCode, req.getProductName(), req.getDeviceName());
-                continue;
-            }
-            otherLogic(dataReq, deviceInfo.getId());
-            IotAlarmData iotAlarmData = iotAlarmDataService.getById(dataReq.getId());
-            boolean insert = false;
-            if (iotAlarmData == null) {
-                insert = true;
-                iotAlarmData = BeanHelper.copyProperties(dataReq, IotAlarmData.class);
-                iotAlarmData.setCreateTime(date);
-            }else {
-                BeanUtils.copyProperties(dataReq, iotAlarmData);
-            }
-            iotAlarmData.setUpdateTime(date);
-            iotAlarmData.setOrgId(sysOrg.getId());
-            iotAlarmData.setDeviceId(String.valueOf(deviceInfo.getId()));
-            iotAlarmData.setTime(dataReq.getStartTime());
-            final Optional<IotAlarmSystemField> optional = fieldList.stream()
-                    .filter(r -> ObjectUtil.equal(String.valueOf(r.getProductType()), dataReq.getProductType()))
-                    .filter(r -> ObjectUtil.equal(r.getProductProperty(), dataReq.getProductProperty()))
-                    .findAny();
-            if (optional.isPresent()) {
-                final IotAlarmSystemField field = optional.get();
-                iotAlarmData.setSourceType(field.getProductType());
-                iotAlarmData.setSourceTypeDes(field.getProductName() + "告警");
-                iotAlarmData.setFieldCode(field.getProductProperty());
-            }
-            if (insert) {
-                iotAlarmDataService.save(iotAlarmData);
-            } else {
-                iotAlarmDataService.updateById(iotAlarmData);
+        try {
+            final String iotCode = req.getServerInfo().getIotCode();
+            final SysOrg sysOrg = serverInfoService.selectOrgByToken(iotCode);
+            if (ObjectUtil.isNull(sysOrg)) {
+                String str=String.format("收到设备报警消息,根据token:%s未查询到机构信息",iotCode);
+                LogUtils.SOCKET_DEVICE_ALARM_DATA.error(str);
+                return WebsocketResult.replyError(req,str);
             }
-            // 发生报警
-            if (ObjectUtil.isNotNull(dataReq.getStartTime()) && ObjectUtil.isNull(dataReq.getEndTime())) {
-                updateStatusByDevicePrimaryId(deviceInfo.getId(), DeviceStatusEnum.ALARM.getValue());
-                //判断是否通知app
-                websocketNoticeLogService.noticeAlarm(deviceInfo, iotAlarmData, false);
+            List<IotAlarmSystemField> fieldList = alarmSystemFieldMapper.selectList(new LambdaQueryWrapper<>());
+
+            final JSONArray data = (JSONArray) req.getData();
+            final List<AlarmDataReq> dataReqList = data.toJavaList(AlarmDataReq.class);
+            if (dataReqList == null || dataReqList.isEmpty()) {
+                return null;
             }
-            // 报警结束
-            if (ObjectUtil.isNotNull(dataReq.getStartTime()) && ObjectUtil.isNotNull(dataReq.getEndTime())) {
-                updateStatusByDevicePrimaryId(deviceInfo.getId(), DeviceStatusEnum.NORMAL.getValue());
-                //告警结束需要结束通知
-                websocketNoticeLogService.endNoticeAlarm(deviceInfo, iotAlarmData);
+            final Date date = new Date();
+            for (AlarmDataReq dataReq : dataReqList) {
+                IotDeviceInfo deviceInfo = iotDeviceInfoService.selectByTokenProductAndDeviceCode(iotCode, req.getProductName(), req.getDeviceName());
+                if (ObjectUtil.isNull(deviceInfo)) {
+                    String str=String.format("收到设备报警消息,根据token:%s,productName:%s,deviceName:%s未查询到设备信息",iotCode,req.getProductName(),req.getDeviceName());
+                    throw new RuntimeException(str);
+                }
+                otherLogic(dataReq, deviceInfo.getId());
+                IotAlarmData iotAlarmData = iotAlarmDataService.getById(dataReq.getId());
+                boolean insert = false;
+                if (iotAlarmData == null) {
+                    insert = true;
+                    iotAlarmData = BeanHelper.copyProperties(dataReq, IotAlarmData.class);
+                    iotAlarmData.setCreateTime(date);
+                }else {
+                    BeanUtils.copyProperties(dataReq, iotAlarmData);
+                }
+                iotAlarmData.setUpdateTime(date);
+                iotAlarmData.setOrgId(sysOrg.getId());
+                iotAlarmData.setDeviceId(String.valueOf(deviceInfo.getId()));
+                iotAlarmData.setTime(dataReq.getStartTime());
+                final Optional<IotAlarmSystemField> optional = fieldList.stream()
+                        .filter(r -> ObjectUtil.equal(String.valueOf(r.getProductType()), dataReq.getProductType()))
+                        .filter(r -> ObjectUtil.equal(r.getProductProperty(), dataReq.getProductProperty()))
+                        .findAny();
+                if (optional.isPresent()) {
+                    final IotAlarmSystemField field = optional.get();
+                    iotAlarmData.setSourceType(field.getProductType());
+                    iotAlarmData.setSourceTypeDes(field.getProductName() + "告警");
+                    iotAlarmData.setFieldCode(field.getProductProperty());
+                }
+                if (insert) {
+                    iotAlarmDataService.save(iotAlarmData);
+                } else {
+                    iotAlarmDataService.updateById(iotAlarmData);
+                }
+                // 发生报警
+                if (ObjectUtil.isNotNull(dataReq.getStartTime()) && ObjectUtil.isNull(dataReq.getEndTime())) {
+                    updateStatusByDevicePrimaryId(deviceInfo.getId(), DeviceStatusEnum.ALARM.getValue());
+                    //判断是否通知app
+                    websocketNoticeLogService.noticeAlarm(deviceInfo, iotAlarmData, false);
+                }
+                // 报警结束
+                if (ObjectUtil.isNotNull(dataReq.getStartTime()) && ObjectUtil.isNotNull(dataReq.getEndTime())) {
+                    updateStatusByDevicePrimaryId(deviceInfo.getId(), DeviceStatusEnum.NORMAL.getValue());
+                    //告警结束需要结束通知
+                    websocketNoticeLogService.endNoticeAlarm(deviceInfo, iotAlarmData);
+                }
             }
+        } catch (BeansException e) {
+            LogUtils.SOCKET_DEVICE_ALARM_DATA.error("收到设备报警消息,处理发生异常", e);
+            throw new RuntimeException(e);
         }
-
-
-        return null;
+        return WebsocketResult.replySuccess(req);
     }
 
     private void otherLogic(AlarmDataReq dataReq, Long deviceId) {
@@ -284,46 +293,52 @@ public class IotDeviceStatusServiceImpl extends ServiceImpl<IotDeviceStatusMappe
     }
 
     private WebsocketResult dealDeviceStatus(WebsocketExecuteReq req) {
-        final String iotCode = req.getServerInfo().getIotCode();
-        final JSONObject reqDataObj = (JSONObject) req.getData();
-        final Object reqStatus = reqDataObj.get(WebSocketConstants.STATUS);
-        if (ObjectUtil.isNull(reqStatus)) {
-            LogUtils.SOCKET_DEVICE_STATUS_INFO.error("设备状态同步时,参数异常,status为空,token:{}", iotCode);
-            return new WebsocketResult();
-        }
-        final JSONArray data = (JSONArray) reqStatus;
-        final String productName = req.getProductName();
-        final BaseDeviceTypeEnum deviceTypeEnum = BaseDeviceTypeEnum.valueOf(productName);
+        try {
+            final String iotCode = req.getServerInfo().getIotCode();
+            final JSONObject reqDataObj = (JSONObject) req.getData();
+            final Object reqStatus = reqDataObj.get(WebSocketConstants.STATUS);
+            if (ObjectUtil.isNull(reqStatus)) {
+                String str=String.format("设备状态同步时,参数异常,status为空,token:%s",iotCode);
+                LogUtils.SOCKET_DEVICE_STATUS_INFO.error(str);
+                return WebsocketResult.replyError(req,str);
+            }
+            final JSONArray data = (JSONArray) reqStatus;
+            final String productName = req.getProductName();
+            final BaseDeviceTypeEnum deviceTypeEnum = BaseDeviceTypeEnum.valueOf(productName);
 
-        final IotDeviceInfo code = iotDeviceInfoService.selectByTypeAndCode(iotCode, deviceTypeEnum.getCode(), req.getProductName(), req.getDeviceName());
-        if (code == null) {
-            LogUtils.SOCKET_DEVICE_STATUS_INFO.error("设备状态同步时,未能找到对应设备,token:{},productName:{},deviceNane:{}", iotCode, req.getProductName(), req.getDeviceName());
-            return new WebsocketResult();
-        }
-        String deviceType = SensorType.getCodeByProduct(productName);
-        List<IotAlarmSystemField> fieldList = alarmSystemFieldMapper.selectList(new LambdaQueryWrapper<>());
-        final JSONArray array = dealStatusData(data, fieldList, deviceTypeEnum.name());
-        IotDeviceStatus status = getByDeviceId(code.getId());
-        final LocalDateTime now = LocalDateTime.now();
-        if (status == null) {
-            status = new IotDeviceStatus();
-            BeanUtils.copyProperties(code, status, "id");
-            status.setDeviceId(code.getId());
-            status.setId(IdWorker.getId());
-            status.setUniqueCode();
-            status.setDeviceType(deviceType);
-            status.setInfo(JSON.toJSONString(array));
-            status.setStateUpdateTime(now);
-            status.setStateStartTime(now);
-            status.setState(0);
-            save(status);
-        } else {
-            status.setInfo(JSON.toJSONString(array));
-            status.setStateStartTime(now);
-            status.setStateUpdateTime(now);
-            updateById(status);
+            final IotDeviceInfo code = iotDeviceInfoService.selectByTypeAndCode(iotCode, deviceTypeEnum.getCode(), req.getProductName(), req.getDeviceName());
+            if (code == null) {
+                String str=String.format("设备状态同步时,未能找到对应设备,token:%s,productName:%s,deviceNane:%s", iotCode, req.getProductName(), req.getDeviceName());
+                LogUtils.SOCKET_DEVICE_STATUS_INFO.error(str);
+                return WebsocketResult.replyError(req,str);
+            }
+            String deviceType = SensorType.getCodeByProduct(productName);
+            List<IotAlarmSystemField> fieldList = alarmSystemFieldMapper.selectList(new LambdaQueryWrapper<>());
+            final JSONArray array = dealStatusData(data, fieldList, deviceTypeEnum.name());
+            IotDeviceStatus status = getByDeviceId(code.getId());
+            final LocalDateTime now = LocalDateTime.now();
+            if (status == null) {
+                status = new IotDeviceStatus();
+                BeanUtils.copyProperties(code, status, "id");
+                status.setDeviceId(code.getId());
+                status.setId(IdWorker.getId());
+                status.setUniqueCode();
+                status.setDeviceType(deviceType);
+                status.setInfo(JSON.toJSONString(array));
+                status.setStateUpdateTime(now);
+                status.setStateStartTime(now);
+                status.setState(0);
+                save(status);
+            } else {
+                status.setInfo(JSON.toJSONString(array));
+                status.setStateStartTime(now);
+                status.setStateUpdateTime(now);
+                updateById(status);
+            }
+            deviceStatusLogService.saveLog(status);
+            return WebsocketResult.replySuccess(req);
+        } catch (Exception e) {
+            throw new RuntimeException("设备状态同步,处理失败",e);
         }
-        deviceStatusLogService.saveLog(status);
-        return null;
     }
 }

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/protection/service/impl/IotAlarmHostServiceImpl.java

@@ -45,6 +45,7 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
@@ -89,7 +90,7 @@ public class IotAlarmHostServiceImpl implements IIotAlarmHostService, RouterServ
     @Resource
     private IWebsocketNoticeLogService websocketNoticeLogService;
 
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
     public JSONObject changeSubSystemStatus(WebsocketExecuteReq req) {
         try {
             LogUtils.STATUS_INFO_DEFENCEAREA.info("【报警主机布撤防状态变更事件】【token:{}】【msgId：{}】【接收参数：{}】", req.getServerInfo().getIotCode(), req.getId(), JSON.toJSONString(req));
@@ -129,11 +130,11 @@ public class IotAlarmHostServiceImpl implements IIotAlarmHostService, RouterServ
             return WebsocketResult.getSuccessPayload();
         } catch (Exception e) {
             LogUtils.STATUS_INFO_DEFENCEAREA.error("处理报警主机布撤防状态改变事件出错", e);
-            return WebsocketResult.getErrorPayload(e.getMessage());
+            throw new RuntimeException("处理报警主机布撤防状态改变事件出错", e);
         }
     }
 
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
     public JSONObject changeAlarmHostSensorStatus(WebsocketExecuteReq req) {
         try {
             LogUtils.STATUS_INFO_STATUS_SENSOR.info("【报警主机传感器状态事件】【token:{}】【msgId：{}】【接收参数：{}】", req.getServerInfo().getIotCode(), req.getId(), JSON.toJSONString(req));
@@ -202,7 +203,7 @@ public class IotAlarmHostServiceImpl implements IIotAlarmHostService, RouterServ
             }
         } catch (Exception e) {
             LogUtils.STATUS_INFO_STATUS_SENSOR.error("处理报警主机传感器状态事件出错", e);
-            return WebsocketResult.getErrorPayload(e.getMessage());
+            throw new RuntimeException("处理报警主机传感器状态事件出错", e);
         }
         return WebsocketResult.getSuccessPayload();
     }
@@ -336,7 +337,7 @@ public class IotAlarmHostServiceImpl implements IIotAlarmHostService, RouterServ
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         final String event = req.getEvent();
         JSONObject jsb;

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/video/service/impl/IotDvrHardDiskDetectionServiceImpl.java

@@ -35,6 +35,7 @@ import com.xunmei.system.api.dto.protection.VideoRecorderHardDiskDetectionEditDt
 import com.xunmei.system.api.util.LogUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
@@ -82,7 +83,7 @@ public class IotDvrHardDiskDetectionServiceImpl extends ServiceImpl<IotDvrHardDi
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         try {
             JSONObject data = (JSONObject) req.getData();
@@ -99,13 +100,10 @@ public class IotDvrHardDiskDetectionServiceImpl extends ServiceImpl<IotDvrHardDi
             dto.setDeviceName(req.getDeviceName());
             dto.setProductName(req.getProductName());
             final ReceiveErrorDto res = saveData(dto, req.getId());
-            return null;
-            //构建返回数据
-           /* String topic = req.getTopic() + "/reply";
-            final JSONObject errorDto = IotServerUtils.dealReceiveErrorDto(res);
-            return IotServerUtils.invokeUpLinkServer(topic, req.getProductName(), req.getDeviceName(), req.getEvent(), errorDto, req.getId());*/
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
+            final JSONObject errorDto = WebsocketResult.dealReceiveErrorDto(res);
+            return WebsocketResult.reply(req, errorDto);
+        } catch (Exception e) {
+            throw new RuntimeException("处理硬盘检测数据上报发生异常",e);
         }
     }
 

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/websocket/handler/SocWebSocketHandler.java

@@ -200,7 +200,12 @@ public class SocWebSocketHandler extends AbstractWebSocketHandler {
                         WebSocketUtils.sendMessage(session, WebsocketResult.replyError(executeReq, ErrorMsgConstants.ERROR_TOPIC));
                         return;
                     }
-                    result = routeService.execute(executeReq);
+                    try {
+                        result = routeService.execute(executeReq);
+                    } catch (Exception e) {
+                        LogUtils.WEBSOCKET_MSG.error("消息处理失败,ip:{},异常内容:{},消息id:{}", ip, e,executeReq.getId());
+                        result = WebsocketResult.replyError(executeReq, e.getMessage());
+                    }
                     break;
                 default:
                     WebSocketUtils.sendMessage(session, WebsocketResult.replyError(executeReq, ErrorMsgConstants.ERROR_TOPIC));

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/work/service/impl/IotDayWorkOperationServiceImpl.java

@@ -81,7 +81,7 @@ public class IotDayWorkOperationServiceImpl extends ServiceImpl<IotDayWorkOperat
             }
         } catch (BeansException e) {
             LogUtils.SOCKET_WORK_OPERATION_DATA.error("一键上下班操作数据,处理失败", e);
-            return WebsocketResult.replyError(req,String.format("一键上下班操作数据处理失败:%s",e));
+            throw new RuntimeException("一键上下班操作数据,处理失败",e);
         }
         return WebsocketResult.replySuccess(req);
     }

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/work/service/impl/IotDayWorkServiceImpl.java

@@ -20,7 +20,9 @@ import com.xunmei.host.work.mapper.IotDayWorkMapper;
 import com.xunmei.host.work.service.IotDayWorkService;
 import com.xunmei.system.api.util.LogUtils;
 import org.springframework.beans.BeanUtils;
+import org.springframework.beans.BeansException;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
@@ -56,50 +58,52 @@ public class IotDayWorkServiceImpl extends ServiceImpl<IotDayWorkMapper, IotDayW
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         final String event = req.getEvent();
         switch (event) {
             case WebSocketConstants.WORK:
-                dealIotDayWorkData(req);
-                break;
+                return dealIotDayWorkData(req);
             case WebSocketConstants.PASSWORD_CHANGE:
-                dealPassWordChange(req);
-                break;
+                return dealPassWordChange(req);
             default:
                 return WebsocketResult.replyError(req, ErrorMsgConstants.ERROR_ROUTE);
         }
-        return WebsocketResult.replySuccess(req);
     }
 
-    private void dealIotDayWorkData(WebsocketExecuteReq req) {
-        Object data = req.getData();
-        LogUtils.SOCKET_WORK_DATA.info("接收到一键上下班主表数据:{}", data);
-        final IotServerInfo serverInfo = req.getServerInfo();
-        DayWorKReq work = JSON.parseObject(data.toString(), DayWorKReq.class);
-        IotDayWork dayWork = findByHostDataIdAndIotCode(work.getId(), req.getServerInfo().getIotCode());
-        if (dayWork != null) {
-            BeanUtils.copyProperties(work, dayWork, "id");
-            dayWork.setHostDataId(work.getId());
-            dayWork.setOrgId(serverInfo.getOrgId());
-            dayWork.setOrgName(serverInfo.getOrgName());
-            dayWork.setOrgPath(serverInfo.getOrgPath());
-            updateById(dayWork);
-        } else {
-            dayWork = new IotDayWork();
-            dayWork.setId(IdWorker.getId());
-            dayWork.setOrgId(serverInfo.getOrgId());
-            dayWork.setOrgName(serverInfo.getOrgName());
-            dayWork.setOrgPath(serverInfo.getOrgPath());
-            dayWork.setHostDataId(work.getId());
-            dayWork.setIotCode(serverInfo.getIotCode());
-            this.save(dayWork);
+    private WebsocketResult dealIotDayWorkData(WebsocketExecuteReq req) {
+        try {
+            Object data = req.getData();
+            LogUtils.SOCKET_WORK_DATA.info("接收到一键上下班主表数据:{}", data);
+            final IotServerInfo serverInfo = req.getServerInfo();
+            DayWorKReq work = JSON.parseObject(data.toString(), DayWorKReq.class);
+            IotDayWork dayWork = findByHostDataIdAndIotCode(work.getId(), req.getServerInfo().getIotCode());
+            if (dayWork != null) {
+                BeanUtils.copyProperties(work, dayWork, "id");
+                dayWork.setHostDataId(work.getId());
+                dayWork.setOrgId(serverInfo.getOrgId());
+                dayWork.setOrgName(serverInfo.getOrgName());
+                dayWork.setOrgPath(serverInfo.getOrgPath());
+                updateById(dayWork);
+            } else {
+                dayWork = new IotDayWork();
+                dayWork.setId(IdWorker.getId());
+                dayWork.setOrgId(serverInfo.getOrgId());
+                dayWork.setOrgName(serverInfo.getOrgName());
+                dayWork.setOrgPath(serverInfo.getOrgPath());
+                dayWork.setHostDataId(work.getId());
+                dayWork.setIotCode(serverInfo.getIotCode());
+                this.save(dayWork);
+            }
+        } catch (BeansException e) {
+            LogUtils.SOCKET_WORK_DATA.error("一键上下班主表数据,处理失败", e);
+            throw new RuntimeException("一键上下班主表数据,处理失败",e);
         }
+        return WebsocketResult.replySuccess(req);
     }
 
-    private void dealPassWordChange(WebsocketExecuteReq req) {
+    private WebsocketResult dealPassWordChange(WebsocketExecuteReq req) {
         Object data = req.getData();
-        LogUtils.SOCKET_WORK_DATA.info("接收到上下班操作密码修改数据:{}", data);
         final IotServerInfo serverInfo = req.getServerInfo();
         try {
             final Map map = JSON.parseObject(data.toString(), Map.class);
@@ -107,10 +111,9 @@ public class IotDayWorkServiceImpl extends ServiceImpl<IotDayWorkMapper, IotDayW
             serverInfo.setPassword(RsaHelper.decodeStr(password));
             serverInfoService.updateById(serverInfo);
         } catch (Exception e) {
-
-            LogUtils.SOCKET_WORK_DATA.error("上下班操作密码修改失败:{}", e.getMessage());
-            throw new RuntimeException(e);
+            throw new RuntimeException("主机一键上下班操作密码同步处理失败",e);
         }
+        return WebsocketResult.replySuccess(req);
     }
 
     @Override

soc-modules/soc-modules-host/src/main/java/com/xunmei/host/work/service/impl/IotWorkRuleServiceImpl.java

@@ -6,6 +6,7 @@ import com.alibaba.fastjson.JSONArray;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.xunmei.common.core.constant.ErrorMsgConstants;
 import com.xunmei.common.core.domain.iot.domain.IotAlarmSubsystem;
 import com.xunmei.common.core.domain.iot.domain.IotServerInfo;
 import com.xunmei.common.core.domain.work.domain.IotWorkRule;
@@ -27,6 +28,7 @@ import com.xunmei.host.work.service.IotWorkRuleItemService;
 import com.xunmei.host.work.service.IotWorkRuleService;
 import com.xunmei.system.api.util.LogUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
@@ -75,53 +77,66 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
     public WebsocketResult execute(WebsocketExecuteReq req) {
         LogUtils.SOCKET_WORK_RULE_DATA.info("收到消息:{}", JacksonUtils.toJSONString(req));
-        if (WebSocketConstants.WORK_RULE.equals(req.getEvent())) {
-            saveBatchWorkRule(req);
-        } else if (WebSocketConstants.INCREMENT_WORK_RULE.equals(req.getEvent())) {
-            saveOrUpdateWorkRule(req);
-        }else if (WebSocketConstants.DELETE_WORK_RULE.equals(req.getEvent())) {
-            deleteData(req);
+
+        final String event = req.getEvent();
+        switch (event) {
+            case WebSocketConstants.WORK_RULE:
+                saveBatchWorkRule(req);
+                break;
+            case WebSocketConstants.INCREMENT_WORK_RULE:
+                saveOrUpdateWorkRule(req);
+                break;
+            case WebSocketConstants.DELETE_WORK_RULE:
+                deleteData(req);
+                break;
+            default:
+                return WebsocketResult.replyError(req, ErrorMsgConstants.ERROR_ROUTE);
         }
-        return null;
+
+        return WebsocketResult.replySuccess(req);
     }
 
     @Transactional(rollbackFor = Exception.class)
     public void saveBatchWorkRule(WebsocketExecuteReq req) {
-        Object data = req.getData();
-        JSONArray dataArray = (JSONArray) data;
-        List<WorkRuleReq> dataList = dataArray.toJavaList(WorkRuleReq.class);
-        String iotToken = req.getServerInfo().getIotCode();
-        //查询所有数据
-        QueryWrapper<IotWorkRule> wrapper = new QueryWrapper<>();
-        wrapper.lambda().eq(IotWorkRule::getIotToken, iotToken);
-        List<IotWorkRule> ruleList = super.list();
-
-        //删除主机不存在的规则
-        if (ruleList != null && ruleList.size() > 0){
-            Iterator<IotWorkRule> iterator = ruleList.iterator();
-            while (iterator.hasNext()){
-                IotWorkRule next = iterator.next();
-                for (WorkRuleReq workRuleReq : dataList) {
-                    boolean b = ObjectUtil.equal(next.getWorkRuleType(), workRuleReq.getWorkRuleType()) && ObjectUtil.equal(next.getRuleObjStatus(), workRuleReq.getRuleObjStatus())
-                            && ObjectUtil.equal(next.getWorkType(), workRuleReq.getWorkType());
-                    if (b){
-                        iterator.remove();
+        try {
+            Object data = req.getData();
+            JSONArray dataArray = (JSONArray) data;
+            List<WorkRuleReq> dataList = dataArray.toJavaList(WorkRuleReq.class);
+            String iotToken = req.getServerInfo().getIotCode();
+            //查询所有数据
+            QueryWrapper<IotWorkRule> wrapper = new QueryWrapper<>();
+            wrapper.lambda().eq(IotWorkRule::getIotToken, iotToken);
+            List<IotWorkRule> ruleList = super.list();
+
+            //删除主机不存在的规则
+            if (ruleList != null && ruleList.size() > 0) {
+                Iterator<IotWorkRule> iterator = ruleList.iterator();
+                while (iterator.hasNext()) {
+                    IotWorkRule next = iterator.next();
+                    for (WorkRuleReq workRuleReq : dataList) {
+                        boolean b = ObjectUtil.equal(next.getWorkRuleType(), workRuleReq.getWorkRuleType()) && ObjectUtil.equal(next.getRuleObjStatus(), workRuleReq.getRuleObjStatus())
+                                && ObjectUtil.equal(next.getWorkType(), workRuleReq.getWorkType());
+                        if (b) {
+                            iterator.remove();
+                        }
                     }
                 }
-            }
-            if (ruleList.size() > 0){
-                for (IotWorkRule workRule : ruleList) {
-                    deleteWorkRule(workRule);
+                if (ruleList.size() > 0) {
+                    for (IotWorkRule workRule : ruleList) {
+                        deleteWorkRule(workRule);
+                    }
                 }
             }
-        }
 
-        //新增或修改主机上送上来的规则
-        for (WorkRuleReq workRuleReq : dataList) {
-            saveData(workRuleReq,iotToken);
+            //新增或修改主机上送上来的规则
+            for (WorkRuleReq workRuleReq : dataList) {
+                saveData(workRuleReq, iotToken);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("处理主机上报的一键上下班规则发生异常",e);
         }
     }
 
@@ -129,11 +144,11 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
     public void saveOrUpdateWorkRule(WebsocketExecuteReq req) {
         Object data = req.getData();
         WorkRuleReq workRuleReq = JSON.parseObject(data.toString(), WorkRuleReq.class);
-        saveData(workRuleReq,req.getServerInfo().getIotCode());
+        saveData(workRuleReq, req.getServerInfo().getIotCode());
     }
 
     @Transactional(rollbackFor = Exception.class)
-    public void deleteData(WebsocketExecuteReq req){
+    public void deleteData(WebsocketExecuteReq req) {
         Object data = req.getData();
         WorkRuleReq workRuleReq = JSON.parseObject(data.toString(), WorkRuleReq.class);
 
@@ -142,57 +157,57 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
     }
 
     @Transactional(rollbackFor = Exception.class)
-    public void saveData(WorkRuleReq workRuleReq,String iotToken) {
+    public void saveData(WorkRuleReq workRuleReq, String iotToken) {
         IotWorkRule workRule = getWorkRule(workRuleReq, iotToken);
         List<IotWorkRuleItem> deleteList = new ArrayList<>();
         List<IotWorkRuleItem> updateList = new ArrayList<>();
         List<IotWorkRuleItem> addList = new ArrayList<>();
         //修改
-        if (null != workRule){
+        if (null != workRule) {
             workRule.setRemark(workRuleReq.getRemark());
             workRule.setUpdateTime(new Date());
             super.updateById(workRule);
 
             List<WorkRuleItemReq> items = workRuleReq.getItems();
             List<IotWorkRuleItem> itemList = ruleItemService.getByRuleId(workRule.getId());
-            if (itemList != null && itemList.size() > 0){
-                if (items != null && items.size() > 0){
+            if (itemList != null && itemList.size() > 0) {
+                if (items != null && items.size() > 0) {
                     Iterator<IotWorkRuleItem> iterator = itemList.iterator();
-                    while (iterator.hasNext()){
+                    while (iterator.hasNext()) {
                         IotWorkRuleItem next = iterator.next();
-                        for(WorkRuleItemReq item : items) {
-                            boolean b = ObjectUtil.equal(next.getZoneId(),item.getZoneId()) && ObjectUtil.equal(next.getAlarmHost(),item.getHostDeviceName())
-                                    && ObjectUtil.equal(next.getIotToken(),iotToken);
-                            if (b){
+                        for (WorkRuleItemReq item : items) {
+                            boolean b = ObjectUtil.equal(next.getZoneId(), item.getZoneId()) && ObjectUtil.equal(next.getAlarmHost(), item.getHostDeviceName())
+                                    && ObjectUtil.equal(next.getIotToken(), iotToken);
+                            if (b) {
                                 updateList.add(next);
                                 iterator.remove();
                             }
                         }
                     }
-                    if (itemList.size() > 0){
+                    if (itemList.size() > 0) {
                         deleteList.addAll(itemList);
                     }
 
-                }else {
+                } else {
                     deleteList.addAll(itemList);
                 }
-                if(updateList.size() > 0){
+                if (updateList.size() > 0) {
                     //删除需要修改的数据，剩下的就是需要新增的数据
                     items.removeIf(item -> updateList.stream().anyMatch(next -> ObjectUtil.equal(next.getZoneId(), item.getZoneId()) && ObjectUtil.equal(next.getAlarmHost(), item.getHostDeviceName())));
                 }
             }
-            if (items != null && items.size() > 0){
-                for(WorkRuleItemReq itemReq : items){
+            if (items != null && items.size() > 0) {
+                for (WorkRuleItemReq itemReq : items) {
                     IotWorkRuleItem item = new IotWorkRuleItem();
                     item.setRuleId(workRule.getId());
                     item.setZoneId(itemReq.getZoneId());
                     item.setAlarmHost(itemReq.getHostDeviceName());
                     item.setIotToken(iotToken);
-                    item.setObjId(getSubSystemId(itemReq.getZoneId(),itemReq.getHostDeviceName(),iotToken));
+                    item.setObjId(getSubSystemId(itemReq.getZoneId(), itemReq.getHostDeviceName(), iotToken));
                     addList.add(item);
                 }
             }
-        }else {
+        } else {
             //新增
             workRule = new IotWorkRule();
             long ruleId = IdWorker.getId();
@@ -208,48 +223,48 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
             super.save(workRule);
 
             List<WorkRuleItemReq> items = workRuleReq.getItems();
-            if (items != null && items.size() > 0){
-                for(WorkRuleItemReq itemReq : items){
+            if (items != null && items.size() > 0) {
+                for (WorkRuleItemReq itemReq : items) {
                     IotWorkRuleItem item = new IotWorkRuleItem();
                     item.setId(IdWorker.getId());
                     item.setRuleId(ruleId);
                     item.setZoneId(itemReq.getZoneId());
                     item.setAlarmHost(itemReq.getHostDeviceName());
                     item.setIotToken(iotToken);
-                    item.setObjId(getSubSystemId(itemReq.getZoneId(),itemReq.getHostDeviceName(),iotToken));
+                    item.setObjId(getSubSystemId(itemReq.getZoneId(), itemReq.getHostDeviceName(), iotToken));
                     addList.add(item);
                 }
             }
         }
-        if (addList.size() > 0){
+        if (addList.size() > 0) {
             ruleItemService.saveBatch(addList);
         }
-        if (updateList.size() > 0){
+        if (updateList.size() > 0) {
             ruleItemService.updateBatchById(updateList);
         }
-        if (deleteList.size() > 0){
+        if (deleteList.size() > 0) {
             ruleItemService.removeBatchByIds(deleteList);
         }
 
         String password = null;
         //修改操作密码
-        if (StringUtils.isNotEmpty(workRuleReq.getPassword())){
+        if (StringUtils.isNotEmpty(workRuleReq.getPassword())) {
             try {
                 password = RsaHelper.decodeStr(workRuleReq.getPassword());
-            }catch (Exception e){
+            } catch (Exception e) {
                 throw new RuntimeException("密码解密失败");
             }
         }
         QueryWrapper<IotServerInfo> wrapper = new QueryWrapper<>();
         wrapper.lambda().eq(IotServerInfo::getIotCode, iotToken);
         IotServerInfo serverInfo = iotServerInfoService.getOne(wrapper);
-        if (null != serverInfo){
+        if (null != serverInfo) {
             serverInfo.setPassword(password);
             iotServerInfoService.updateById(serverInfo);
         }
     }
 
-    private IotWorkRule getWorkRule(WorkRuleReq workRuleReq,String iotToken){
+    private IotWorkRule getWorkRule(WorkRuleReq workRuleReq, String iotToken) {
         QueryWrapper<IotWorkRule> wrapper = new QueryWrapper<>();
         wrapper.lambda()
                 .eq(IotWorkRule::getWorkRuleType, workRuleReq.getWorkRuleType())
@@ -261,14 +276,13 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
     }
 
 
-
-    private void deleteItemByRuleId(Long ruleId){
+    private void deleteItemByRuleId(Long ruleId) {
         QueryWrapper<IotWorkRuleItem> wrapper = new QueryWrapper<>();
         wrapper.lambda().eq(IotWorkRuleItem::getRuleId, ruleId);
         ruleItemService.remove(wrapper);
     }
 
-    private Long getSubSystemId(Integer zoneId,String alarmHostCode,String iotToken){
+    private Long getSubSystemId(Integer zoneId, String alarmHostCode, String iotToken) {
         QueryWrapper<IotAlarmSubsystem> wrapper = new QueryWrapper<>();
         wrapper.lambda()
                 .eq(IotAlarmSubsystem::getCode, zoneId.toString())
@@ -277,7 +291,7 @@ public class IotWorkRuleServiceImpl extends ServiceImpl<IotWorkRuleMapper, IotWo
                 .eq(IotAlarmSubsystem::getDeleted, 0);
 
         IotAlarmSubsystem subsystem = subsystemService.getOne(wrapper);
-        if(null != subsystem){
+        if (null != subsystem) {
             return subsystem.getId();
         }
         return null;