quartz

项目上要求实现一个动态定时推送功能，用来提醒值班用户，所以尝试下使用quartz

源码地址

quartz-scheduler/quartz: Code for Quartz Scheduler (github.com)

pom引入

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

导入sql

下载源码，对应数据库的sql都在quartz-core\src\main\resources\org\quartz\impl\jdbcjobstore 挑一个导入进数据库即可

创建Quartz配置类

创建一个配置类，用于配置Quartz的相关属性。你可以指定数据源、任务调度工厂等等。以下是一个示例配置类：

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;

@Configuration
public class QuartzConfig {

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("dataSource") DataSource dataSource) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setDataSource(dataSource);
        schedulerFactoryBean.setOverwriteExistingJobs(true);
         schedulerFactoryBean.setQuartzProperties(quartzProperties());
        schedulerFactoryBean.setStartupDelay(5);
        return schedulerFactoryBean;
    }
    // 数据库用的pgsql,需要加一些属性
    private Properties quartzProperties() {
        Properties properties = new Properties();
        properties.put("org.quartz.scheduler.instanceName", "MyScheduler");
        properties.put("org.quartz.scheduler.instanceId", "AUTO");
        properties.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        properties.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");
        properties.put("org.quartz.jobStore.tablePrefix", "qrtz_");
        properties.put("org.quartz.jobStore.isClustered", "false");
        return properties;
    }
}

创建定时任务类

创建一个实现Job接口的定时任务类，例如：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // 在这里定义你的定时任务逻辑
        JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        String customParam = dataMap.getString("customParam");  // 获取自定义参数
        String name = jobExecutionContext.getJobDetail().getKey().getName(); // 获取任务名称
        System.out.println("参数：" + customParam);
        System.out.println("任务执行时间：" + new Date());
    }
}

创建动态定时任务管理器

创建一个管理动态定时任务的类，用于动态添加、删除、修改任务。这个类可以通过读取数据库或外部配置来获取任务信息，并使用SchedulerFactoryBean来动态调度任务

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class JobManager {

    @Autowired
    private Scheduler scheduler;

    public void addJob(String jobName, String jobGroup, String cronExpression,String customParam) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity(jobName, jobGroup)
                .usingJobData("customParam", customParam) // 自定义参数
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();

        scheduler.scheduleJob(jobDetail, trigger);
    }

    public void updateJob(String jobName, String jobGroup, String cronExpression,String customParam) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        CronTrigger newTrigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .usingJobData("customParam", customParam)
                .build();

        scheduler.rescheduleJob(triggerKey, newTrigger);
    }

    public void deleteJob(String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);

        scheduler.pauseTrigger(triggerKey);
        scheduler.unscheduleJob(triggerKey);
        scheduler.deleteJob(jobKey);
    }
    
    public void addOneTimeJob(String jobName, String jobGroup, Date startTime, String customParam) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();

        // 创建一个只执行一次的SimpleTrigger
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroup)
                .startAt(startTime)
                .build();

        // 创建JobDetail，并将自定义参数传递给Job
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity(jobName, jobGroup)
                .usingJobData("customParam", customParam)
                .build();

        // 将JobDetail和Trigger关联，然后将任务添加到调度器
        scheduler.scheduleJob(jobDetail, trigger);
    }
}

创建接口动态修改

import com.imsa.backend.schedule.JobManager;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class JobController {

    @Autowired
    private JobManager jobManager;

    @GetMapping("/addJob")
    public String addJob(@RequestParam String jobName, @RequestParam String cronExpression, @RequestParam String customParam) throws SchedulerException {
        jobManager.addJob(jobName, "default", cronExpression, customParam);
        return "Job added successfully";
    }

    @GetMapping("/updateJob")
    public String updateJob(@RequestParam String jobName, @RequestParam String cronExpression, @RequestParam String customParam) throws SchedulerException {
        jobManager.updateJob(jobName, "default", cronExpression, customParam);
        return "Job updated successfully";
    }

    @GetMapping("/deleteJob")
    public String deleteJob(@RequestParam String jobName) throws SchedulerException {
        jobManager.deleteJob(jobName, "default");
        return "Job deleted successfully";
    }
}

完事