tuqin
2026-10-29 0a3129cb06fcea6677245097715dcc6fa3de65e5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package com.ruoyi.lims.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.lims.controller.DataInterfaceController;
import com.ruoyi.lims.pojo.DataInterface;
import com.ruoyi.lims.service.DataInterfaceService;
import com.ruoyi.lims.service.LimsAlertService;
import com.ruoyi.lims.service.LimsCleanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.stereotype.Service;
 
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
 
/**
 * LIMS 定时任务入口
 *
 * 在「系统监控 → 定时任务」里配置(cron 表达式写在 sys_job 表里,不要写进注释,否则斜杠星号会提前结束注释):
 *   limsTask.autoCollect   自动采集,建议周期 5 分钟
 *   limsTask.checkAlerts   监控预警扫描,建议周期 1 分钟
 */
@Service("limsTask")
@Slf4j
public class LimsTaskService {
 
    private final DataInterfaceService diService;
    private final LimsCleanService cleanService;
    private final LimsAlertService alertService;
    private final ObjectProvider<DataInterfaceController> controllerProvider;
 
    public LimsTaskService(DataInterfaceService diService,
                           LimsCleanService cleanService,
                           LimsAlertService alertService,
                           ObjectProvider<DataInterfaceController> controllerProvider) {
        this.diService = diService;
        this.cleanService = cleanService;
        this.alertService = alertService;
        this.controllerProvider = controllerProvider;
    }
 
    /**
     * 自动采集:扫描启用自动采集的接口,逐个采集并清洗
     */
    public void autoCollect() {
        QueryWrapper<DataInterface> w = new QueryWrapper<>();
        w.eq("auto_enabled", "1").orderByAsc("id");
        List<DataInterface> list = diService.list(w);
        if (list.isEmpty()) {
            log.info("[LIMS自动采集] 没有启用自动采集的接口");
            return;
        }
        DataInterfaceController ctl = controllerProvider.getIfAvailable();
        if (ctl == null) {
            log.warn("[LIMS自动采集] 采集器未就绪,跳过");
            return;
        }
 
        int okCount = 0, failCount = 0;
        for (DataInterface di : list) {
            String cron = di.getCollectCron();
            if (cron == null || cron.trim().isEmpty()) {
                // 只开了开关没配 cron,按"每次任务都采集"处理
                log.debug("[LIMS自动采集] {} 未配置 cron,按任务周期采集", di.getInterfaceCode());
            }
            try {
                Map<String, Object> r = ctl.collectInternal(di.getId(), "auto");
                boolean ok = Boolean.TRUE.equals(r.get("ok"));
                String msg = String.valueOf(r.get("msg"));
                saveResult(di.getId(), ok, msg);
                if (ok) {
                    okCount++;
                } else {
                    failCount++;
                }
                log.info("[LIMS自动采集] {} -> {}", di.getInterfaceCode(), ok ? "成功" : ("失败:" + msg));
            } catch (Exception e) {
                failCount++;
                saveResult(di.getId(), false, "异常:" + e.getMessage());
                log.error("[LIMS自动采集] {} 异常", di.getInterfaceCode(), e);
            }
        }
        log.info("[LIMS自动采集] 完成,成功 {} 个,失败 {} 个", okCount, failCount);
 
        // 兜底:再清洗一遍所有待清洗记录
        try {
            Map<String, Object> cr = cleanService.cleanPending(200);
            log.info("[LIMS自动采集] 兜底清洗:{}", cr);
        } catch (Exception e) {
            log.warn("[LIMS自动采集] 兜底清洗失败", e);
        }
    }
 
    /**
     * 监控预警:先清洗待处理数据,再扫描所有监控项判定越限
     */
    public void checkAlerts() {
        // 1. 清洗
        try {
            Map<String, Object> cr = cleanService.cleanPending(200);
            Integer cleaned = (Integer) cr.get("cleaned");
            if (cleaned != null && cleaned > 0) {
                log.info("[LIMS监控预警] 清洗 {} 条", cleaned);
            }
        } catch (Exception e) {
            log.warn("[LIMS监控预警] 清洗失败", e);
        }
 
        // 2. 判定
        try {
            Map<String, Object> r = alertService.checkAll(500);
            Integer alerts = (Integer) r.get("alerts");
            Integer scanned = (Integer) r.get("scanned");
            if (alerts != null && alerts > 0) {
                log.warn("[LIMS监控预警] 扫描 {} 个监控项,新增告警 {} 条", scanned, alerts);
            } else {
                log.debug("[LIMS监控预警] 扫描 {} 个监控项,无新增告警", scanned);
            }
        } catch (Exception e) {
            log.error("[LIMS监控预警] 判定失败", e);
        }
    }
 
    private void saveResult(Long id, boolean ok, String msg) {
        try {
            DataInterface upd = new DataInterface();
            upd.setId(id);
            upd.setLastCollectTime(LocalDateTime.now());
            String s = LocalDateTime.now().format(DateTimeFormatter.ofPattern("MM-dd HH:mm:ss"))
                    + " " + (ok ? "成功" : "失败");
            if (msg != null && !msg.isEmpty()) {
                s += ":" + (msg.length() > 300 ? msg.substring(0, 300) : msg);
            }
            upd.setLastCollectResult(s);
            diService.updateById(upd);
        } catch (Exception ignore) {
        }
    }
}