Springboot quartz动态定时任务

在Spring Boot中使用Quartz实现动态定时任务可以分为以下几个步骤：

1. 添加依赖

在`pom.xml`文件中添加Quartz依赖：

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

2. 配置Quartz

在`application.properties`中添加Quartz的配置：

# 配置Quartz的JobStore
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = false
 
# 配置Quartz的线程池
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
 
# 配置Quartz的数据源
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = root
org.quartz.dataSource.myDS.maxConnections = 5
org.quartz.dataSource.myDS.validationQuery = select 0

3. 创建Job

创建一个继承`org.quartz.Job`接口的类，用于执行定时任务的逻辑代码。

public class MyJob implements Job {
 
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 执行定时任务逻辑
    }
}

4. 创建Trigger

创建一个继承`org.quartz.Trigger`接口的类，用于设置定时任务的触发器，例如定时任务的执行时间、执行频率等。

public class MyTrigger implements Trigger {
 
    @Override
    public Date getNextFireTime() {
        // 设置下一次执行时间
        return null;
    }
 
    @Override
    public Date getPreviousFireTime() {
        // 获取上一次执行时间
        return null;
    }
 
    @Override
    public void setNextFireTime(Date nextFireTime) {
        // 设置下一次执行时间
    }
 
    @Override
    public void setPreviousFireTime(Date previousFireTime) {
        // 设置上一次执行时间
    }
 
    // 其他方法省略...
}

5. 创建Scheduler

创建一个`org.quartz.Scheduler`实例，用于管理定时任务的执行。

public class MyScheduler {
 
    private Scheduler scheduler;
 
    public MyScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }
 
    // 添加定时任务
    public void addJob(JobDetail jobDetail, Trigger trigger) throws SchedulerException {
        scheduler.scheduleJob(jobDetail, trigger);
    }
 
    // 删除定时任务
    public void deleteJob(JobKey jobKey) throws SchedulerException {
        scheduler.deleteJob(jobKey);
    }
 
    // 修改定时任务
    public void updateJob(TriggerKey triggerKey, Trigger newTrigger) throws SchedulerException {
        scheduler.rescheduleJob(triggerKey, newTrigger);
    }
 
    // 启动定时任务
    public void start() throws SchedulerException {
        scheduler.start();
    }
 
    // 关闭定时任务
    public void shutdown() throws SchedulerException {
        scheduler.shutdown();
    }
}

6. 创建动态定时任务

创建一个类，用于动态添加、删除、修改定时任务。

@Service
public class DynamicJobService {
 
    @Autowired
    private Scheduler scheduler;
 
    // 添加定时任务
    public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class<? extends Job> jobClass, String cronExpression) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName).withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();
 
        scheduler.scheduleJob(jobDetail, trigger);
    }
 
    // 删除定时任务
    public void deleteJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) throws SchedulerException {
        scheduler.pauseTrigger(new TriggerKey(triggerName, triggerGroupName));
        scheduler.unscheduleJob(new TriggerKey(triggerName, triggerGroupName));
        scheduler.deleteJob(new JobKey(jobName, jobGroupName));
    }
 
    // 修改定时任务
    public void updateJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cronExpression) throws SchedulerException {
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(new TriggerKey(triggerName, triggerGroupName));
        trigger = trigger.getTriggerBuilder().withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();
 
        scheduler.rescheduleJob(new TriggerKey(triggerName, triggerGroupName), trigger);
    }
 
    // 暂停定时任务
    public void pauseJob(String jobName, String jobGroupName) throws SchedulerException {
        scheduler.pauseJob(new JobKey(jobName, jobGroupName));
    }
 
    // 恢复定时任务
    public void resumeJob(String jobName, String jobGroupName) throws SchedulerException {
        scheduler.resumeJob(new JobKey(jobName, jobGroupName));
    }
}

7. 测试

@Service
public class TestService {
 
    @Autowired
    private DynamicJobService dynamicJobService;
 
    public void test() throws SchedulerException {
        // 添加定时任务
        dynamicJobService.addJob("job1", "group1", "trigger1", "group1", MyJob.class, "0/5 * * * * ?");
 
        // 修改定时任务
        dynamicJobService.updateJob("job1", "group1", "trigger1", "group1", "0/10 * * * * ?");
 
        // 暂停定时任务
        dynamicJobService.pauseJob("job1", "group1");
 
        // 恢复定时任务
        dynamicJobService.resumeJob("job1", "group1");
 
        // 删除定时任务
        dynamicJobService.deleteJob("job1", "group1", "trigger1", "group1");
    }
}

以上就是使用Spring Boot和Quartz实现动态定时任务的步骤。