基于SpringBoot和Vue的实时设备告警系统全链路实现方案

实时监控告警这个功能，说起来简单，但真正落地的时候，坑比想象中多——重复报警、僵尸告警、前端刷屏，哪个都能让人头疼。下面就把从数据采集、告警判定、持久化、接口暴露，到前端展示、闭环处理、兜底补偿的整个链条完整捋一遍。每个环节的关键设计要点和通用代码示例都会给到，而且尽量跟具体业务解耦，方便你直接拿过来参考。

一、整体架构与数据流

一个典型的实时告警系统，拆开来看，其实就五段：

┌──────────┐   采集    ┌──────────┐  判定/去重  ┌──────────┐
│ 数据源    │ ───────▶ │ 采集任务  │ ─────────▶ │  告警表   │
│(设备/API)│  周期轮询  │(定时/流) │  生成/闭环  │ (DB)     │
└──────────┘           └──────────┘            └────┬─────┘
                                                     │ REST
                                              ┌──────▼─────┐   推送/轮询  ┌─────────┐
                                              │ 后端接口层  │ ──────────▶ │ 前端界面 │
                                              └────────────┘             │ +提醒    │
                                                                         └─────────┘

设计的时候，有几个原则需要先定下来：

• 采集与判定解耦：采集只管拿到原始状态，判定逻辑独立出来，后面想加新告警类型就不用改采集代码。
• 状态化而非事件流：告警落库要是一条有生命周期的记录（有 start/stop），而不是无穷无尽的日志流。这样才能做“当前未恢复告警”这种查询，不然每次都得扫全量。
• 前端只读 + 幂等操作：前端不参与告警产生，只做展示，以及“确认/处理”这类幂等状态流转。写死了，省心。

二、告警生成层：边沿检测与状态机

2.1 电平 vs 边沿

采集到的原始状态，通常是电平信号——布尔量，故障=true，正常=false。如果每个采集周期只要 true 就插一条告警，2秒一采集，一分钟就能刷出30条，一天下来表里全是重复数据。

正确的做法是边沿检测（Edge Detection）：只在状态发生跳变的时候动作。

2.2 通用示例：边沿检测器

/**
 * 通用布尔量边沿检测器，线程安全
 * key 通常是 "设备ID:信号名"
 */
public class EdgeDetector {

    private final Map lastState = new ConcurrentHashMap<>();

    public enum Edge { RISING, FALLING, NONE }

    public Edge detect(String key, boolean current) {
        Boolean prev = lastState.put(key, current);
        if (prev == null) {
            // 首次采集：把 true 视为上升沿，false 视为无事件
            return current ? Edge.RISING : Edge.NONE;
        }
        if (!prev && current) return Edge.RISING;
        if (prev && !current) return Edge.FALLING;
        return Edge.NONE;
    }
}

2.3 在采集周期中使用

EdgeDetector detector = new EdgeDetector();

void onSample(String deviceId, String signal, boolean faultBit, Date now) {
    String key = deviceId + ":" + signal;
    switch (detector.detect(key, faultBit)) {
        case RISING:
            alarmService.open(deviceId, signal, now);   // 生成告警
            break;
        case FALLING:
            alarmService.close(deviceId, signal, now);  // 闭合告警
            break;
        default:
            // 状态未变，忽略
    }
}

状态存哪里？ 单机可用内存 Map；多实例或需要重启不丢，可以把“上一次状态”放 Redis，或者直接以数据库中“是否存在未闭合告警”作为判断依据（见第3节，最稳，不需要额外状态存储）。

三、告警去重与生命周期

比内存边沿更可靠的方案：以数据库中“是否存在未闭合记录”作为状态源。天然幂等、重启不丢、多实例也安全。

3.1 生命周期模型

一条告警记录有三个关键时间点与两个派生字段：

start_time ──────(持续中)──────▶ stop_time
                                  total_time = stop - start（秒）
handle_status: 待确认 → 已确认 → 已处理（或 超时未确认）

3.2 开告警（带去重）

public void open(Long deviceId, String alarmName, Date startTime) {
    // 去重：若已存在该设备该类型"未闭合"告警，则不再新建
    if (mapper.selectUnfinished(deviceId, alarmName) != null) {
        return;
    }
    Alarm a = new Alarm();
    a.setDeviceId(deviceId);
    a.setAlarmName(alarmName);
    a.setStartTime(startTime);
    a.setAlarmLevel(resolveLevel(alarmName));   // 名称→等级映射
    a.setHandleStatus(STATUS_PENDING);          // 默认待确认
    mapper.insert(a);
}

3.3 关告警（计算时长）

public boolean close(Long deviceId, String alarmName, Date stopTime) {
    Alarm a = mapper.selectUnfinished(deviceId, alarmName);
    if (a == null) return false;                // 没有未闭合记录，忽略

    long seconds = (stopTime.getTime() - a.getStartTime().getTime()) / 1000;
    return mapper.updateStop(a.getId(), stopTime, seconds) > 0;
}

3.4 名称 → 等级映射（可配置化）

把“哪个告警多严重”抽成映射表，以后加告警只改配置，不改逻辑：

public class AlarmLevel {
    public static final int INFO = 1, WARN = 2, SERIOUS = 3, FATAL = 4;

    private static final Map MAP = new HashMap<>();
    static {
        MAP.put("急停", FATAL);
        MAP.put("高压报警", SERIOUS);
        MAP.put("低流量报警", WARN);
        // ...
    }
    /** 未命中默认按严重处理，保证"漏配也不漏报" */
    public static int of(String name) {
        return MAP.getOrDefault(name, SERIOUS);
    }
}

更进一步，可以把映射表放到数据库字典表（sys_dict_data）或独立阈值配置表，做到运营可视化配置。

四、数据库层设计

4.1 建表 DDL（通用示例）

CREATE TABLE device_alarm (
    id            BIGINT       NOT NULL AUTO_INCREMENT COMMENT '主键',
    device_id     BIGINT       NOT NULL               COMMENT '设备ID',
    alarm_name    VARCHAR(64)  NOT NULL               COMMENT '告警名称/类型',
    alarm_level   TINYINT      NOT NULL DEFAULT 3      COMMENT '等级 1提示2预警3严重4致命',
    start_time    DATETIME     NOT NULL               COMMENT '开始时间',
    stop_time     DATETIME     NULL                   COMMENT '结束时间(NULL=未恢复)',
    total_time    INT          NULL                   COMMENT '持续秒数',
    handle_status TINYINT      NOT NULL DEFAULT 0      COMMENT '0待确认1已确认2超时3已处理',
    handle_user   VARCHAR(64)  NULL                   COMMENT '处理人',
    handle_time   DATETIME     NULL                   COMMENT '处理时间',
    handle_remark VARCHAR(500) NULL                   COMMENT '处理备注',
    create_time   DATETIME     NOT NULL               COMMENT '创建时间',
    PRIMARY KEY (id),
    KEY idx_device_unfinished (device_id, alarm_name, stop_time),
    KEY idx_stop_time (stop_time),
    KEY idx_create_time (create_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='设备告警表';

4.2 索引设计要点

stop_time IS NULL 表示未恢复——用 NULL 而不是额外的 is_finished 布尔字段，语义清晰且能与时间字段复用索引。

4.3 关键 SQL

-- 查未闭合（去重判断）
SELECT * FROM device_alarm
WHERE device_id = #{deviceId} AND alarm_name = #{alarmName}
  AND stop_time IS NULL LIMIT 1;
-- 闭合告警
UPDATE device_alarm
SET stop_time = #{stopTime}, total_time = #{seconds}
WHERE id = #{id} AND stop_time IS NULL;   -- 加 stop_time IS NULL 防并发重复闭合
-- 当前未恢复列表
SELECT a.*, d.device_name
FROM device_alarm a LEFT JOIN device d ON a.device_id = d.id
WHERE a.stop_time IS NULL
ORDER BY a.alarm_level DESC, a.start_time DESC;

并发防护：UPDATE ... WHERE id=? AND stop_time IS NULL 利用行锁 + 条件，天然防止两个线程重复闭合同一告警（第二个 UPDATE 影响 0 行）。

五、后端接口层：REST API 设计

5.1 接口清单（RESTful + 语义动作）

查询用 REST 名词 + GET；“确认/处理”这类状态流转用动词子路径（/confirm、/handle），比强行 PUT 整个对象更清晰、更安全——避免前端误改其他字段。

5.2 通用控制器示例

@RestController
@RequestMapping("/alarm")
public class AlarmController {

    @Autowired private AlarmService service;

    /** 前端轮询：当前所有未恢复告警 */
    @GetMapping("/current")
    public Result> current() {
        return Result.ok(service.listUnfinished());
    }

    /** 确认（幂等） */
    @PostMapping("/confirm/{id}")
    public Result confirm(@PathVariable Long id) {
        service.confirm(id, currentUser());
        return Result.ok();
    }

    /** 处理闭环 */
    @PostMapping("/handle")
    public Result handle(@RequestParam Long id,
                               @RequestParam(required = false) String remark) {
        service.handle(id, remark, currentUser());
        return Result.ok();
    }
}

5.3 权限与审计

• 每个写接口加权限校验（如 Spring Security @PreAuthorize）。
• “确认/处理”记录操作人 + 操作时间，形成审计链，责任可追溯。

六、前端展示层：三种实时推送方案对比

前端要“实时”感知新告警，有三条技术路线可以选：

6.1 轮询（最常用，通用示例）

class AlarmPoller {
  constructor(fetchFn, { interval = 5000, onNew } = {}) {
    this.fetchFn = fetchFn;      // 返回 Promise
    this.interval = interval;
    this.onNew = onNew;
    this.knownIds = new Set();
    this.timer = null;
  }

  start() {
    this.tick();                 // 立即拉一次
    this.timer = setInterval(() => this.tick(), this.interval);
  }

  async tick() {
    try {
      const list = await this.fetchFn();
      // 找出本轮"新出现"的告警
      const fresh = list.filter(a => !this.knownIds.has(a.id));
      list.forEach(a => this.knownIds.add(a.id));
      // 清理已恢复的 id，防止 Set 无限膨胀
      const alive = new Set(list.map(a => a.id));
      this.knownIds = new Set([...this.knownIds].filter(id => alive.has(id)));
      if (fresh.length && this.onNew) this.onNew(fresh);
    } catch (e) {
      console.error('轮询告警失败', e);   // 失败不中断下一轮
    }
  }

  stop() { clearInterval(this.timer); this.timer = null; }
}

// 用法
const poller = new AlarmPoller(() => api.getCurrentAlarms(), {
  interval: 5000,
  onNew: (alarms) => alarms.forEach(a => alarmManager.alarm({
    title: a.deviceName, body: a.alarmName, level: mapLevel(a.alarmLevel),
  })),
});
poller.start();

轮询的两个关键技巧：

1. “新增”判定用 id 集合 diff，不要每次全量弹提醒，否则同一告警会反复响。
2. 及时清理已恢复 id，避免 Set 内存泄漏。

6.2 SSE（服务端主动推）

// 前端
const es = new EventSource('/alarm/stream');
es.addEventListener('alarm', (e) => {
  const alarm = JSON.parse(e.data);
  alarmManager.alarm({ title: alarm.deviceName, body: alarm.alarmName });
});
es.onerror = () => console.warn('SSE 断开，浏览器将自动重连');

// 后端 Spring MVC
@GetMapping(value = "/alarm/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter stream() {
    SseEmitter emitter = new SseEmitter(0L);       // 不超时
    emitterRegistry.add(emitter);                  // 存起来，产生告警时广播
    emitter.onCompletion(() -> emitterRegistry.remove(emitter));
    return emitter;
}
// 产生新告警时：emitter.send(SseEmitter.event().name("alarm").data(alarm));

6.3 WebSocket（双向）

const ws = new WebSocket('wss://host/ws/alarm');
ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  if (msg.type === 'ALARM') alarmManager.alarm(msg.payload);
};
// 心跳保活
setInterval(() => ws.readyState === 1 && ws.send('ping'), 30000);

选型建议：秒级监控大屏优先轮询（最稳、运维成本最低）；需要毫秒级或服务端主动推且不想维护重连时用 SSE；有双向指令交互（如页面下发控制命令）才上 WebSocket。

七、前端提醒层

新告警到达后，触发“提醒三件套”：

• Web Audio 蜂鸣：按告警等级播放不同急促度的合成音，无需音频文件。
• 浏览器 Notification：仅在 document.visibilityState !== 'visible'（用户切走）时弹系统通知，避免前台重复骚扰。
• 标题 / fa vicon 红点角标：后台时用 document.title 计数 + Canvas 绘制 fa vicon 角标，把用户“拉回来”。

统一入口示例：

poller.onNew = (alarms) => {
  alarms.forEach(a => alarmManager.alarm({
    title: a.deviceName,
    body: a.alarmName,
    level: mapLevel(a.alarmLevel),
    tag: 'alarm-' + a.id,        // 去重，防刷屏
  }));
};

八、闭环处理：确认 / 处理 / 超时

告警不能只“响”，必须能被人闭环，否则等于噪音。典型状态机：

        产生
待确认 ───────▶ (用户点确认) ──▶ 已确认 ──▶ (处理完+备注) ──▶ 已处理
   │
   └─(超过N分钟无人确认)──▶ 超时未确认   ← 用于考核值班响应

8.1 确认（幂等）

public void confirm(Long id, String user) {
    Alarm a = new Alarm();
    a.setId(id);
    a.setHandleStatus(STATUS_CONFIRMED);
    a.setHandleUser(user);
    a.setHandleTime(new Date());
    mapper.updateSelective(a);      // 只更新非空字段
}

8.2 前端确认交互

async function confirmAlarm(id) {
  await api.confirm(id);
  this.$message.success('已确认');
  this.refresh();          // 刷新当前告警列表
  alarmManager.clear();    // 清角标/停声音
}

幂等性：确认/处理接口要能被重复调用而不出错（重复点、网络重试）。用“设置目标状态”而非“状态+1”即天然幂等。

九、兜底补偿：僵尸告警与数据自愈

实时系统一定要考虑异常路径，否则数据会失真：

9.1 两类典型脏数据

9.2 兜底任务（定时扫描自愈）

/** 每分钟跑一次，修复未闭合告警 */
public void fallback() {
    Date now = new Date();
    for (Alarm a : mapper.selectAllUnfinished()) {
        long elapsedMin = (now.getTime() - a.getStartTime().getTime()) / 60000;

        // 1) 超时未确认 → 标记
        if (a.getHandleStatus() == STATUS_PENDING && elapsedMin >= TIMEOUT_MIN) {
            mapper.markTimeout(a.getId());
        }

        // 2) 僵尸告警 → 若数据源已恢复正常/持续离线超阈值，则强制关闭
        Boolean live = readCurrentState(a);           // 从缓存/实时源读当前状态
        if (Boolean.FALSE.equals(live)) {
            mapper.forceClose(a.getId(), now, "点位已恢复，兜底关闭");
        } else if (live == null && offlineTooLong(a)) {
            mapper.forceClose(a.getId(), now, "设备持续离线，兜底关闭");
        }
    }
}

9.3 防误关的两个细节

• 离线要“持续超阈值”才关：用一个 Map 记录，避免瞬时网络抖动误关正常告警。
• 区分“离线”与“恢复”：数据源读不到（null）= 离线，读到且为正常 = 真恢复，两者处置不同。

十、关键设计要点汇总

以上即“实时设备告警”功能从数据源到界面的全链路技术详解。核心思想可提炼为三句话：采集判定用边沿、状态落库带生命周期、异常路径必有兜底；而前端则遵循只读展示 + 幂等闭环 + 恰到好处的提醒。这套模式可以直接迁移到设备监控、服务器运维告警、业务风控预警等任意实时告警场景。