案例 9：IoT 设备告警分级

本案例对应 JQuick-Java 仓库 USE-CASES.md 的场景 9：IoT 设备告警分级，属于物联网/设备运维领域，解决对传感器、网关、摄像头、工业机器人等设备做「六维实时指标独立打分 → 告警等级/类型 → 派单/通知/自动处置/升级时限」的实时告警决策问题。

行业场景

IoT 平台需要对海量在线设备做实时告警分级。设备运行快照包含：设备编号、名称、类型（SENSOR/GATEWAY/CAMERA/ROBOT）、设备重要性（HIGH/MEDIUM/LOW）、当前温度、CPU 使用率、内存使用率、窗口期错误次数、是否断连、最近心跳间隔（秒）、电池电量与振动强度。

评分从六个维度独立进行：温度按 90/80/70/60℃ 四档记 35/25/15/8 分；错误次数按 20/10/5/1 次四档记 25/18/10/4 分；CPU 与内存取峰值后按 95%/85%/75% 记 20/12/6 分；电量不高于 5% 记 15 分、不高于 20% 记 8 分；断连直接记 25 分，心跳间隔达到 300 秒记 15 分、达到 120 秒记 8 分；振动强度按 8/5/3 三档记 20/12/5 分。六维汇总后按 70/45/20 三条线映射 CRITICAL/MAJOR/MINOR/NORMAL。

告警类型按「网络 > 温度 > 性能 > 电量 > 振动」的业务优先级唯一归类：断连或心跳超过 300 秒归为 NETWORK，温度达到 70℃ 归为 TEMPERATURE，CPU 或内存达到 85% 归为 PERFORMANCE，电量不高于 20% 归为 POWER，振动达到 5 归为 VIBRATION。在等级与类型之上，再联动产出派单结论与 P0-P3 优先级（45 分以上必派单，20-44 分的关键 HIGH 设备也要派单，优先级 P2）、通知渠道（CRITICAL 电话、MAJOR 短信、MINOR IM、其余邮件）、自动处置动作（70 分以上或网络类隔离 ISOLATE，性能类限流 RATE_LIMIT，温度/振动类降频 THROTTLE）与升级时限（CRITICAL 5 分钟、MAJOR 15 分钟、MINOR 60 分钟、NORMAL 240 分钟）。

决策同时附带命中指标明细与处置动作清单，便于告警复盘与审计。场景 9 覆盖 6 组形态：炼钢炉温控传感器严重过热 80 分 P0、园区闸机网关断连 51 分 P1、图像识别节点性能告警 22 分 MINOR 不派单、关键设备低电量 25 分 P2 派单、健康设备 0 分 NORMAL、传送带电机振动异常 38 分降频。

业务痛点

六维阈值（温度 90/80/70/60℃、错误 20/10/5/1 次、心跳 300/120 秒、电量 5%/20% 等）硬编码在网关脚本、流式作业与告警平台中，调一次阈值要重新上线整条链路。
告警类型按优先级归类与六维评分是两套逻辑，散落在不同组件里，新增一个告警维度就要同时改多处。
派单不仅看分数还要叠加设备重要性（20-44 分的关键设备 P2 派单），用普通 if-else 堆叠后迅速腐化、无人敢改。
通知渠道、自动处置（隔离/限流/降频）、升级时限都与告警等级联动，改一个升级时限可能影响派单与通知，牵一发而动全身。
告警风暴之下，运维需要每条告警附带命中了哪些指标、执行了哪些处置动作，黑盒告警无法复盘和定责。
边缘网关与设备平台多为 JDK 8 与国产化环境，资源受限，无法部署重型规则中间件。

方案架构

本案例采用标准「六件套」：入参模型承载设备实时快照，决策结果模型承载等级、类型、派单、通知、处置与升级时限，规则接口声明 13 个规则方法，XML 脚本外置全部打分口径与阈值，Service 负责六维汇总封顶与指标/动作组装，JUnit 以 6 组告警形态回归。

层次	职责	对应文件
领域模型	设备运行快照、告警决策结果	DeviceAlarm.java、AlarmDecision.java
规则集与 XML	六维评分 + 类型归类 + 等级/派单/通知/处置/升级共 13 个方法	DeviceAlarmRules.java、device-alarm.xml
编排服务	六维汇总并 clamp 到 0-100、指标明细与处置动作清单组装	DeviceAlarmService.java
测试	6 组告警形态（过热/断连/性能/低电量/正常/振动）	DeviceAlarmServiceTest.java

规则方法拆分

规则方法	口径	分值/输出
`scoreTemperature`	≥90℃ 35 / ≥80 25 / ≥70 15 / ≥60 8 / 否则 0	0-35
`scoreError`	错误次数 ≥20 记 25 / ≥10 记 18 / ≥5 记 10 / ≥1 记 4 / 否则 0	0-25
`scoreResource`	CPU 与内存取峰值，≥95 记 20 / ≥85 记 12 / ≥75 记 6 / 否则 0	0-20
`scoreBattery`	电量 ≤5% 记 15 / ≤20% 记 8 / 否则 0	0-15
`scoreConnection`	断连记 25 / 心跳 ≥300s 记 15 / ≥120s 记 8 / 否则 0	0-25
`scoreVibration`	振动 ≥8 记 20 / ≥5 记 12 / ≥3 记 5 / 否则 0	0-20
`alarmLevel`	≥70 CRITICAL / ≥45 MAJOR / ≥20 MINOR / 否则 NORMAL	CRITICAL/MAJOR/MINOR/NORMAL
`alarmType`	网络（断连或心跳≥300s）> 温度（≥70℃）> 性能（CPU/内存≥85）> 电量（≤20%）> 振动（≥5），否则 NONE	NETWORK/TEMPERATURE/PERFORMANCE/POWER/VIBRATION/NONE
`needDispatch`	≥45 派单；20-44 且关键设备（HIGH）派单；否则不派	true / false
`dispatchPriority`	≥70 P0 / ≥45 P1 / 20-44 且 HIGH 为 P2 / 否则 P3	P0/P1/P2/P3
`notifyChannel`	CRITICAL PHONE_CALL / MAJOR SMS / MINOR IM / 其余 EMAIL	PHONE_CALL/SMS/IM/EMAIL
`autoRemediation`	≥70 或 NETWORK → ISOLATE；PERFORMANCE → RATE_LIMIT；TEMPERATURE/VIBRATION → THROTTLE；否则 NONE	ISOLATE/RATE_LIMIT/THROTTLE/NONE
`escalateMinutes`	CRITICAL 5 / MAJOR 15 / MINOR 60 / NORMAL 240	升级时限（分钟）

代码实现（完整可运行）

将六个文件按仓库原有包结构放入 Maven 工程：两个模型放入 src/test/java/com/github/paohaijiao/demo/model/，规则接口与测试放入 com.github.paohaijiao.demo 包，编排服务放入 com.github.paohaijiao.demo.service 包，XML 脚本放入 src/test/resources/demo/device-alarm.xml，包名全部保持源码原样。工程根目录执行 mvn test -Dtest=DeviceAlarmServiceTest 即可运行。

DeviceAlarm.java

package com.github.paohaijiao.demo.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * IoT 设备运行快照（告警分级所需的实时指标）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeviceAlarm {

    /**
     * 设备编号
     */
    private String deviceId;

    /**
     * 设备名称
     */
    private String deviceName;

    /**
     * 设备类型：SENSOR / GATEWAY / CAMERA / ROBOT
     */
    private String deviceType;

    /**
     * 设备重要性：HIGH / MEDIUM / LOW
     */
    private String criticality;

    /**
     * 温度（摄氏度）
     */
    private double temperature;

    /**
     * CPU 使用率（0-100）
     */
    private int cpuUsage;

    /**
     * 内存使用率（0-100）
     */
    private int memoryUsage;

    /**
     * 窗口期内错误次数
     */
    private int errorCount;

    /**
     * 是否断连
     */
    private boolean connectionLost;

    /**
     * 最近心跳间隔（秒）
     */
    private int lastHeartbeatSeconds;

    /**
     * 电池电量（0-100）
     */
    private int batteryLevel;

    /**
     * 振动强度
     */
    private double vibrationLevel;
}

AlarmDecision.java

package com.github.paohaijiao.demo.model;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * IoT 设备告警决策结果
 */
@Data
public class AlarmDecision {

    /**
     * 设备编号
     */
    private String deviceId;

    /**
     * 告警分（0-100）
     */
    private int alarmScore;

    /**
     * 告警等级：CRITICAL / MAJOR / MINOR / NORMAL
     */
    private String alarmLevel;

    /**
     * 告警类型：TEMPERATURE / PERFORMANCE / NETWORK / POWER / VIBRATION / NONE
     */
    private String alarmType;

    /**
     * 是否派发工单
     */
    private boolean needDispatch;

    /**
     * 派单优先级：P0 / P1 / P2 / P3
     */
    private String dispatchPriority;

    /**
     * 通知渠道：PHONE_CALL / SMS / IM / EMAIL
     */
    private String notifyChannel;

    /**
     * 自动处置动作：ISOLATE / RATE_LIMIT / THROTTLE / NONE
     */
    private String autoRemediation;

    /**
     * 升级时限（分钟）
     */
    private int escalateMinutes;

    /**
     * 命中指标明细
     */
    private List<String> indicators = new ArrayList<String>();

    /**
     * 处置动作建议
     */
    private List<String> actions = new ArrayList<String>();

    public void addIndicator(String indicator) {
        this.indicators.add(indicator);
    }

    public void addAction(String action) {
        this.actions.add(action);
    }
}

DeviceAlarmRules.java

package com.github.paohaijiao.demo;

import com.github.paohaijiao.xml.param.Param;

/**
 * 场景 9：IoT 设备告警分级
 * <p>
 * 各维度独立打分（温度/错误/资源/电量/连接/振动），再由综合分决定等级、派单、通知与自动处置。
 */
public interface DeviceAlarmRules {

    int scoreTemperature(@Param("temperature") double temperature);

    int scoreError(@Param("errorCount") int errorCount);

    int scoreResource(@Param("cpuUsage") int cpuUsage,
                      @Param("memoryUsage") int memoryUsage);

    int scoreBattery(@Param("batteryLevel") int batteryLevel);

    int scoreConnection(@Param("connectionLost") boolean connectionLost,
                        @Param("lastHeartbeatSeconds") int lastHeartbeatSeconds);

    int scoreVibration(@Param("vibrationLevel") double vibrationLevel);

    String alarmLevel(@Param("alarmScore") int alarmScore);

    String alarmType(@Param("connectionLost") boolean connectionLost,
                     @Param("lastHeartbeatSeconds") int lastHeartbeatSeconds,
                     @Param("temperature") double temperature,
                     @Param("cpuUsage") int cpuUsage,
                     @Param("memoryUsage") int memoryUsage,
                     @Param("batteryLevel") int batteryLevel,
                     @Param("vibrationLevel") double vibrationLevel);

    boolean needDispatch(@Param("alarmScore") int alarmScore,
                         @Param("criticality") String criticality);

    String dispatchPriority(@Param("alarmScore") int alarmScore,
                            @Param("criticality") String criticality);

    String notifyChannel(@Param("alarmLevel") String alarmLevel,
                         @Param("criticality") String criticality);

    String autoRemediation(@Param("alarmType") String alarmType,
                           @Param("alarmScore") int alarmScore);

    int escalateMinutes(@Param("alarmLevel") String alarmLevel);
}

-alarm.xml

class="header">

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE javas PUBLIC "-//PAOHAIJIAO//DTD API JAVA 1.0//EN"
        "classpath:paohaijiao/dtd/Jquick-java.dtd">
<javas namespace="com.github.paohaijiao.demo.DeviceAlarmRules">
 <!-- 温度评分：0~35 -->
    <java name="scoreTemperature" returnClass="int">
        <![CDATA[
            int def scoreTemperature(double:temperature) {
                if (temperature >= 90.0) {
                    return 35;
                } else if (temperature >= 80.0) {
                    return 25;
                } else if (temperature >= 70.0) {
                    return 15;
                } else if (temperature >= 60.0) {
                    return 8;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 错误次数评分：0~25 -->
    <java name="scoreError" returnClass="int">
        <![CDATA[
            int def scoreError(int:errorCount) {
                if (errorCount >= 20) {
                    return 25;
                } else if (errorCount >= 10) {
                    return 18;
                } else if (errorCount >= 5) {
                    return 10;
                } else if (errorCount >= 1) {
                    return 4;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 资源占用评分（取 CPU/内存峰值）：0~20 -->
    <java name="scoreResource" returnClass="int">
        <![CDATA[
            int def scoreResource(int:cpuUsage, int:memoryUsage) {
                int peak = cpuUsage;
                if (memoryUsage > peak) {
                    peak = memoryUsage;
                }
                if (peak >= 95) {
                    return 20;
                } else if (peak >= 85) {
                    return 12;
                } else if (peak >= 75) {
                    return 6;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 电量评分：0~15 -->
    <java name="scoreBattery" returnClass="int">
        <![CDATA[
            int def scoreBattery(int:batteryLevel) {
                if (batteryLevel <= 5) {
                    return 15;
                } else if (batteryLevel <= 20) {
                    return 8;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 连接异常评分：0~25 -->
    <java name="scoreConnection" returnClass="int">
        <![CDATA[
            int def scoreConnection(boolean:connectionLost, int:lastHeartbeatSeconds) {
                if (connectionLost) {
                    return 25;
                } else if (lastHeartbeatSeconds >= 300) {
                    return 15;
                } else if (lastHeartbeatSeconds >= 120) {
                    return 8;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 振动评分：0~20 -->
    <java name="scoreVibration" returnClass="int">
        <![CDATA[
            int def scoreVibration(double:vibrationLevel) {
                if (vibrationLevel >= 8.0) {
                    return 20;
                } else if (vibrationLevel >= 5.0) {
                    return 12;
                } else if (vibrationLevel >= 3.0) {
                    return 5;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 告警等级 -->
    <java name="alarmLevel" returnClass="java.lang.String">
        <![CDATA[
            str def alarmLevel(int:alarmScore) {
                if (alarmScore >= 70) {
                    return "CRITICAL";
                } else if (alarmScore >= 45) {
                    return "MAJOR";
                } else if (alarmScore >= 20) {
                    return "MINOR";
                } else {
                    return "NORMAL";
                }
            }
        ]]>
    </java>
 <!-- 告警类型（按业务优先级归类） -->
    <java name="alarmType" returnClass="java.lang.String">
        <![CDATA[
            str def alarmType(boolean:connectionLost, int:lastHeartbeatSeconds, double:temperature,
                              int:cpuUsage, int:memoryUsage, int:batteryLevel, double:vibrationLevel) {
                if (connectionLost || lastHeartbeatSeconds >= 300) {
                    return "NETWORK";
                } else if (temperature >= 70.0) {
                    return "TEMPERATURE";
                } else if (cpuUsage >= 85 || memoryUsage >= 85) {
                    return "PERFORMANCE";
                } else if (batteryLevel <= 20) {
                    return "POWER";
                } else if (vibrationLevel >= 5.0) {
                    return "VIBRATION";
                } else {
                    return "NONE";
                }
            }
        ]]>
    </java>
 <!-- 是否派单 -->
    <java name="needDispatch" returnClass="boolean">
        <![CDATA[
            boolean def needDispatch(int:alarmScore, str:criticality) {
                if (alarmScore >= 45) {
                    return true;
                } else if (alarmScore >= 20 && criticality == "HIGH") {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 派单优先级 -->
    <java name="dispatchPriority" returnClass="java.lang.String">
        <![CDATA[
            str def dispatchPriority(int:alarmScore, str:criticality) {
                if (alarmScore >= 70) {
                    return "P0";
                } else if (alarmScore >= 45) {
                    return "P1";
                } else if (alarmScore >= 20 && criticality == "HIGH") {
                    return "P2";
                } else {
                    return "P3";
                }
            }
        ]]>
    </java>
 <!-- 通知渠道 -->
    <java name="notifyChannel" returnClass="java.lang.String">
        <![CDATA[
            str def notifyChannel(str:alarmLevel, str:criticality) {
                if (alarmLevel == "CRITICAL") {
                    return "PHONE_CALL";
                } else if (alarmLevel == "MAJOR") {
                    return "SMS";
                } else if (alarmLevel == "MINOR") {
                    return "IM";
                } else {
                    return "EMAIL";
                }
            }
        ]]>
    </java>
 <!-- 自动处置动作 -->
    <java name="autoRemediation" returnClass="java.lang.String">
        <![CDATA[
            str def autoRemediation(str:alarmType, int:alarmScore) {
                if (alarmScore >= 70) {
                    return "ISOLATE";
                } else if (alarmType == "NETWORK") {
                    return "ISOLATE";
                } else if (alarmType == "PERFORMANCE") {
                    return "RATE_LIMIT";
                } else if (alarmType == "TEMPERATURE") {
                    return "THROTTLE";
                } else if (alarmType == "VIBRATION") {
                    return "THROTTLE";
                } else {
                    return "NONE";
                }
            }
        ]]>
    </java>
 <!-- 升级时限（分钟） -->
    <java name="escalateMinutes" returnClass="int">
        <![CDATA[
            int def escalateMinutes(str:alarmLevel) {
                if (alarmLevel == "CRITICAL") {
                    return 5;
                } else if (alarmLevel == "MAJOR") {
                    return 15;
                } else if (alarmLevel == "MINOR") {
                    return 60;
                } else {
                    return 240;
                }
            }
        ]]>
    </java>
 style="--0:#7FDBCA"></javas>

>DeviceAlarmService.java