增加对成组的采集值的处理

src/main/java/com/persagy/client/WebSocketClientFactory.java

@@ -122,12 +122,6 @@ public class WebSocketClientFactory {
                             log.warn("等待获取锁....");
                             LockUtil.getInstance().lock.lockInterruptibly();
                             log.warn("已经获取锁....");
-                            //                            try {
-                            //                                LockUtil.getInstance().condition.await();
-                            //                            } catch (InterruptedException e) {
-                            //                                e.printStackTrace();
-                            //                            }
-                            //                            log.warn("等待结束....");
                         } catch (Exception e) {
                             log.error("数据加锁处理发生异常", e);
                         } finally {
@@ -137,7 +131,7 @@ public class WebSocketClientFactory {
                     String finalMessage = message;
                     executor.execute(() -> {
                         try {
-                            alarmHandleService.handleIOTData(finalMessage);
+                            alarmHandleService.handleIotMsg(finalMessage);
                         } catch (Exception e) {
                             log.error("数据处理失败", e);
                         }

src/main/java/com/persagy/controller/HelloWorld.java

@@ -77,7 +77,7 @@ public class HelloWorld {
 	@PostMapping("/test2")
 	public String test2(@RequestBody JSONObject jsonObject) throws Exception {
 		String message = jsonObject.getString("message");
-		alarmHandleService.handleIOTData(message);
+		alarmHandleService.handleIotMsg(message);
 		return "成功";
 	}
 

src/main/java/com/persagy/enumeration/AlarmDefineStateEnum.java

@@ -0,0 +1,30 @@
+package com.persagy.enumeration;
+
+/**
+ * @description: 报警定义状态枚举类
+ * @author: lixing
+ * @company: Persagy Technology Co.,Ltd
+ * @since: 2021/2/2 11:53 上午
+ * @version: V1.0
+ **/
+public enum AlarmDefineStateEnum {
+    NORMAL("1", "正常"),
+    NOT_DEAL("2", "未处理"),
+    EXPIRED("3", "已过期");
+
+    private String value;
+    private String desc;
+
+    AlarmDefineStateEnum(String value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+}

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

@@ -10,6 +10,7 @@ import com.persagy.entity.AlarmDefineState;
 import com.persagy.entity.AlarmRecord;
 import com.persagy.entity.NettyMessage;
 import com.persagy.entity.ZktAlarmRecordDO;
+import com.persagy.enumeration.AlarmDefineStateEnum;
 import com.persagy.repository.AlarmRecordRepository;
 import com.persagy.utils.DateUtils;
 import com.persagy.utils.StringUtil;
@@ -22,6 +23,7 @@ import org.springframework.scheduling.quartz.QuartzJobBean;
 
 import java.util.Collections;
 import java.util.Date;
+import java.util.Optional;
 import java.util.concurrent.atomic.AtomicLong;
 
 import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
@@ -114,7 +116,7 @@ public class AlarmExpireJob extends QuartzJobBean {
     @Override
     protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
         try {
-            String jobType = "2".equals(state) ? "恢复" : "过期";
+            String jobType = AlarmDefineStateEnum.NOT_DEAL.getValue().equals(state) ? "恢复" : "过期";
             JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
             log.info("定时任务开始{}", alarmRecord);
             log.info("定时任务为{}任务", jobType);
@@ -129,7 +131,7 @@ public class AlarmExpireJob extends QuartzJobBean {
 
                 // 立即过期的场景，过期的时候可能还没有报警记录ID,需要延迟重新执行
                 if (!createdAlarmIdsCache.contains(alarmId)) {
-                    log.info("未获取到报警记录id, 定时任务将在5分钟后重新执行");
+                    log.info("已创建的报警id中不包含[{}], 定时任务将在5分钟后重新执行", alarmId);
                     log.info("refire:[{}]", refire);
                     mergedJobDataMap.put("refire", String.valueOf(StringUtil.getInt(refire) + 1));
                     reFireJob(context, mergedJobDataMap);
@@ -146,7 +148,8 @@ public class AlarmExpireJob extends QuartzJobBean {
                         .groupCode(groupCode)
                         .projectId(zktAlarmRecordDO.getProjectId())
                         .build();
-                if ("2".equals(state)) {
+                // 恢复任务发送消息时，带上恢复信息
+                if (AlarmDefineStateEnum.NOT_DEAL.getValue().equals(state)) {
                     message.setEndInfo(endInfo);
                     message.setEndTime(DateUtils.parseDate(endTime));
                 }
@@ -158,17 +161,34 @@ public class AlarmExpireJob extends QuartzJobBean {
                 // 删除缓存中报警id
                 createdAlarmIdsCache.remove(alarmId);
 
-                //已经过期的时候删除掉这条报警定义了，保证不会再次产生报警
-                AlarmDefineState alarmState = new AlarmDefineState(defineId);
-                alarmState.setAlarmStartTime("");
-                alarmInfoCache.setAlarmState(defineId, alarmState);
-                if (alarmRecordRepository.existsById(zktAlarmRecordDO.getDefinitionId())) {
-                    alarmRecordRepository.deleteById(zktAlarmRecordDO.getDefinitionId());
+                String defineId = zktAlarmRecordDO.getDefinitionId();
+                synchronized (defineId.intern()) {
+                    // 判断报警是否仍是创建任务时的报警，如果不是了，任务结束
+                    Optional<ZktAlarmRecordDO> currentRecordOptional = alarmRecordRepository.findById(defineId);
+                    if (!currentRecordOptional.isPresent()) {
+                        log.info("定时任务执行完成");
+                        return;
+                    }
+                    ZktAlarmRecordDO alarmRecordDO = currentRecordOptional.get();
+                    if (!alarmId.equals(alarmRecordDO.getAlarmId())) {
+                        log.info("定时任务执行完成");
+                        return;
+                    }
+
+                    // 过期任务执行时，如果报警仍是创建任务时的报警，重置报警定义的状态
+                    if (AlarmDefineStateEnum.EXPIRED.getValue().equals(state)) {
+                        AlarmDefineState alarmState = new AlarmDefineState(this.defineId);
+                        alarmState.setAlarmStartTime("");
+                        alarmInfoCache.setAlarmState(this.defineId, alarmState);
+                    }
+
+                    // 如果报警仍是创建任务时的报警，数据库中删除这条报警定义
+                    alarmRecordRepository.deleteById(defineId);
                 }
             }
-            log.info("----------------结束---------------------");
+
         } catch (Exception e) {
-            log.error("job hander error", e);
+            log.error("定时任务执行失败", e);
         }
 
     }

src/main/java/com/persagy/service/AlarmHandleService.java

@@ -10,5 +10,5 @@ import org.quartz.SchedulerException;
  * @version:V1.0
  **/
 public interface AlarmHandleService {
-    void handleIOTData(String msg) throws SchedulerException, InterruptedException;
+    void handleIotMsg(String msg) throws SchedulerException, InterruptedException;
 }

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

@@ -17,6 +17,7 @@ import com.persagy.service.AlarmHandleService;
 import com.persagy.service.AlarmQuartzService;
 import com.persagy.utils.DateUtils;
 import com.persagy.utils.StringUtil;
+import com.persagy.utils.ValidateUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.quartz.JobDataMap;
@@ -65,83 +66,229 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
     public String systemId;
 
     /**
-     * @param msg:
-     * @description:处理iot采集数据
+     * @description: 处理iot采集值消息
+     * @param: msg iot采集值消息
+     * @return: void
      * @exception:
-     * @author: LuoGuangyi
+     * @author: lixing
      * @company: Persagy Technology Co.,Ltd
-     * @return: void
-     * @since: 2020/10/27 14:28
+     * @since: 2021/2/1 3:31 下午
      * @version: V1.0
      */
     @Override
-    public void handleIOTData(String msg) throws SchedulerException, InterruptedException {
+    public void handleIotMsg(String msg) throws SchedulerException, InterruptedException {
         log.info("接收到采集值：[{}]", msg);
-        String[] split = msg.split(";");
-        if (split.length % 4 != 0) {
+        // 校验采集值
+        boolean validateIotMsgResult = validateIotMsg(msg);
+        if (!validateIotMsgResult) {
             return;
         }
-        //返回的信息点个数
-        int nums = (split.length) / 4;
-        for (int i = 0; i < nums; i++) {
-            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]);
-
-            if (alarmInfoCache.hasKey(meterId, funcId)) {
-                currentDataCache.putCurrentData(meterId, funcId, value);
-                List<AlarmDefine> alarmDefines = alarmInfoCache.getAlarmDefinitionIdByMeterFuncId(meterId, funcId);
-                for (AlarmDefine alarmDefine : alarmDefines) {
-                    Condition condition = alarmDefine.getCondition();
-                    String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
-                    log.info("defineId: [{}]", defineId);
-                    List<JSONObject> codeDetail = condition.getInfoCodes();
-                    boolean match = codeDetail.stream().allMatch(
-                            p -> currentDataCache.hasKey(p.getString("meterId"), p.getString("funcId"))
-                    );
-                    //报警定义的所有信息点都有采集数值，具备判断条件
-                    if (match) {
-                        String trigger = condition.getTrigger();
-                        String end = condition.getEnd();
-                        HashMap<String, Object> paramMap = new HashMap<>();
-                        for (JSONObject code : codeDetail) {
-                            paramMap.put(
-                                    code.getString("infoCode"),
-                                    currentDataCache.getCurrentData(code.getString("meterId"), code.getString("funcId")));
-                        }
-                        Expression triggerExp = AviatorEvaluator.compile(trigger, true);
-                        Expression endExp = AviatorEvaluator.compile(end, true);
-                        Boolean triggerResult = (Boolean) triggerExp.execute(paramMap);
-                        Boolean endResult = (Boolean) endExp.execute(paramMap);
-                        log.info("triggerResult:[{}],endResult:[{}]", triggerResult, endResult);
-                        if (triggerResult && endResult) {
-                            log.warn("报警触发条件和报警恢复条件同时满足，请检查，报警定义详情【{}】", alarmDefine.toString());
-                        }
-                        // 使用intern（）方法，确保上锁的是同一个String对象
-                        synchronized (defineId.intern()) {
-                            //报警产生值满足（这里的满足不考虑报警持续时间）
-                            if (triggerResult) {
-                                log.info("满足报警条件");
-                                //                                log.info("--" + alarmDefine.toString());
-                                //                                log.info("--" + JSONObject.toJSONString(paramMap));
-                                //报警的时候不考虑报警恢复，因为同时报警和报警恢复是不应该出现的
-                                handlerNowDataAlarm(alarmDefine, dataTime, paramMap);
-                            } else {
-                                log.info("不满足报警条件");
-                                //                                log.info("--" + alarmDefine.toString());
-                                //                                log.info("--" + JSONObject.toJSONString(paramMap));
-                                //当前数据正常
-                                handlerNowDataNormal(alarmDefine, dataTime, endResult, paramMap);
-                            }
-                        }
-                    } else {
-                        log.warn("部分信息点没有数值");
-                    }
+
+        /* 将iot消息拆分成一条条iot数据，然后处理 */
+        String[] split = msg.split(";");
+        // 每一条iot数据应该包含4个分号
+        int groupCount = 4;
+        int dataCounts = split.length / groupCount;
+        for (int i = 0; i < dataCounts; i++) {
+            int startIndex = i * groupCount;
+            String dataTime = split[startIndex];
+            String meterId = split[startIndex + 1];
+            String funcId = split[startIndex + 2];
+            String value = split[startIndex + 3];
+            // 使用intern（）方法，确保上锁的是同一个String对象
+            synchronized (meterId.intern()) {
+                // 处理iot数据
+                handleIotData(dataTime, meterId, funcId, value);
+            }
+        }
+    }
+
+    /**
+     * @description: 处理iot数据, iot数据可能包含一个设备多个信息点的采集值
+     * @param: dataTime 采集时间
+     * @param: meterId 设备id
+     * @param: funcIdStr 信息点id
+     * @param: valueStr 采集值
+     * @return: void
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 3:44 下午
+     * @version: V1.0
+     */
+    private void handleIotData(String dataTime, String meterId, String funcIdStr, String valueStr) throws InterruptedException {
+        /* 如果iot数据为一组数据，先更新缓存中这组iot数据值，然后将这一组iot数据拆分为一条条iot数据处理 */
+        String funcIdSeparator = ",";
+        String[] funcIdArray = funcIdStr.split(funcIdSeparator);
+        String[] values = valueStr.split(funcIdSeparator);
+        // 更新缓存中的设备信息点当前采集值
+        for (int i = 0; i < funcIdArray.length; i++) {
+            // 如果有对应的报警定义
+            if (alarmInfoCache.hasKey(meterId, funcIdArray[i])) {
+                currentDataCache.putCurrentData(meterId, funcIdArray[i], Double.parseDouble(values[i]));
+            }
+        }
+
+        // 将一组数据拆分为单条处理
+        for (String funcId : funcIdArray) {
+            handleSingleIotData(dataTime, meterId, funcId);
+        }
+    }
+
+    /**
+     * @description: 处理单条iot数据
+     * @param: dataTime 采集时间
+     * @param: meterId 设备id
+     * @param: funcId 信息点id
+     * @return: void
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 4:01 下午
+     * @version: V1.0
+     */
+    private void handleSingleIotData(String dataTime, String meterId, String funcId) throws InterruptedException {
+        // 获取和采集值相关的报警定义
+        List<AlarmDefine> alarmDefines = alarmInfoCache.getAlarmDefinitionIdByMeterFuncId(meterId, funcId);
+        for (AlarmDefine alarmDefine : alarmDefines) {
+            Condition condition = alarmDefine.getCondition();
+            String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
+            log.info("defineId: [{}]", defineId);
+
+            // 判断报警定义所包含的信息点在缓存中是否都有值
+            List<JSONObject> infoCodes = condition.getInfoCodes();
+            boolean infoCodesFullFill = infoCodes.stream().allMatch(
+                    p -> currentDataCache.hasKey(p.getString("meterId"), p.getString("funcId"))
+            );
+
+            //报警定义的所有信息点都有采集数值，具备判断条件
+            if (infoCodesFullFill) {
+                // 解析触发和恢复条件
+                String trigger = condition.getTrigger();
+                Expression triggerExp = AviatorEvaluator.compile(trigger, true);
+                String end = condition.getEnd();
+                Expression endExp = AviatorEvaluator.compile(end, true);
+
+                // 拼装报警条件参数
+                HashMap<String, Object> paramMap = new HashMap<>();
+                for (JSONObject code : infoCodes) {
+                    paramMap.put(
+                            code.getString("infoCode"),
+                            currentDataCache.getCurrentData(code.getString("meterId"), code.getString("funcId")));
+                }
+
+                // 执行报警条件公式，得到触发和恢复结果
+                Boolean triggerResult = (Boolean) triggerExp.execute(paramMap);
+                Boolean endResult = (Boolean) endExp.execute(paramMap);
+                log.info("triggerResult:[{}],endResult:[{}]", triggerResult, endResult);
+                if (triggerResult && endResult) {
+                    log.error("报警触发条件和报警恢复条件同时满足，请检查，报警定义详情【{}】", alarmDefine.toString());
                 }
+
+                //报警产生值满足（这里的满足不考虑报警持续时间）
+                if (triggerResult) {
+                    log.info("满足报警条件");
+                    //报警的时候不考虑报警恢复，因为同时报警和报警恢复是不应该出现的
+                    handlerNowDataAlarm(alarmDefine, dataTime, paramMap);
+                } else {
+                    log.info("不满足报警条件");
+                    //当前数据正常
+                    handlerNowDataNormal(alarmDefine, dataTime, endResult, paramMap);
+                }
+            } else {
+                log.warn("部分信息点没有数值");
+            }
+        }
+    }
+
+    /**
+     * @description: 校验iot消息是否合法
+     * @param: msg iot数据消息
+     * @return: boolean 校验结果
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 2:26 下午
+     * @version: V1.0
+     */
+    private boolean validateIotMsg(String msg) {
+        // iot数据使用英文分号分隔
+        String separator = ";";
+        // 每一条iot数据应该包含4个分号
+        int groupCount = 4;
+        String[] split = msg.split(separator);
+        if (split.length % groupCount != 0) {
+            log.error("采集值有误！每一条iot数据应该包含4个英文分号");
+            return false;
+        }
+        // 数据条数
+        int dataCounts = (split.length) / groupCount;
+        for (int i = 0; i < dataCounts; i++) {
+            int startIndex = i * groupCount;
+            String dataTime = split[startIndex];
+            String meterId = split[startIndex + 1];
+            String funcId = split[startIndex + 2];
+            String value = split[startIndex + 3];
+
+            boolean iotDataValidateResult = validateIotData(dataTime, meterId, funcId, value);
+            if (!iotDataValidateResult) {
+                return false;
             }
+        }
+        return true;
+    }
 
+    /**
+     * @description: 校验iot数据是否合法
+     * @param: dataTime 采集时间
+     * @param: meterId 设备id
+     * @param: funcId 信息点id
+     * @param: value 采集值
+     * @return: boolean 校验结果
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 3:22 下午
+     * @version: V1.0
+     */
+    private boolean validateIotData(String dataTime, String meterId, String funcId, String value) {
+        String separator = ",";
+        // 校验时间格式
+        boolean dateTimeValid = ValidateUtils.validateDateTime(dataTime);
+        if (!dateTimeValid) {
+            log.error("采集值时间有误，[{}]", dataTime);
+            return false;
+        }
+
+        // 校验信息点和值是否匹配
+        int funcIdsLength = funcId.split(separator).length;
+        int valuesLength = value.split(separator).length;
+        if (funcIdsLength != valuesLength) {
+            log.error("信息点个数与值的个数不匹配");
+            return false;
+        }
+
+        // 校验值是否为合法的值
+        if (!value.contains(separator)) {
+            try {
+                Double.parseDouble(value);
+            } catch (NumberFormatException e) {
+                log.error("采集值不能被转换为数字，[{}]", value);
+                return false;
+            }
+        } else {
+            String[] values = value.split(separator);
+            for (String tmp : values) {
+                try {
+                    Double.parseDouble(tmp);
+                } catch (NumberFormatException e) {
+                    log.error("采集值不能被转换为数字，[{}]", value);
+                    return false;
+                }
+            }
         }
+
+        return true;
     }
 
     /**
@@ -177,7 +324,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      * @param dataTime    :IOT采集时间
      * @param endResult   :报警恢复监测结果
      * @param paramMap    报警恢复触发值
-     * @description:当前数据正常判断逻辑
+     * @description: 当前数据正常判断逻辑
      * @exception:
      * @author: LuoGuangyi
      * @company: Persagy Technology Co.,Ltd
@@ -240,7 +387,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
                 // 报警恢复后，从缓存中移除报警id
                 createdAlarmIdsCache.remove(alarmId);
             } else {
-                log.info("未获取到报警记录id, 3分钟后重试发送报警恢复消息");
+                log.info("已创建的报警id中不包含[{}], 3分钟后重试发送报警恢复消息", alarmId);
                 //如果没有报警ID,定时任务再次测试
                 JobDataMap jobDataMap = new JobDataMap();
                 jobDataMap.put("alarmRecord", alarmRecordDO.toString());
@@ -283,7 +430,7 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      * @version: V1.0
      */
     private void deleteZktAlarmRecordWhenAlarmSuspend(String defineId) {
-        if(alarmRecordRepository.existsById(defineId)) {
+        if (alarmRecordRepository.existsById(defineId)) {
             alarmRecordRepository.deleteById(defineId);
         }
     }
@@ -501,12 +648,15 @@ public class AlarmHandleServiceImpl implements AlarmHandleService {
      * @version: V1.0
      */
     private ZktAlarmRecordDO saveZktAlarmRecordWhenAlarmStart(String alarmId, AlarmDefine alarmDefine, String alarmTime) {
-        ZktAlarmRecordDO zktAlarmRecordDO = initZktAlarmRecordDO(alarmDefine);
-        zktAlarmRecordDO.setAlarmId(alarmId);
-        zktAlarmRecordDO.setState("1");
-        zktAlarmRecordDO.setAlarmTime(alarmTime);
-        alarmRecordRepository.save(zktAlarmRecordDO);
-        return zktAlarmRecordDO;
+        String defineId = AlarmInfoCache.getAlarmDefineId(alarmDefine);
+        synchronized (defineId.intern()) {
+            ZktAlarmRecordDO zktAlarmRecordDO = initZktAlarmRecordDO(alarmDefine);
+            zktAlarmRecordDO.setAlarmId(alarmId);
+            zktAlarmRecordDO.setState("1");
+            zktAlarmRecordDO.setAlarmTime(alarmTime);
+            alarmRecordRepository.save(zktAlarmRecordDO);
+            return zktAlarmRecordDO;
+        }
     }
 
     /**

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

@@ -35,8 +35,6 @@ public class AlarmQuartzServiceImpl implements AlarmQuartzService {
 
     @Override
     public void initAlarmMessagehandler() {
-
-        System.out.println("--init--");
         //启动后先休息20秒，这样报警netty  websocket  quartz都启动了
         try {
             Thread.sleep(20000);

src/main/java/com/persagy/utils/ValidateUtils.java

@@ -0,0 +1,55 @@
+package com.persagy.utils;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * @description: 校验通用类
+ * @author: lixing
+ * @company: Persagy Technology Co.,Ltd
+ * @since: 2021/2/1 2:40 下午
+ * @version: V1.0
+ **/
+public class ValidateUtils {
+    private static final String dateTimeDefaultPattern = "yyyyMMddHHmmss";
+
+    /**
+     * @description: 校验时间字符串是否合法
+     * @param: dateTime 时间字符串
+     * @param: pattern 时间格式
+     * @return: boolean
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 4:10 下午
+     * @version: V1.0
+     */
+    public static boolean validateDateTime(String dateTime, String pattern) {
+        try {
+            DateTimeFormatter inFormat = DateTimeFormatter.ofPattern(pattern);
+            LocalDateTime.parse(dateTime, inFormat);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * @description: 校验时间字符串是否合法
+     * @param: dateTime 时间字符串
+     * @return: boolean
+     * @exception:
+     * @author: lixing
+     * @company: Persagy Technology Co.,Ltd
+     * @since: 2021/2/1 4:10 下午
+     * @version: V1.0
+     */
+    public static boolean validateDateTime(String dateTime) {
+        return validateDateTime(dateTime, dateTimeDefaultPattern);
+    }
+
+//    public static void main(String[] args) {
+//        boolean b = validateDateTime("20120232112233");
+//        System.out.println(b);
+//    }
+}

src/main/resources/logback-spring.xml

@@ -5,9 +5,9 @@ debug:  当此属性设置为true时，将打印出logback内部日志信息，
 configuration 子节点为 appender、logger、root       -->
 <configuration scan="true" scanPeriod="60 seconds" debug="false">
     <!--用于区分不同应用程序的记录-->
-    <contextName>zk-project-alarm</contextName>
+    <contextName>alarm-engine</contextName>
     <!--日志文件所在目录，如果是tomcat，如下写法日志文件会在则为${TOMCAT_HOME}/bin/logs/目录下-->
-    <property name="LOG_HOME" value="../logs/zk-project-alarm"/>
+    <property name="LOG_HOME" value="../logs/alarm-engine"/>
     <!--
     %p:输出优先级，即DEBUG,INFO,WARN,ERROR,FATAL
     %r:输出自应用启动到输出该日志讯息所耗费的毫秒数