修改重复产生报警的bug

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

@@ -2,14 +2,12 @@ package com.persagy.cache;
 
 
 import cn.hutool.core.collection.CollectionUtil;
-import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.googlecode.aviator.AviatorEvaluator;
 import com.googlecode.aviator.Expression;
 import com.persagy.entity.AlarmDefine;
 import com.persagy.entity.AlarmState;
 import com.persagy.entity.Condition;
-import com.persagy.utils.StringUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
@@ -42,18 +40,18 @@ public class AlarmInfoCache {
     private ConcurrentHashMap<String, List<AlarmDefine>> infoAlarmMap = new ConcurrentHashMap<>();
 
 
-
     /**
      * 报警定义  <报警定义标识，报警时间状态>
      * 报警定义标识默认为：报警编码-报警对象id
      */
     private ConcurrentHashMap<String, AlarmState> alarmStateMap = new ConcurrentHashMap<>();
+
     /**
-     * @description:获取报警状态  <报警定义标识，报警时间状态>
+     * @param :
+     * @description:获取报警状态 <报警定义标识，报警时间状态>
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param :
      * @return: null
      * @since: 2020/10/20 17:12
      * @version: V1.0
@@ -61,43 +59,52 @@ public class AlarmInfoCache {
     public AlarmState getAlarmState(String definitionId) {
         return alarmStateMap.get(definitionId);
     }
+
     /**
+     * @param definitionId: 报警定义id
+     * @param alarmState:   报警状态时间类
      * @description:设置报警定义
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param definitionId: 报警定义id
-     * @param alarmState: 报警状态时间类
      * @return: com.persagy.entity.AlarmState
      * @since: 2020/10/20 17:15
      * @version: V1.0
      */
-    public AlarmState setAlarmState(String definitionId,AlarmState alarmState) {
-        return alarmStateMap.put(definitionId,alarmState);
+    public AlarmState setAlarmState(String definitionId, AlarmState alarmState) {
+        return alarmStateMap.put(definitionId, alarmState);
     }
+
     /**
      * 获取报警定义Map <报警定义标识，报警定义详情>
+     *
      * @return
      */
     public ConcurrentHashMap<String, AlarmDefine> getAlarmDefineMap() {
         return alarmDefineMap;
     }
+
     /**
      * 设置报警定义Map <报警定义标识，报警定义详情>
+     *
      * @return
      */
     public void setAlarmDefineMap(ConcurrentHashMap<String, AlarmDefine> alarmDefineMap) {
         this.alarmDefineMap = alarmDefineMap;
     }
+
     /**
      * 获取信息点-报警定义map <表号-功能号，[报警定义1,报警定义2]>
+     *
      * @return
      */
     public ConcurrentHashMap<String, List<AlarmDefine>> getInfoAlarmMap() {
         return infoAlarmMap;
     }
+
     /**
      * 设置信息点-报警定义map <表号-功能号，[报警定义1,报警定义2]>
+     *
      * @return
      */
     public void setInfoAlarmMap(ConcurrentHashMap<String, List<AlarmDefine>> infoAlarmMap) {
@@ -105,11 +112,11 @@ public class AlarmInfoCache {
     }
 
     /**
+     * @param definitionId :
      * @description:根据报警定义id获取报警定义详情
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param definitionId :
      * @return: AlarmDefine 报警定义详情
      * @since: 2020/10/19 14:32
      * @version: V1.0
@@ -120,80 +127,80 @@ public class AlarmInfoCache {
 
 
     /**
+     * @param definitionId:报警定义ID
+     * @param alarmDefine:报警定义详情
      * @description:保存报警定义详情
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param definitionId:报警定义ID
-     * @param alarmDefine:报警定义详情
      * @return: void
      * @since: 2020/10/19 14:32
      * @version: V1.0
      */
     public void putAlarmDefinitionById(String definitionId, AlarmDefine alarmDefine) {
-        if("0".equals(alarmDefine.getOpen())){
+        if (alarmDefine.getOpen() == 0) {
             return;
         }
         Condition condition = alarmDefine.getCondition();
         List<JSONObject> infoCodes = condition.getInfoCodes();
-        if(CollectionUtil.isEmpty(infoCodes)) {
-            log.error("报警定义ID为[{}],报警定义详情为[{}] 的报警定义信息点为空,请检查!!!!!  ",definitionId,alarmDefine.toString());
+        if (CollectionUtil.isEmpty(infoCodes)) {
+            log.error("报警定义ID为[{}],报警定义详情为[{}] 的报警定义信息点为空,请检查!!!!!  ", definitionId, alarmDefine.toString());
             return;
         }
         String trigger = condition.getTrigger();
         String end = condition.getEnd();
         try {
-            Expression triggerCompiledExp = AviatorEvaluator.compile(trigger,true);
+            Expression triggerCompiledExp = AviatorEvaluator.compile(trigger, true);
         } catch (Exception e) {
-            log.info("触发表达式：",trigger);
-            log.error("触发表表达式不合法，请校验",e);
-            throw  new IllegalArgumentException("触发表表达式不合法",e);
+            log.info("触发表达式：", trigger);
+            log.error("触发表表达式不合法，请校验", e);
+            throw new IllegalArgumentException("触发表表达式不合法", e);
         }
         try {
-            Expression endCompiledExp = AviatorEvaluator.compile(end,true);
+            Expression endCompiledExp = AviatorEvaluator.compile(end, true);
         } catch (Exception e) {
-            log.error("恢复表达式：",end);
-            log.error("恢复表达式不合法，请校验",e);
-            throw  new IllegalArgumentException("恢复表达式不合法",e);
+            log.error("恢复表达式：", end);
+            log.error("恢复表达式不合法，请校验", e);
+            throw new IllegalArgumentException("恢复表达式不合法", e);
         }
         alarmDefineMap.put(definitionId, alarmDefine);
         for (int i = 0; i < infoCodes.size(); i++) {
             JSONObject infoCode = infoCodes.get(i);
             String meterId = infoCode.getString("meterId");
             String funcId = infoCode.getString("funcId");
-            putAlarmDefinitionIdByMeterFuncId(meterId,funcId,alarmDefine);
+            putAlarmDefinitionIdByMeterFuncId(meterId, funcId, alarmDefine);
         }
     }
+
     public void putAlarmDefinitionById(AlarmDefine alarmDefine) {
-        putAlarmDefinitionById(getAlarmDefineId(alarmDefine),alarmDefine);
+        putAlarmDefinitionById(getAlarmDefineId(alarmDefine), alarmDefine);
     }
 
 
-
     /**
+     * @param meterId: 表号
+     * @param funcId:  功能号
      * @description:根据表号功能号获取多条报警定义id
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param meterId: 表号
-     * @param funcId: 功能号
      * @return: java.util.List<com.alibaba.fastjson.JSONObject>
      * @since: 2020/10/19 14:31
      * @version: V1.0
      */
     public List<AlarmDefine> getAlarmDefinitionIdByMeterFuncId(String meterId, String funcId) {
-        return infoAlarmMap.get(getKey(meterId,funcId));
+        return infoAlarmMap.get(getKey(meterId, funcId));
     }
 
 
     /**
+     * @param meterId:    表号
+     * @param funcId:     功能号
+     * @param definition: 报警定义
      * @description:根据表号功能号缓存报警定义
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param meterId: 表号
-     * @param funcId: 功能号
-     * @param definition: 报警定义
      * @return: void
      * @since: 2020/10/19 14:26
      * @version: V1.0
@@ -204,9 +211,9 @@ public class AlarmInfoCache {
             definitionList = new ArrayList<>();
         }
         //去重并添加
-        definitionList = definitionList.stream().filter(a->!getAlarmDefineId(definition).equals(getAlarmDefineId(a))).collect(Collectors.toList());
+        definitionList = definitionList.stream().filter(a -> !getAlarmDefineId(definition).equals(getAlarmDefineId(a))).collect(Collectors.toList());
         definitionList.add(definition);
-        infoAlarmMap.put(getKey(meterId,funcId), definitionList);
+        infoAlarmMap.put(getKey(meterId, funcId), definitionList);
     }
 
 
@@ -225,12 +232,13 @@ public class AlarmInfoCache {
         //清除编译表达式缓存
         AviatorEvaluator.getInstance().clearExpressionCache();
     }
+
     /**
+     * @param ad: 要删除掉的报警定义
      * @description:根据报警定义删除缓存
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param ad:  要删除掉的报警定义
      * @return: void
      * @since: 2020/10/26 20:34
      * @version: V1.0
@@ -238,53 +246,59 @@ public class AlarmInfoCache {
     public void clearAlarmDefine(AlarmDefine ad) {
         String defineId = getAlarmDefineId(ad);
         AlarmDefine alarmDefine = alarmDefineMap.get(defineId);
-        if(!Objects.isNull(alarmDefine)) {
+        if (!Objects.isNull(alarmDefine)) {
             List<JSONObject> infoCodes = alarmDefine.getCondition().getInfoCodes();
-            infoCodes.stream().forEach(info->{
+            // 删除map中报警定义相关信息点与要删除的报警定义的映射
+            infoCodes.stream().forEach(info -> {
                 String meterId = info.getString("meterId");
                 String funcId = info.getString("funcId");
-                List<AlarmDefine> AlarmDefineList = infoAlarmMap.getOrDefault(getKey(meterId, funcId),new ArrayList<>());
-                infoAlarmMap.put(getKey(meterId, funcId), AlarmDefineList.stream().filter(adTmp -> !getAlarmDefineId(adTmp).equals(defineId)).collect(Collectors.toList()));
+                List<AlarmDefine> AlarmDefineList = infoAlarmMap.getOrDefault(getKey(meterId, funcId), new ArrayList<>());
+                // 过滤掉要删除的报警定义
+                infoAlarmMap.put(getKey(meterId, funcId),
+                        AlarmDefineList.stream().filter(
+                                adTmp -> !getAlarmDefineId(adTmp).equals(defineId)
+                        ).collect(Collectors.toList()));
             });
         }
         alarmDefineMap.remove(defineId);
     }
+
     /**
-     * @description:获取报警定义id,
-     * 中台报警定义ID没有实际意义，根据itemCode-objId拼接作为唯一标识
+     * @param alarmDefine:
+     * @description:获取报警定义id, 中台报警定义ID没有实际意义，根据itemCode-objId拼接作为唯一标识
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param alarmDefine:
      * @since: 2020/10/19 17:28
      * @version: V1.0
      */
     public static String getAlarmDefineId(AlarmDefine alarmDefine) {
-        return alarmDefine.getItemCode()+"-"+alarmDefine.getObjId();
+        return alarmDefine.getItemCode() + "-" + alarmDefine.getObjId();
     }
 
     /**
+     * @param meterId:表号
+     * @param funcId:功能号
      * @description:判断是否包含有改表号功能号的改报警定义
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
-     * @param meterId:表号
-     * @param funcId:功能号
      * @return: boolean
      * @since: 2020/10/19 19:54
      * @version: V1.0
      */
-    public boolean hasKey(String meterId,String funcId) {
-        return infoAlarmMap.containsKey(getKey(meterId,funcId));
+    public boolean hasKey(String meterId, String funcId) {
+        return infoAlarmMap.containsKey(getKey(meterId, funcId));
     }
 
     /**
      * 拼接表号-功能号为一个key
+     *
      * @param meterId
      * @param funcId
      * @return
      */
-    private String getKey(String meterId,String funcId) {
+    private String getKey(String meterId, String funcId) {
         return meterId + "-" + funcId;
     }
 

src/main/java/com/persagy/entity/util/ConditionUtil.java

@@ -0,0 +1,235 @@
+package com.persagy.entity.util;
+
+import com.alibaba.fastjson.JSONObject;
+import com.persagy.entity.Condition;
+import com.persagy.utils.DateUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @description: 报警定义util类
+ * @author: lixing
+ * @company: Persagy Technology Co.,Ltd
+ * @since: 2021/1/8 上午11:21
+ * @version: V1.0
+ **/
+public class ConditionUtil {
+
+    /**
+     * 生效类型：always
+     */
+    public static final String EFFECT_TYPE_ALWAYS = "always";
+
+    /**
+     * 生效类型：period
+     */
+    public static final String EFFECT_TYPE_PERIOD = "period";
+
+    /**
+     * @description: 获取有效期类型
+     * @param: condition
+     * @return: java.lang.String
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午3:38
+     * @version: V1.0
+     */
+    public static String getEffectType(Condition condition) {
+        if (condition == null) {
+            return null;
+        }
+        JSONObject effectTime = condition.getEffectTime();
+        if (effectTime == null) {
+            return null;
+        }
+
+        return effectTime.getString("type");
+    }
+
+    /**
+     * @description: 获取有效期开始时间
+     * @param: condition
+     * @return: java.lang.String
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午3:44
+     * @version: V1.0
+     */
+    public static String getEffectStartTime(Condition condition) {
+        if (condition == null) {
+            return null;
+        }
+        JSONObject effectTime = condition.getEffectTime();
+        if (effectTime == null) {
+            return null;
+        }
+
+        String type = effectTime.getString("type");
+        if (EFFECT_TYPE_PERIOD.equals(type)) {
+            JSONObject period = effectTime.getJSONObject("period");
+            if (period == null) {
+                return null;
+            }
+            return period.getString("startTime");
+        }
+
+        return null;
+    }
+
+    /**
+     * @description: 获取有效期结束时间
+     * @param: condition
+     * @return: java.lang.String
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午3:44
+     * @version: V1.0
+     */
+    public static String getEffectEndTime(Condition condition) {
+        if (condition == null) {
+            return null;
+        }
+        JSONObject effectTime = condition.getEffectTime();
+        if (effectTime == null) {
+            return null;
+        }
+
+        String type = effectTime.getString("type");
+        if (EFFECT_TYPE_PERIOD.equals(type)) {
+            JSONObject period = effectTime.getJSONObject("period");
+            if (period == null) {
+                return null;
+            }
+            return period.getString("endTime");
+        }
+
+        return null;
+    }
+
+    /**
+     * @description: 判断报警条件中的过期设置是否生效
+     * @param: condition
+     * @return: boolean
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午2:32
+     * @version: V1.0
+     */
+    public static boolean expireSetEffective(Condition condition) {
+        if (condition == null) {
+            return false;
+        }
+
+        JSONObject effectTime = condition.getEffectTime();
+        if (effectTime == null) {
+            return false;
+        }
+
+        String type = effectTime.getString("type");
+        if (StringUtils.isBlank(type)) {
+            return false;
+        }
+        // 只有type=period，且设置的生效时间在"000000" -> "235959"之间，过期设置才有效
+        if (EFFECT_TYPE_PERIOD.equals(type)) {
+            String startTime = getEffectStartTime(condition);
+            String endTime = getEffectEndTime(condition);
+            // 时间不合法，认为过期设置不生效
+            if (!validateTime(startTime) || !validateTime(endTime)) {
+                return false;
+            }
+
+            // 一天的开始和结束时间
+            String dayStartTime = "000000";
+            String dayEndTime = "235959";
+            // 设置的生效时间为"000000" -> "235959"，过期设置不生效
+            if (dayStartTime.equals(startTime) && dayEndTime.equals(endTime)) {
+                return false;
+            }
+
+            // 前面的校验都通过，并且开始时间<结束时间，过期设置才有效
+            return startTime.compareTo(endTime) < 0;
+        }
+
+        return false;
+    }
+
+    /**
+     * @description: 校验时间是否合法（是否为6位数字）
+     * @param: time
+     * @return: boolean
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午3:13
+     * @version: V1.0
+     */
+    private static boolean validateTime(String time) {
+        if (StringUtils.isBlank(time)) {
+            return false;
+        }
+        String regex = "^\\d{6}$";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(time);
+        return matcher.matches();
+    }
+
+    /**
+     * @description: 判断时间是否在有效期内
+     * @param: condition
+     * @param: datetime
+     * @return: boolean
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/1/8 下午3:31
+     * @version: V1.0
+     */
+    public static boolean inEffectiveTime(Condition condition, String datetime) {
+        if (StringUtils.isBlank(datetime)) {
+            return false;
+        }
+        String time = DateUtils.getSdfTimeNotDate(datetime);
+        // 如果时间格式有问题，认为不在有效期内
+        if (!validateTime(time)) {
+            return false;
+        }
+
+        String effectType = getEffectType(condition);
+        // 如果有效期类型为always, 一定在有效期内
+        if (EFFECT_TYPE_ALWAYS.equals(effectType)) {
+            return true;
+        }
+
+        if (EFFECT_TYPE_PERIOD.equals(effectType)) {
+            String effectStartTime = getEffectStartTime(condition);
+            String effectEndTime = getEffectEndTime(condition);
+            // 如果报警条件中的有效期开始时间或者结束时间格式有问题，认为不在有效期
+            if (!validateTime(effectStartTime) || !validateTime(effectEndTime)) {
+                return false;
+            }
+            return effectStartTime.compareTo(time) <= 0 && effectEndTime.compareTo(time) >= 0;
+        }
+
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Condition condition = new Condition();
+        JSONObject effectTime = new JSONObject();
+//        JSONObject period = new JSONObject();
+//        period.put("startTime", "000000");
+//        period.put("endTime", "115958");
+////        effectTime.put("type", EFFECT_TYPE_PERIOD);
+//        effectTime.put("type", EFFECT_TYPE_ALWAYS);
+//        effectTime.put(EFFECT_TYPE_PERIOD, period);
+        condition.setEffectTime(effectTime);
+        boolean b = inEffectiveTime(condition, "20210108115959");
+        System.out.println(b);
+    }
+}

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

@@ -9,6 +9,7 @@ import com.persagy.cache.AlarmInfoCache;
 import com.persagy.cache.CurrentDataCache;
 import com.persagy.client.GroupNettyClient;
 import com.persagy.entity.*;
+import com.persagy.entity.util.ConditionUtil;
 import com.persagy.job.ExpireAlarmQueue;
 import com.persagy.repository.AlarmRecordRepository;
 import com.persagy.service.AlarmHandleService;
@@ -109,11 +110,9 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                         if (triggerResult && endResult) {
                             log.warn("报警触发条件和报警恢复条件同时满足，请检查，报警定义详情【{}】", alarmDefine.toString());
                         }
+                        // 使用intern（）方法，确保上锁的是同一个String对象
                         synchronized (defineId.intern()) {
-                            AlarmState alarmState = alarmInfoCache.getAlarmState(defineId);
-                            if (Objects.isNull(alarmState)) {
-                                alarmState = new AlarmState(defineId);
-                            }
+                            AlarmState alarmState = getAlarmStateFromCacheOrDb(defineId);
                             //报警产生值满足（这里的满足不考虑报警持续时间）
                             if (triggerResult) {
                                 log.info("有一条满足报警条件");
@@ -139,6 +138,34 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
     }
 
     /**
+     * @description: 根据报警定义唯一标识从缓存或数据库中获取alarmState
+     * @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 AlarmState getAlarmStateFromCacheOrDb(String defineId) {
+        AlarmState alarmState = alarmInfoCache.getAlarmState(defineId);
+        if (Objects.isNull(alarmState)) {
+            //默认正常报警状态
+            alarmState = new AlarmState(defineId);
+            Optional<ZktAlarmRecordDO> recordOptional = alarmRecordRepository.findById(defineId);
+            if (recordOptional.isPresent()) {
+                ZktAlarmRecordDO alarmRecordDO = recordOptional.get();
+                //数据库报警状态：1-未处理
+                if ("1".equals(alarmRecordDO.getState())) {
+                    alarmState.setState(AlarmState.State.NOT_DEAL.getType());
+                    alarmState.setAlarmStartTime(alarmRecordDO.getAlarmTime());
+                }
+            }
+        }
+        return alarmState;
+    }
+
+    /**
      * @param alarmDefine :       报警定义
      * @param dateTime    :IOT采集时间
      * @param condition   :报警条件
@@ -277,36 +304,13 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      */
     private void handlerNowDataAlarm(AlarmDefine alarmDefine, AlarmState alarmState, String dateTime, Condition condition, String defineId, HashMap paramMap) throws SchedulerException, InterruptedException {
         alarmState.setLatestDataNormalstate(false);
-        JSONObject effectTime = condition.getEffectTime();
-        boolean inEffectTime = false;
-        boolean hasExpire = true;
-        //生效时间段，有误过期时间判断
-        if (StringUtil.isEmpty(effectTime) ||
-                StringUtil.isEmpty(effectTime.getString("type")) ||
-                "always".equals(effectTime.getString("type"))
-        ) {
-            //无生效时间设置，则任何时间生效
-            inEffectTime = true;
-            //没有设置生效时间，所以也没有设置过期时间
-            hasExpire = false;
 
-        } else {
-            if ("period".equals(effectTime.getJSONObject("period").getString("type"))
-                    && "000000".equals(effectTime.getJSONObject("period").getString("startTime").substring(0, 6))
-                    && "235959".equals(effectTime.getJSONObject("period").getString("endTime").substring(0, 6))) {
-                //架构师w确认 00:00-23:59的生效时间为一值生效，23:59分不过期
-                hasExpire = false;
-            }
+        JSONObject effectTime = condition.getEffectTime();
+        // 判断报警是否在有效期内
+        boolean inEffectTime = ConditionUtil.inEffectiveTime(condition, dateTime);
+        // 判断过期设置是否生效
+        boolean expireSetEffective = ConditionUtil.expireSetEffective(condition);
 
-            if ("period".equals(effectTime.getString("type"))
-                    && effectTime.getJSONObject("period").getString("startTime").compareTo(DateUtils.getSdfTimeNotDate(dateTime)) <= 0
-                    && effectTime.getJSONObject("period").getString("endTime").compareTo(DateUtils.getSdfTimeNotDate(dateTime)) >= 0) {
-                //在生效时间
-                inEffectTime = true;
-            } else {
-                log.info("[{}]不在设置的生效时间段", dateTime);
-            }
-        }
         if (inEffectTime) {
             // 之前是报警状态，现在还是报警（可能并未产生报警记录，只是连续触发了报警条件）
             if (AlarmState.State.NOT_DEAL.getType().equals(alarmState.getState())) {
@@ -331,7 +335,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                 }
                 LocalDateTime expireDateTime = null;
                 Date expireDate = null;
-                if (hasExpire && "period".equals(effectTime.getString("type"))) {
+                if (expireSetEffective && "period".equals(effectTime.getString("type"))) {
                     //过期时间
                     String expireTime = effectTime.getJSONObject("period").getString("endTime");
                     LocalTime localTime = LocalTime.parse(expireTime, DateTimeFormatter.ofPattern(DateUtils.sdfTimeNotDate));
@@ -371,7 +375,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                     alarmRecordRepository.save(zktAlarmRecordDO);
                     alarmState.setState(AlarmState.State.NOT_DEAL.getType());
                     //有过期时间，生成报警过期消息
-                    if (hasExpire && "period".equals(effectTime.getString("type"))) {
+                    if (expireSetEffective && "period".equals(effectTime.getString("type"))) {
                         //过期时间
                         log.error("产生一条定时过期报警消息");
                         String alarmId = alarmRecordRepository.findById(defineId).orElse(new ZktAlarmRecordDO()).getAlarmId();
@@ -403,13 +407,14 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                         ExpireAlarmQueue.getExpireAlarmMessageQueue().produce(em);
                         //alarmQuartzService.addExpireJob(DateUtils.localDateTime2Date(expireDateTime), jobName, "expire", jobDataMap);
                     }
-                } else {
-                    alarmState.setState(AlarmState.State.NORMAL.getType());
                 }
             }
         } else {
             //不在生效时间的段的产生报警,要保存最近一次的数值是否是是报警
             //其他条件全部改成默认值（不报警，不过期，报警开始时间和结束时间为空）
+            log.info("defineId: [{}]", defineId);
+            log.info("[{}]不在生效时间，重置报警状态", dateTime);
+            log.info("生效时间为：[{}]", effectTime.toJSONString());
             alarmState.reset();
         }
         alarmInfoCache.setAlarmState(defineId, alarmState);