优化日志记录

src/main/java/com/persagy/cache/AlarmInfoCache.java

@@ -48,7 +48,7 @@ public class AlarmInfoCache {
 
     /**
      * @param :
-     * @description:获取报警状态 <报警定义标识，报警时间状态>
+     * @description:获取报警定义状态 <报警定义标识，报警时间状态>
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
@@ -56,7 +56,7 @@ public class AlarmInfoCache {
      * @since: 2020/10/20 17:12
      * @version: V1.0
      */
-    public AlarmDefineState getAlarmState(String definitionId) {
+    public AlarmDefineState getAlarmDefineState(String definitionId) {
         return alarmStateMap.get(definitionId);
     }
 

src/main/java/com/persagy/entity/AlarmDefineState.java

@@ -33,9 +33,9 @@ public class AlarmDefineState {
      */
     private String alarmStartTime = "";
     /**
-     * 报警恢复开始时间
+     * 报警中止（恢复）开始时间
      */
-    private String alarmEndTime = "";
+    private String alarmSuspendStartTime = "";
 
     public AlarmDefineState(String definitionId) {
         this.definitionId = definitionId;

src/main/java/com/persagy/job/AlarmExpireJob.java

@@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.quartz.QuartzJobBean;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -128,7 +129,7 @@ public class AlarmExpireJob extends QuartzJobBean {
                     message.setEndInfo(endInfo);
                     message.setEndTime(DateUtils.parseDate(endTime));
                 }
-                nettyMessage.setContent(Arrays.asList(message));
+                nettyMessage.setContent(Collections.singletonList(message));
                 //{"id","123", "state":1, "groupCode":"wd", "projectId":"Pj123"}
                 groupNettyClient.sendMessage(nettyMessage.toString());
                 //已经过期的时候删除掉这条报警定义了，保证不会再次产生报警

src/main/java/com/persagy/service/impl/AlarmHandleServiceImpl.java

@@ -73,6 +73,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      */
     @Override
     public void handleIOTData(String msg) throws SchedulerException, InterruptedException {
+        log.info("接收到采集值：[{}]", msg);
         String[] split = msg.split(";");
         if (split.length % 4 != 0) {
             return;
@@ -80,7 +81,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
         //返回的信息点个数
         int nums = (split.length) / 4;
         for (int i = 0; i < nums; i++) {
-            String dateTime = split[i * 4];
+            String dataTime = split[i * 4];
             String meterId = split[i * 4 + 1];
             String funcId = split[i * 4 + 2];
             double value = Double.parseDouble(split[i * 4 + 3]);
@@ -109,26 +110,26 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                         Expression endExp = AviatorEvaluator.compile(end, true);
                         Boolean triggerResult = (Boolean) triggerExp.execute(paramMap);
                         Boolean endResult = (Boolean) endExp.execute(paramMap);
+                        log.info("defineId: [{}]", defineId);
                         log.info("triggerResult:[{}],endResult:[{}]", triggerResult, endResult);
                         if (triggerResult && endResult) {
                             log.warn("报警触发条件和报警恢复条件同时满足，请检查，报警定义详情【{}】", alarmDefine.toString());
                         }
                         // 使用intern（）方法，确保上锁的是同一个String对象
                         synchronized (defineId.intern()) {
-
                             //报警产生值满足（这里的满足不考虑报警持续时间）
                             if (triggerResult) {
-                                log.info("有一条满足报警条件");
+                                log.info("满足报警条件");
                                 log.info("--" + alarmDefine.toString());
                                 log.info("--" + JSONObject.toJSONString(paramMap));
                                 //报警的时候不考虑报警恢复，因为同时报警和报警恢复是不应该出现的
-                                handlerNowDataAlarm(alarmDefine, dateTime, paramMap);
+                                handlerNowDataAlarm(alarmDefine, dataTime, paramMap);
                             } else {
                                 log.info("不满足报警条件");
                                 log.info("--" + alarmDefine.toString());
                                 log.info("--" + JSONObject.toJSONString(paramMap));
                                 //当前数据正常
-                                handlerNowDataNormal(alarmDefine, dateTime, endResult, paramMap);
+                                handlerNowDataNormal(alarmDefine, dataTime, endResult, paramMap);
                             }
                         }
                     } else {
@@ -141,36 +142,36 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
     }
 
     /**
-     * @description: 根据报警定义唯一标识从缓存或数据库中获取alarmState
+     * @description: 根据报警定义唯一标识从缓存或数据库中获取AlarmDefineState
      * @param: defineId 报警定义唯一标识
-     * @return: com.persagy.entity.AlarmState
      * @exception:
      * @author: lixing
      * @company: Persagy Technology Co.,Ltd
      * @since: 2021/1/8 上午11:05
      * @version: V1.0
      */
-    private AlarmDefineState getAlarmStateFromCacheOrDb(String defineId) {
-        AlarmDefineState alarmState = alarmInfoCache.getAlarmState(defineId);
-        if (Objects.isNull(alarmState)) {
+    private AlarmDefineState getAlarmDefineStateFromCacheOrDb(String defineId) {
+        AlarmDefineState alarmDefineState = alarmInfoCache.getAlarmDefineState(defineId);
+        if (Objects.isNull(alarmDefineState)) {
             //默认正常报警状态
-            alarmState = new AlarmDefineState(defineId);
+            alarmDefineState = new AlarmDefineState(defineId);
             Optional<ZktAlarmRecordDO> recordOptional = alarmRecordRepository.findById(defineId);
             if (recordOptional.isPresent()) {
                 ZktAlarmRecordDO alarmRecordDO = recordOptional.get();
                 //数据库报警状态：1-未处理
                 if ("1".equals(alarmRecordDO.getState())) {
-                    alarmState.setState(AlarmDefineState.State.NOT_DEAL.getType());
-                    alarmState.setAlarmStartTime(alarmRecordDO.getAlarmTime());
+                    alarmDefineState.setState(AlarmDefineState.State.NOT_DEAL.getType());
+                    alarmDefineState.setAlarmStartTime(alarmRecordDO.getAlarmTime());
                 }
             }
         }
-        return alarmState;
+        log.info("alarmDefineState: [{}], （ 0-正常 1-报警）", alarmDefineState.getState());
+        return alarmDefineState;
     }
 
     /**
-     * @param alarmDefine :       报警定义
-     * @param dateTime    :IOT采集时间
+     * @param alarmDefine :报警定义
+     * @param dataTime    :IOT采集时间
      * @param endResult   :报警恢复监测结果
      * @param paramMap    报警恢复触发值
      * @description:当前数据正常判断逻辑
@@ -182,92 +183,112 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      * @version: V1.0
      */
     private void handlerNowDataNormal(
-            AlarmDefine alarmDefine, String dateTime,
+            AlarmDefine alarmDefine, String dataTime,
             Boolean endResult, HashMap<String, Object> paramMap) throws InterruptedException {
         String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
-        AlarmDefineState alarmState = getAlarmStateFromCacheOrDb(defineId);
+        AlarmDefineState alarmDefineState = getAlarmDefineStateFromCacheOrDb(defineId);
+
         Condition condition = alarmDefine.getCondition();
         //当前数据正常，报警状态为正常：清空之前的报警计时，重置回默认状态
-        if (AlarmDefineState.State.NORMAL.getType().equals(alarmState.getState())) {
-            alarmState = new AlarmDefineState(defineId);
-            alarmInfoCache.setAlarmState(defineId, alarmState);
-        } else if (AlarmDefineState.State.NOT_DEAL.getType().equals(alarmState.getState())) {
-            //            //报警状态异常时候
-            //            alarmState.setLatestDataNormalstate(true);
-            //报警恢复条件满足，判断是否满足报警恢复持续时间
-            if (endResult) {
-                String endTime = alarmState.getAlarmEndTime();
-                if (StringUtil.isEmpty(endTime)) {
-                    endTime = dateTime;
-                }
-                alarmState.setAlarmEndTime(endTime);
+        if (AlarmDefineState.State.NORMAL.getType().equals(alarmDefineState.getState())) {
+            alarmDefineState = new AlarmDefineState(defineId);
+        } else if (AlarmDefineState.State.NOT_DEAL.getType().equals(alarmDefineState.getState())) {
+            // 报警恢复条件不满足，不处理
+            if (!endResult) {
+                return;
+            }
+            /* 判断是否满足报警恢复持续时间 */
+            String alarmSuspendStartTime = alarmDefineState.getAlarmSuspendStartTime();
+            if (StringUtil.isEmpty(alarmSuspendStartTime)) {
+                alarmSuspendStartTime = dataTime;
                 //设置开始恢复时间
-                int uphold = condition.getEndUphold();
-                //超过报警恢复设置的持续时间
-                if (DateUtils.betweenTwoTimeSecond(endTime, dateTime) >= uphold) {
-                    log.info("defineId: [{}]", defineId);
-                    log.error("产生一条报警恢复消息[{}]>[{}]", DateUtils.betweenTwoTimeSecond(endTime, dateTime), uphold);
-                    NettyMessage<AlarmRecord> nettyMessage = new NettyMessage<>(6, alarmDefine.getProjectId());
-                    ZktAlarmRecordDO alarmRecordDO = alarmRecordRepository.findById(AlarmInfoCache.getAlarmDefineId(alarmDefine)).orElse(new ZktAlarmRecordDO());
-                    alarmRecordDO.setDefinitionId(defineId);
-                    alarmRecordDO.setObjId(alarmDefine.getObjId());
-                    alarmRecordDO.setItemCode(alarmDefine.getItemCode());
-                    alarmRecordDO.setState("2");
-                    alarmRecordDO.setEndTime(DateUtils.parseDate(dateTime));
-                    alarmRecordDO.setEndInfo(JSONObject.toJSONString(paramMap));
-                    alarmRecordDO.setProjectId(alarmDefine.getProjectId());
-                    //更新报警状态
-                    alarmRecordRepository.save(alarmRecordDO);
-                    String alarmId = alarmRecordDO.getAlarmId();
-                    //报警恢复参数
-                    AlarmRecord alarmResumeRecord = AlarmRecord.builder()
-                            .state(2)
-                            .groupCode(groupCode)
-                            .projectId(alarmDefine.getProjectId())
-                            .endTime(DateUtils.parseDate(dateTime))
-                            .endInfo(JSONObject.toJSONString(paramMap))
-                            .build();
-                    //如果有报警ID,直接报警恢复
-                    if (StringUtils.isNotEmpty(alarmId)) {
-                        alarmResumeRecord.setId(alarmId);
-                        nettyMessage.setContent(Arrays.asList(alarmResumeRecord));
-                        //{"id","123", "state":1, "groupCode":"wd", "projectId":"Pj123","endTime":"","endInfo":""}
-                        groupNettyClient.sendMessage(nettyMessage.toString());
-                    } else {
-                        //如果没有报警ID,定时任务再次测试
-                        JobDataMap jobDataMap = new JobDataMap();
-                        jobDataMap.put("alarmRecord", alarmRecordDO.toString());
-                        jobDataMap.put("refire", "0");
-                        jobDataMap.put("endTime", dateTime);
-                        jobDataMap.put("endInfo", JSONObject.toJSONString(paramMap));
-                        jobDataMap.put("defineId", defineId);
-                        //恢复
-                        jobDataMap.put("state", "2");
-                        log.info(JSONObject.toJSONString(jobDataMap));
-                        String jobName = defineId;
-                        ExpireAlarmMessage em = new ExpireAlarmMessage();
-                        //过期消息
-                        em.setType("1");
-                        em.setStartTime(DateUtil.offsetMinute(new Date(), 3).toJdkDate());
-                        em.setJobDataMap(jobDataMap);
-                        em.setJobName(jobName);
-                        em.setJobGroupName("resume");
-                        ExpireAlarmQueue.getExpireAlarmMessageQueue().produce(em);
-                    }
+                alarmDefineState.setAlarmSuspendStartTime(alarmSuspendStartTime);
+            }
+            // 报警恢复持续时间
+            long alarmSuspendLastTime = DateUtils.betweenTwoTimeSecond(alarmSuspendStartTime, dataTime);
+            // 设定的报警恢复持续时间
+            int uphold = condition.getEndUphold();
+            if (alarmSuspendLastTime < uphold) {
+                return;
+            }
 
-                    String jobName = AlarmInfoCache.getAlarmDefineId(alarmDefine);
-                    ExpireAlarmMessage em = new ExpireAlarmMessage();
-                    //取消过期消息
-                    em.setType("2");
-                    em.setJobName(jobName);
-                    em.setJobGroupName("expire");
-                    ExpireAlarmQueue.getExpireAlarmMessageQueue().produce(em);
-                    //报警恢复，报警状态重置回默认
-                    alarmState.reset();
-                }
+            /* 超过报警恢复设置的持续时间 */
+            // 边缘端记录报警恢复消息
+            ZktAlarmRecordDO alarmRecordDO = upsertZktAlarmRecordWhenAlarmSuspend(alarmDefine, dataTime, paramMap);
+
+            String alarmId = alarmRecordDO.getAlarmId();
+            //报警恢复参数
+            AlarmRecord alarmResumeRecord = AlarmRecord.builder()
+                    .state(2)
+                    .groupCode(groupCode)
+                    .projectId(alarmDefine.getProjectId())
+                    .endTime(DateUtils.parseDate(dataTime))
+                    .endInfo(JSONObject.toJSONString(paramMap))
+                    .build();
+            log.info("报警恢复持续时间大于设定时间：[{}]>[{}]", alarmSuspendLastTime, uphold);
+            //如果有报警ID,直接报警恢复
+            if (StringUtils.isNotEmpty(alarmId)) {
+                alarmResumeRecord.setId(alarmId);
+                NettyMessage<AlarmRecord> nettyMessage = new NettyMessage<>(6, alarmDefine.getProjectId());
+                nettyMessage.setContent(Collections.singletonList(alarmResumeRecord));
+                //{"id","123", "state":1, "groupCode":"wd", "projectId":"Pj123","alarmSuspendStartTime":"","endInfo":""}
+                groupNettyClient.sendMessage(nettyMessage.toString());
+                log.error("产生一条报警恢复消息: [{}]", nettyMessage.toString());
+            } else {
+                log.info("未获取到报警记录id, 3分钟后重试发送报警恢复消息");
+                //如果没有报警ID,定时任务再次测试
+                JobDataMap jobDataMap = new JobDataMap();
+                jobDataMap.put("alarmRecord", alarmRecordDO.toString());
+                jobDataMap.put("refire", "0");
+                jobDataMap.put("alarmSuspendStartTime", dataTime);
+                jobDataMap.put("endInfo", JSONObject.toJSONString(paramMap));
+                jobDataMap.put("defineId", defineId);
+                //恢复
+                jobDataMap.put("state", "2");
+                log.info(JSONObject.toJSONString(jobDataMap));
+                String jobName = defineId;
+                ExpireAlarmMessage em = new ExpireAlarmMessage();
+                //过期消息
+                em.setType("1");
+                em.setStartTime(DateUtil.offsetMinute(new Date(), 3).toJdkDate());
+                em.setJobDataMap(jobDataMap);
+                em.setJobName(jobName);
+                em.setJobGroupName("resume");
+                ExpireAlarmQueue.getExpireAlarmMessageQueue().produce(em);
             }
-            alarmInfoCache.setAlarmState(defineId, alarmState);
+
+            String jobName = AlarmInfoCache.getAlarmDefineId(alarmDefine);
+            ExpireAlarmMessage em = new ExpireAlarmMessage();
+            //取消过期消息
+            em.setType("2");
+            em.setJobName(jobName);
+            em.setJobGroupName("expire");
+            ExpireAlarmQueue.getExpireAlarmMessageQueue().produce(em);
+            //报警恢复，报警状态重置回默认
+            alarmDefineState.reset();
         }
+        alarmInfoCache.setAlarmState(defineId, alarmDefineState);
+    }
+
+    /**
+     * @description: 当报警恢复时边缘端保存/更新报警信息
+     * @param: alarmDefine
+     * @param: dataTime
+     * @param: paramMap
+     * @return: com.persagy.entity.ZktAlarmRecordDO
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/13 下午5:11
+     * @version: V1.0
+     */
+    private ZktAlarmRecordDO upsertZktAlarmRecordWhenAlarmSuspend(AlarmDefine alarmDefine, String dataTime, HashMap<String, Object> paramMap) {
+        ZktAlarmRecordDO alarmRecordDO = initZktAlarmRecordDO(alarmDefine);
+        alarmRecordDO.setState("2");
+        alarmRecordDO.setEndTime(DateUtils.parseDate(dataTime));
+        alarmRecordDO.setEndInfo(JSONObject.toJSONString(paramMap));
+        alarmRecordRepository.save(alarmRecordDO);
+        return alarmRecordDO;
     }
 
     /**
@@ -297,7 +318,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
 
     /**
      * @param alarmDefine 报警定义
-     * @param dateTime    :IOT数据采集时间
+     * @param dataTime    :IOT数据采集时间
      * @param paramMap    报警触发值
      * @description:处理当前值报警的情况
      * @exception:
@@ -308,25 +329,26 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      * @version: V1.0
      */
     private void handlerNowDataAlarm(
-            AlarmDefine alarmDefine, String dateTime,
+            AlarmDefine alarmDefine, String dataTime,
             HashMap<String, Object> paramMap) throws InterruptedException {
         // 根据defineId获取报警定义状态
         String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
-        AlarmDefineState alarmDefineState = getAlarmStateFromCacheOrDb(defineId);
+        AlarmDefineState alarmDefineState = getAlarmDefineStateFromCacheOrDb(defineId);
 
         Condition condition = alarmDefine.getCondition();
         // 判断报警是否在有效期内
-        boolean inEffectTime = ConditionUtil.inEffectiveTime(condition, dateTime);
+        boolean inEffectTime = ConditionUtil.inEffectiveTime(condition, dataTime);
 
         if (inEffectTime) {
-            // 之前是报警状态，现在还是报警（可能并未产生报警记录，只是连续触发了报警条件）
+            // 已经产生报警
             if (AlarmDefineState.State.NOT_DEAL.getType().equals(alarmDefineState.getState())) {
                 // 获取报警持续时间
                 String alarmStartTime = alarmDefineState.getAlarmStartTime();
-                long lastTime = DateUtils.betweenTwoTimeSecond(alarmStartTime, dateTime);
+                long lastTime = DateUtils.betweenTwoTimeSecond(alarmStartTime, dataTime);
                 String alarmId = alarmRecordRepository.findById(defineId).orElse(new ZktAlarmRecordDO()).getAlarmId();
                 // 如果已经产生了报警记录
                 if (StringUtils.isNotBlank(alarmId)) {
+                    log.info("报警已经产生，向云端推送报警持续消息");
                     // 发送报警仍在继续的消息
                     sendAlarmContinueMessage(alarmId, lastTime, paramMap, alarmDefine.getProjectId());
                 }
@@ -336,23 +358,23 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                 // 报警持续时间
                 long alarmLastTime = 0;
                 if (StringUtil.isNotEmpty(alarmDefineState.getAlarmStartTime())) {
-                    alarmLastTime = DateUtils.betweenTwoTimeSecond(alarmDefineState.getAlarmStartTime(), dateTime);
+                    alarmLastTime = DateUtils.betweenTwoTimeSecond(alarmDefineState.getAlarmStartTime(), dataTime);
                 } else {
                     //设置开始报警时间
-                    alarmDefineState.setAlarmStartTime(dateTime);
+                    alarmDefineState.setAlarmStartTime(dataTime);
                 }
 
                 // 获取报警过期时间
-                LocalDateTime expireDateTime = getExpireLocalDateTime(dateTime, condition);
-
+                LocalDateTime expireDateTime = getExpireLocalDateTime(dataTime, condition);
+                log.info("报警持续时间：[{}]", alarmLastTime);
+                log.info("设定的持续时间：[{}]", condition.getTriggerUphold());
                 if (alarmLastTime >= condition.getTriggerUphold()) {
-                    log.info("defineId: [{}]", defineId);
-                    log.info("大于持续时间了，产生一条报警[{}]>[{}]", alarmLastTime, condition.getTriggerUphold());
+                    log.info("报警持续时间大于设定的持续时间，产生一条报警");
                     // 发送创建报警记录的消息
-                    sendCreateAlarmRecordMessage(alarmDefine, dateTime, paramMap,
+                    sendCreateAlarmRecordMessage(alarmDefine, dataTime, paramMap,
                             DateUtils.localDateTime2Date(expireDateTime));
                     // 边缘端保存报警信息
-                    saveZktAlarmRecord(alarmDefine);
+                    upsertZktAlarmRecordWhenAlarmStart(alarmDefine);
                     // 报警定义状态更新为未处理
                     alarmDefineState.setState(AlarmDefineState.State.NOT_DEAL.getType());
                     //有过期时间，生成报警过期消息
@@ -366,8 +388,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
             }
         } else {
             // 其他条件全部改成默认值（不报警，不过期，报警开始时间和结束时间为空）
-            log.info("defineId: [{}]", defineId);
-            log.info("[{}]不在生效时间，重置报警状态", dateTime);
+            log.info("[{}]不在生效时间，重置报警状态", dataTime);
             log.info("生效时间为：[{}]", condition.getEffectTime());
             alarmDefineState.reset();
         }
@@ -392,7 +413,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
         if (!expireSetEffective) {
             return null;
         }
-        
+
         //过期时间
         String expireTime = ConditionUtil.getEffectEndTime(condition);
         LocalTime localTime = LocalTime.parse(expireTime, DateTimeFormatter.ofPattern(DateUtils.sdfTimeNotDate));
@@ -401,6 +422,18 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
         return LocalDateTime.of(triggerDate, localTime);
     }
 
+    /**
+     * @description: 创建过期任务
+     * @param: alarmDefine 报警定义
+     * @param: alarmDefineState 报警定义状态对象
+     * @param: expireDateTime 过期时间
+     * @return: void
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/13 下午3:39
+     * @version: V1.0
+     */
     private void createExpireJob(AlarmDefine alarmDefine, AlarmDefineState alarmDefineState, LocalDateTime expireDateTime) throws InterruptedException {
         String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
         String alarmId = alarmRecordRepository.findById(defineId).orElse(new ZktAlarmRecordDO()).getAlarmId();
@@ -433,26 +466,43 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
     }
 
     /**
-     * @description: 边缘端保存报警信息
+     * @description: 当报警开始时边缘端保存/更新报警信息
      * @param: alarmDefine 报警定义
-     * @return: void
+     * @return: com.persagy.entity.ZktAlarmRecordDO
      * @exception:
      * @author: lixing
      * @company: Persagy Technology Co.,Ltd
      * @since: 2021/1/8 下午5:55
      * @version: V1.0
      */
-    private void saveZktAlarmRecord(AlarmDefine alarmDefine) {
+    private ZktAlarmRecordDO upsertZktAlarmRecordWhenAlarmStart(AlarmDefine alarmDefine) {
+        ZktAlarmRecordDO zktAlarmRecordDO = initZktAlarmRecordDO(alarmDefine);
+        zktAlarmRecordDO.setState("1");
+        alarmRecordRepository.save(zktAlarmRecordDO);
+        return zktAlarmRecordDO;
+    }
+
+    /**
+     * @description: 初始化边缘端报警记录对象
+     * @param: alarmDefine
+     * @return: com.persagy.entity.ZktAlarmRecordDO
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/13 下午5:07
+     * @version: V1.0
+     */
+    private ZktAlarmRecordDO initZktAlarmRecordDO(AlarmDefine alarmDefine) {
         String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
         ZktAlarmRecordDO zktAlarmRecordDO = alarmRecordRepository.findById(defineId).orElse(new ZktAlarmRecordDO());
         zktAlarmRecordDO.setDefinitionId(defineId);
         zktAlarmRecordDO.setObjId(alarmDefine.getObjId());
         zktAlarmRecordDO.setItemCode(alarmDefine.getItemCode());
-        zktAlarmRecordDO.setState("1");
         zktAlarmRecordDO.setProjectId(alarmDefine.getProjectId());
-        alarmRecordRepository.save(zktAlarmRecordDO);
+        return zktAlarmRecordDO;
     }
 
+
     /**
      * @description: 发送创建报警记录消息
      * @param: alarmDefine 报警定义