Quartz任务管理工具类

1.maven坐标

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

2.配置

@Bean
public HashMapper<Object, String, Object> hashMapper(){
    return new Jackson2HashMapper(true);
}

SpringContextUtil工具类：普通Java类中获取Bean工具类（SpringBoot）-CSDN博客

3.工具类

import com.anxko.automation.constant.enums.JobMisfirePolicyEnum;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.data.redis.hash.HashMapper;

import java.util.List;
import java.util.Map;

@Slf4j
public class QuartzManagerUtil {

    public static final Scheduler scheduler = SpringContextUtil.getBean(Scheduler.class);

    public static final HashMapper hashMapper = SpringContextUtil.getBean(HashMapper.class);

    /**
     * 添加job（更新）
     * @param jobName job名称
     * @param jobGroup job分组
     * @param jobClass 执行class
     * @param jobRemark job描述
     * @param param 参数
     * @return 是否成功
     */
    public static boolean addJob(String jobName, String jobGroup, String jobClass, String jobRemark, Object param){
        try {
            return addJob(jobName, jobGroup, (Class<? extends Job>) Class.forName(jobClass), jobRemark, param);
        }catch (Exception e){
            log.error("添加Job失败！", e);
            return false;
        }
    }

    public static boolean addJob(String jobName, String jobGroup, Class<? extends Job> jobClass, String jobRemark, Object param){
        try {
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobName, jobGroup)
                    .withDescription(jobRemark)
                    .usingJobData(instanceofJobDataMap(param))
                    .build();
            scheduler.addJob(jobDetail, true, true);
            return true;
        }catch (SchedulerException e){
            log.error("添加Job失败！", e);
            return false;
        }
    }

    /**
     * 添加触发器
     * @param jobName job名称
     * @param jobGroup job分组
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器分组
     * @param triggerRemark 触发器备注
     * @param cron cron表达式
     * @param policyEnum 执行策略
     * @param param 参数
     * @return 是否成功
     */
    public static boolean addTrigger(String jobName, String jobGroup, String triggerName, String triggerGroup, String triggerRemark, String cron, JobMisfirePolicyEnum policyEnum, Object param){
        try {
            if (!CronExpression.isValidExpression(cron)){
                return false;
            }
            Trigger trigger = createCronTrigger(
                    jobName,
                    jobGroup,
                    triggerName,
                    triggerGroup,
                    triggerRemark,
                    cron,
                    policyEnum,
                    param,
                    true
            );
            scheduler.scheduleJob(trigger);
            return true;
        }catch (SchedulerException e){
            log.error("添加Trigger失败！", e);
            return false;
        }
    }

    /**
     * 更新触发器
     * @param name 旧触发器名称
     * @param group 旧触发器分组
     * @param triggerName 新触发器名称
     * @param triggerGroup 新触发器分组
     * @param triggerRemark 新触发器备注
     * @param cron cron表达式
     * @param policyEnum 执行策略
     * @param param 参数
     * @return 是否成功
     */
    public static boolean updateTrigger(String name, String group, String triggerName, String triggerGroup, String triggerRemark, String cron, JobMisfirePolicyEnum policyEnum, Object param){
        try {
            if (!CronExpression.isValidExpression(cron)){
                return false;
            }
            Trigger trigger = createCronTrigger(triggerName, triggerGroup, triggerRemark, cron, policyEnum, param);
            scheduler.rescheduleJob(TriggerKey.triggerKey(name, group), trigger);
            return true;
        }catch (SchedulerException e){
            log.error("更新Trigger失败！", e);
            return false;
        }
    }


    /**
     * 创建Cron触发器
     * @param jobName job名称
     * @param jobGroup job分组
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器分组
     * @param triggerRemark 触发器描述
     * @param cron cron表达式
     * @param policyEnum 执行策略
     * @param param 参数
     * @param isForJob 是否关联job
     * @return Trigger实例对象
     */
    public static Trigger createCronTrigger(String jobName, String jobGroup, String triggerName, String triggerGroup, String triggerRemark, String cron, JobMisfirePolicyEnum policyEnum, Object param, boolean isForJob){
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        switch (policyEnum){
            case EXECUTE_IMMEDIATELY -> scheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
            case EXECUTE_ONCE -> scheduleBuilder.withMisfireHandlingInstructionFireAndProceed();
            case ABANDON_EXECUTION -> scheduleBuilder.withMisfireHandlingInstructionDoNothing();
        }
        TriggerBuilder<CronTrigger> builder = TriggerBuilder.newTrigger()
                .withIdentity(triggerName, triggerGroup)
                .withSchedule(scheduleBuilder)
                .withDescription(triggerRemark)
                .usingJobData(instanceofJobDataMap(param));
        if (isForJob) builder.forJob(jobName, jobGroup);
        return builder.build();
    }

    public static Trigger createCronTrigger(String triggerName, String triggerGroup, String triggerRemark, String cron, JobMisfirePolicyEnum policyEnum, Object param){
        return createCronTrigger(null, null, triggerName, triggerGroup, triggerRemark, cron, policyEnum, param, false);
    }

    public static JobDataMap instanceofJobDataMap(Object param){
        if (param instanceof JobDataMap){
            return (JobDataMap) param;
        }
        if (param instanceof Map<?,?>){
            return new JobDataMap((Map<?, ?>) param);
        }
        return new JobDataMap(hashMapper.toHash(param));
    }

    /**
     * 触发一次
     * @param jobName job名称
     * @param jobGroup job分组
     * @param param 参数
     * @return 是否成功
     */
    public static boolean triggerJob(String jobName, String jobGroup, Object param){
        try {
            scheduler.triggerJob(JobKey.jobKey(jobName, jobGroup), instanceofJobDataMap(param));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    public static boolean triggerJob(String jobName, String jobGroup){
        try {
            scheduler.triggerJob(JobKey.jobKey(jobName, jobGroup));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 暂停job
     */
    public static boolean pauseJob(String jobName, String jobGroup){
        try {
            scheduler.pauseJob(JobKey.jobKey(jobName, jobGroup));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 暂停匹配的job
     */
    public static boolean pauseJobs(GroupMatcher<JobKey> groupMatcher){
        try {
            scheduler.pauseJobs(groupMatcher);
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 暂停所有任务
     */
    public static boolean pauseAll(){
        try {
            scheduler.pauseAll();
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 恢复job
     */
    public static boolean resumeJob(String jobName, String jobGroup){
        try {
            scheduler.resumeJob(JobKey.jobKey(jobName, jobGroup));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 恢复匹配的job
     */
    public static boolean resumeJobs(GroupMatcher<JobKey> groupMatcher){
        try {
            scheduler.resumeJobs(groupMatcher);
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 删除job
     */
    public static boolean deleteJob(String jobName, String jobGroup){
        try {
            return scheduler.deleteJob(JobKey.jobKey(jobName, jobGroup));
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 删除多个job
     */
    public static boolean deleteJobs(List<JobKey> jobKeys){
        try {
            return scheduler.deleteJobs(jobKeys);
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 暂停触发器
     */
    public static boolean pauseTrigger(String triggerName, String triggerGroup){
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(triggerName, triggerGroup));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 暂停匹配的触发器
     */
    public static boolean pauseTriggers(GroupMatcher<TriggerKey> groupMatcher){
        try {
            scheduler.pauseTriggers(groupMatcher);
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 恢复触发器
     */
    public static boolean resumeTrigger(String triggerName, String triggerGroup){
        try {
            scheduler.resumeTrigger(TriggerKey.triggerKey(triggerName, triggerGroup));
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 恢复匹配的触发器
     */
    public static boolean resumeTriggers(GroupMatcher<TriggerKey> groupMatcher){
        try {
            scheduler.resumeTriggers(groupMatcher);
            return true;
        }catch (SchedulerException e){
            return false;
        }
    }

    /**
     * 从map转为实例对象
     * @param map map
     * @param cls 实例class类型
     * @return 实例对象
     * @param <T> 类型
     */
    public static <T> T mapToObject(Map<String, Object> map, Class<T> cls){
        return cls.cast(hashMapper.fromHash(map));
    }
}