gongchunyi
9 天以前 e9b4ceeea014f9d81263672f3d9c46a567c39591
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
package com.ruoyi.energymeter.job;
 
import com.ruoyi.energymeter.config.EnergyMeterProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
 
import java.util.TimeZone;
 
/**
 * 启动时以固定 JobKey/TriggerKey 注册或更新两个 Quartz 作业,重复启动不会产生重复触发器。
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class EnergyMeterSchedulerRegistrar implements ApplicationRunner {
 
    private static final String GROUP = "energyMeter";
    private static final String TIME_ZONE = "Asia/Shanghai";
 
    private final Scheduler scheduler;
    private final EnergyMeterProperties properties;
 
    @Override
    public void run(ApplicationArguments args) {
        if (!properties.isSchedulerEnabled()) {
            log.info("水电表定时任务已关闭(energy-meter.scheduler-enabled=false)");
            return;
        }
        try {
            // 清理已下线的电表整点同步作业,避免持久化 Quartz 存储里的旧触发器继续按小时触发
            removeIfExists("energyMeterElectricHourlySync", "energyMeterElectricHourlySyncTrigger");
            register("energyMeterDailySync", "energyMeterDailySyncTrigger",
                    EnergyMeterDailySyncJob.class, properties.getSyncCron(), "水电表每天08:00自动同步");
            register("energyMeterRecovery", "energyMeterRecoveryTrigger",
                    EnergyMeterRecoveryJob.class, properties.getRecoveryCron(), "水电表每10分钟恢复重试");
        } catch (Exception e) {
            log.error("注册水电表定时任务失败", e);
        }
    }
 
    private void removeIfExists(String jobName, String triggerName) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, GROUP);
        if (scheduler.checkExists(triggerKey)) {
            scheduler.unscheduleJob(triggerKey);
            log.info("已移除下线的水电表定时任务触发器 {}", triggerName);
        }
        JobKey jobKey = JobKey.jobKey(jobName, GROUP);
        if (scheduler.checkExists(jobKey)) {
            scheduler.deleteJob(jobKey);
            log.info("已移除下线的水电表定时任务 {}", jobName);
        }
    }
 
    private void register(String jobName, String triggerName, Class<? extends Job> jobClass,
                          String cron, String description) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobName, GROUP);
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, GROUP);
        if (!scheduler.checkExists(jobKey)) {
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobKey)
                    .withDescription(description)
                    .storeDurably()
                    .requestRecovery()
                    .build();
            Trigger trigger = buildTrigger(triggerKey, jobKey, cron, description);
            scheduler.scheduleJob(jobDetail, trigger);
            log.info("已注册水电表定时任务 {}({},{})", jobName, cron, TIME_ZONE);
            return;
        }
        Trigger existing = scheduler.getTrigger(triggerKey);
        boolean sameCron = existing instanceof CronTrigger cronTrigger
                && cron.equals(cronTrigger.getCronExpression());
        Trigger.TriggerState state = existing == null
                ? Trigger.TriggerState.NONE : scheduler.getTriggerState(triggerKey);
        // 版本升级后旧实例可能不认识新 Job 类而把触发器置为 ERROR,这里重建触发器使其恢复调度
        if (!sameCron || state == Trigger.TriggerState.ERROR) {
            Trigger trigger = buildTrigger(triggerKey, jobKey, cron, description);
            if (existing != null) {
                scheduler.unscheduleJob(triggerKey);
            }
            scheduler.scheduleJob(trigger);
            log.info("已重建水电表定时任务 {} 的触发器(cron={},原状态={})", jobName, cron, state);
        } else {
            log.info("水电表定时任务 {} 已存在且规则一致,跳过重复注册", jobName);
        }
    }
 
    private Trigger buildTrigger(TriggerKey triggerKey, JobKey jobKey, String cron, String description) {
        return TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .withDescription(description)
                .forJob(jobKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron)
                        .inTimeZone(TimeZone.getTimeZone(TIME_ZONE))
                        .withMisfireHandlingInstructionFireAndProceed())
                .build();
    }
}