程序员の奇妙冒险

返回
Spring Boot Spring Boot
2025-04-09 11:44 阅读:85 评论:0

在Spring boot中 封装 Quartz

QuartzManager分组版 QuartzManager精简版 实践版本 定时器中注入Spring Bean问题 使用 注入 Scheduler 代替 new 替换掉以下手动创建 常用方法 获取全部真正执行的任务

QuartzManager分组版

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
142
143
144
145
146
147
148
149
package net.fjyl.market.quartz;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
 
/**
 * @author caizw
 * @date 2018-08-13
 * @description: 定时任务
 */
public class QuartzManager {
 
    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
 
    /**
     * @Description: 添加一个定时任务
     *
     * @param jobName 任务名
     * @param jobGroupName  任务组名
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass  任务
     * @param cron   时间设置，参考quartz说明文档
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static void addJob(String jobName, String jobGroupName,
                              String triggerName, String triggerGroupName, Class jobClass, String cron) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            // 任务名，任务组，任务执行类
            JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
 
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
 
            // 调度容器设置JobDetail和Trigger
            sched.scheduleJob(jobDetail, trigger);
 
            // 启动
            if (!sched.isShutdown()) {
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    /**
     * @Description: 修改一个任务的触发时间
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     * @param cron   时间设置，参考quartz说明文档
     */
    public static void modifyJobTime(String jobName,
                                     String jobGroupName, String triggerName, String triggerGroupName, String cron) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }
 
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                /** 方式一 ：调用 rescheduleJob 开始 */
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间
                sched.rescheduleJob(triggerKey, trigger);
                /** 方式一 ：调用 rescheduleJob 结束 */
 
                /** 方式二：先删除，然后在创建一个新的Job  */
                //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
                //Class<? extends Job> jobClass = jobDetail.getJobClass();
                //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
                /** 方式二 ：先删除，然后在创建一个新的Job */
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    /**
     * @Description: 移除一个任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public static void removeJob(String jobName, String jobGroupName,
                                 String triggerName, String triggerGroupName) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
 
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
 
            sched.pauseTrigger(triggerKey);// 停止触发器
            sched.unscheduleJob(triggerKey);// 移除触发器
            sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    /**
     * @Description:启动所有定时任务
     */
    public static void startJobs() {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            sched.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    /**
     * @Description:关闭所有定时任务
     */
    public static void shutdownJobs() {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            if (!sched.isShutdown()) {
                sched.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

QuartzManager精简版

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
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.util.Date;
 
/**
 * @author caizw
 * @date 2018-08-13
 * @description: 定时任务
 */
public class QuartzManager {
 
    private static Logger logger = LoggerFactory.getLogger(QuartzManager.class);
 
    private static Scheduler scheduler;
 
    static {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        try {
            scheduler = schedulerFactory.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
 
    private static void addJob(String jobKey, Class jobClass, String cron, Date date) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey).build();
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        Trigger trigger = null;
        if (cron != null) {
            trigger = TriggerBuilder.newTrigger().withIdentity(jobKey).withSchedule(scheduleBuilder).build();
        } else if (date != null) {
            trigger = TriggerBuilder.newTrigger().startAt(date).withIdentity(jobKey).build();
        } else {
            throw new RuntimeException("未指定定时任务何时启动");
        }
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }
 
    /**
     * @param jobKey   定时任务 key
     * @param jobClass 定时执行的实例对象
     * @param date     定时启动任务，传入时间实例对象
     * @throws SchedulerException
     */
    public static void addJobByDate(String jobKey, Class jobClass, Date date) throws SchedulerException {
        logger.info("date启动定时任务");
        addJob(jobKey, jobClass, null, date);
    }
 
    /**
     * @param jobKey   定时任务 key
     * @param jobClass 定时执行的实例对象
     * @param cron     quartz cron表达式
     * @throws SchedulerException
     */
    public static void addJobByCron(String jobKey, Class jobClass, String cron) throws SchedulerException {
        logger.info("cron启动定时任务");
        addJob(jobKey, jobClass, cron, null);
    }
 
    /**
     * 删除定时任务
     *
     * @param jobKey
     */
    public static void deleteJob(String jobKey) {
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobKey));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey));
            scheduler.deleteJob(JobKey.jobKey(jobKey));
        } catch (Exception e) {
            logger.info("删除定时任务失败");
        }
    }
 
    /**
     * @Description:关闭所有定时任务
     */
    public static void shutdownJobs() {
        logger.info("关闭所有定时任务");
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

实践版本

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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
 
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
 
/**
 * @author caizw
 * @date 2018-08-13
 * @description: 定时任务
 */
@Slf4j
public class QuartzManager {
 
    private static Scheduler scheduler;
 
    public static void setScheduler(Scheduler schedule) {
        QuartzManager.scheduler = schedule;
    }
 
    private static void addJob(String jobKey, Class jobClass, String cron, Date date, Integer interval, boolean nowStart) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey).build();
        Trigger trigger;
        if (StringUtils.isNotBlank(cron)) {
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
            trigger = TriggerBuilder.newTrigger().withIdentity(jobKey).withSchedule(scheduleBuilder).build();
        } else if (date != null) {
            if (interval == null || interval == 0) {
                // 只执行一次
                Date nowTime = new Date();
                if (date.getTime() <= nowTime.getTime()) {
                    trigger = TriggerBuilder.newTrigger().startNow().withIdentity(jobKey).build();
                } else {
                    trigger = TriggerBuilder.newTrigger().startAt(date).withIdentity(jobKey).build();
                }
            } else {
                Date nowTime = new Date();
                if (date.getTime() <= nowTime.getTime() && nowStart) {
                    trigger = TriggerBuilder.newTrigger()
                            // 立即生效
                            .startNow()
                            .withIdentity(jobKey)
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                    // 间隔 interval 秒执行一次
                                    .withIntervalInSeconds(interval)
                                    .repeatForever()//永远重复执行
                            ).build();
                } else {
                    trigger = TriggerBuilder.newTrigger()
                            // 在指定日期生效
                            .startAt(date)
                            .withIdentity(jobKey)
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                    // 间隔 interval 秒执行一次
                                    .withIntervalInSeconds(interval)
                                    .repeatForever()//永远重复执行
                            ).build();
                }
 
 
            }
        } else {
            throw new RuntimeException("未指定定时任务何时启动");
        }
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
        scheduler.scheduleJob(jobDetail, trigger);
    }
 
    /**
     * @param jobKey   定时任务 key
     * @param jobClass 定时执行的实例对象，此对象需继承Job接口
     * @param date     定时启动任务，传入时间实例对象
     * @param nowStart 当前启动(条件满足后是否立即执行任务)
     * @throws SchedulerException
     */
    public static void addJobByDate(String jobKey, Class jobClass, Date date, boolean nowStart) throws SchedulerException {
        log.info("date启动定时任务");
        addJob(jobKey, jobClass, null, date, null, nowStart);
    }
 
    /**
     * @param jobKey   定时任务 key
     * @param jobClass 定时执行的实例对象，此对象需继承Job接口
     * @param date     定时启动任务，传入时间实例对象
     * @param interval 每间隔多少秒执行， 单位秒
     * @param nowStart 当前启动(条件满足后是否立即执行任务)
     * @throws SchedulerException
     */
    public static void addJobByDate(String jobKey, Class jobClass, Date date, Integer interval, boolean nowStart) throws SchedulerException {
        log.info("date启动间隔定时任务");
        addJob(jobKey, jobClass, null, date, interval, nowStart);
    }
 
    /**
     * @param jobKey   定时任务 key
     * @param jobClass 定时执行的实例对象，此对象需继承Job接口
     * @param cron     quartz cron表达式
     * @param nowStart 当前启动(条件满足后是否立即执行任务)
     * @throws SchedulerException
     */
    public static void addJobByCron(String jobKey, Class jobClass, String cron, boolean nowStart) throws SchedulerException {
        log.info("cron启动定时任务");
        addJob(jobKey, jobClass, cron, null, null, nowStart);
    }
 
    /**
     * 获取所有任务key
     */
    public static Set<JobKey> getJobKeySet() {
        try {
            return scheduler.getJobKeys(GroupMatcher.anyGroup());
        } catch (Exception e) {
            log.error("获取所有任务key失败：" + e.getMessage(), e);
        }
        return new HashSet<>();
    }
 
    /**
     * 删除定时任务
     *
     * @param jobKey
     */
    public static void deleteJob(String jobKey) {
        log.info("删除定时任务, keyName ===>【{}】", jobKey);
        if (StringUtils.isBlank(jobKey)) {
            return;
        }
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobKey));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey));
            scheduler.interrupt(JobKey.jobKey(jobKey, null));
            scheduler.deleteJob(JobKey.jobKey(jobKey));
        } catch (Exception e) {
            log.error("删除定时任务失败：" + e.getMessage(), e);
            throw new RuntimeException(e);
        }
    }
 
    /**
     * 关闭所有定时任务
     */
    public static void shutdownJobs() {
        log.info("关闭所有定时任务");
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

定时器中注入Spring Bean问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;
 
/**
 * @author caizw
 * @date 2018-08-13
 * @description: 定时器工厂
 */
@Component
public class MyJobFactory extends AdaptableJobFactory {
 
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
 
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}
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
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
 
/**
 * @author caizw
 * @date 2018-08-13
 * @description: 配置定时器
 */
@Configuration
public class QuartzConfig {
 
    @Autowired
    private MyJobFactory myJobFactory;
 
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(myJobFactory);
        return schedulerFactoryBean;
    }
 
    @Bean
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }
 
 
}

使用 注入 Scheduler 代替 new

1
2
@Autowired
private Scheduler scheduler;
  • 替换掉以下手动创建
1
2
3
4
5
6
7
8
static {
    SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    try {
        scheduler = schedulerFactory.getScheduler();
    } catch (SchedulerException e) {
        e.printStackTrace();
    }
}

常用方法

获取全部真正执行的任务

1
2
3
4
public Set<JobKey> getJob() throws SchedulerException {
    Set<JobKey> jobKeySet = scheduler.getJobKeys(GroupMatcher.anyGroup());
    return jobKeySet;
}
评论 (0)
暂无评论 来抢沙发吧~

目录

SpringWonderland

探索 Spring 生态的奇妙世界

2025-04-09 11:44

我的标签

MySQL(31) Linux(20) Java(20) Spring Boot(18) Python(18) Nginx(16) HarmonyOS NEXT(12) Vue(9) 人工智能AI(8) Docker(6) MacOS(5) 多租户(4) POI(4) MyBatis(4) IntelliJ IDEA(4) Hadoop(4) ElementUI(4) 向量数据库(3) Redis(3) Git(3) ESP32(3) Beetl(3) 物联网(2) 小程序(2) Visual Studio Code(2) Spring Cloud(2) Spring AI Alibaba(2) PostgreSQL(2) Node(2) MongoDB(2) JavaScript(2) FastAPI(2) CSS(2) 工具(1) UV(1) Spring(1) Sharding-JDBC(1) Phoenix(1) Oracle(1) Nexus(1) Nacos(1) Maven(1) Markdown(1) Kafka(1) jQuery(1) Hive(1) Hibernate(1) ESP-IDF(1) Electron(1) Django(1) Codex(1) Bootstrap(1) BeetlSQL(1)

随笔分类

物联网 (1)
beetl (3)
beetlSQL (2)
Docker (4)
Git (3)
Hibernate (1)
IntelliJ IDEA (4)
Java (9)
MongoDB (1)
MySQL (4)
Nginx (15)
PostgreSQL (2)
Python (17)
Spring Boot (13)
Visual Studio Code (2)
多租户 (4)
分库分表 (1)
服务器运维 (25)
鸿蒙应用开发 (11)
前端 (5)
人工智能AI (5)
微服务 (2)
我开源的项目 (2)