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

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

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

    private final map<string, boolean> 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;
    }
}

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:
            // 状态未变，忽略
    }
}

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

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);
}

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;
}

public class alarmlevel {
    public static final int info = 1, warn = 2, serious = 3, fatal = 4;

    private static final map<string, integer> map = new hashmap<>();
    static {
        map.put("急停", fatal);
        map.put("高压报警", serious);
        map.put("低流量报警", warn);
        // ...
    }
    /** 未命中默认按严重处理，保证"漏配也不漏报" */
    public static int of(string name) {
        return map.getordefault(name, serious);
    }
}

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='设备告警表';

-- 查未闭合（去重判断）
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;

@restcontroller
@requestmapping("/alarm")
public class alarmcontroller {

    @autowired private alarmservice service;

    /** 前端轮询：当前所有未恢复告警 */
    @getmapping("/current")
    public result<list<alarm>> current() {
        return result.ok(service.listunfinished());
    }

    /** 确认（幂等） */
    @postmapping("/confirm/{id}")
    public result<void> confirm(@pathvariable long id) {
        service.confirm(id, currentuser());
        return result.ok();
    }

    /** 处理闭环 */
    @postmapping("/handle")
    public result<void> handle(@requestparam long id,
                               @requestparam(required = false) string remark) {
        service.handle(id, remark, currentuser());
        return result.ok();
    }
}

class alarmpoller {
  constructor(fetchfn, { interval = 5000, onnew } = {}) {
    this.fetchfn = fetchfn;      // 返回 promise<alarm[]>
    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();

// 前端
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));

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);

poller.onnew = (alarms) => {
  alarms.foreach(a => alarmmanager.alarm({
    title: a.devicename,
    body: a.alarmname,
    level: maplevel(a.alarmlevel),
    tag: 'alarm-' + a.id,        // 去重，防刷屏
  }));
};

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

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);      // 只更新非空字段
}

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

/** 每分钟跑一次，修复未闭合告警 */
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, "设备持续离线，兜底关闭");
        }
    }
}