Spring boot（三）使用quartz实现定时任务

朴灿烈づ我的快乐病毒、 2023-01-03 11:30 211阅读 0赞

#### 引入依赖 ####

*  pom.xml依赖引入

<dependency>
        <groupId>org.quartz-scheduler</groupId>
    	<artifactId>quartz</artifactId>
    </dependency>
    <dependency>
       <groupId>org.quartz-scheduler</groupId>
       <artifactId>quartz-jobs</artifactId>
    </dependency>

#### 创建一个定时任务类 ####

*  实现类实现 **Job** 类
 *  类的第一行 com.xf.mall.task 为该类的完全限定名（根据自己定义的类而定）
 *  完全限定名 在后面设置定时器时需要使用

package com.xf.mall.task;
    
    import cn.hutool.core.date.DateUtil
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    @Slf4j
    public class CountTask implements Job { 
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
    
            log.info("定时任务开始------");
    
            log.info("业务逻辑:"+ DateUtil.date());
    
            log.info("定时任务结束------");
    
        }
    }

#### 定义一个定时任务参数接收对象 ####

*  可根据业务需求定义更对的参数，并存储在数据库中，存在多个定时器方便管理和设置

@Data
    public class TaskInfo implements Serializable { 
        private static final long serialVersionUID = -8054692082716173379L;
        
        /** * 任务名称 */
        private String jobName;
        /** * 任务分组 */
        private String jobGroup;
    
        /** * 任务描述 */
        private String jobDescription;
        /** * 任务表达式 */
        private String cronExpression;
        /** * 创建时间 */
        private String createTime;
        
    }

#### 定义定时任务接口类 ####

*  定义操作定时任务的相关实现方法

public interface TaskService { 
    
        //添加任务
        void addTask(TaskInfo taskInfo) throws SchedulerException;
    
        //修改任务
        void editTask(TaskInfo taskInfo);
    
        //删除任务
        void deleteJob(String jobName, String jobGroup);
    
        //暂停任务
        void pauseJob(String jobName, String jobGroup);
    
        //恢复任务
        void resumeJob(String jobName, String jobGroup);
    }

#### 实现操作定时任务相关方法 ####

@Slf4j
    @Service
    public class TaskServiceImpl implements TaskService { 
    
        @Autowired
        private Scheduler scheduler;
    
        /** * 添加定时任务 * @param taskInfo 数据对象 */
        @Override
        public void addTask(TaskInfo taskInfo)  { 
    
            String jobName = taskInfo.getJobName(); //任务名称（完全限定名）
            String jobGroup =taskInfo.getJobGroup(); //任务分组
            String cronExpression =taskInfo.getCronExpression(); //任务表达式
            String jobDescription = taskInfo.getJobDescription(); //任务描述
            String createTime = DateUtil.formatTime(DateUtil.date()); //当前时间
    
            try { 
                //判断任务是否存在
                if(existJob(taskInfo.getJobName(),taskInfo.getJobGroup())){ 
                    log.info("该定时任务已存在");
                    throw  new SchedulerException("该定时任务已存在");
                }
                //构建触发器
                TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
                //构建任务
                JobKey jobKey=new JobKey(jobName,jobGroup);
    
                //构建时间生成器
                CronScheduleBuilder scheduleBuilder=CronScheduleBuilder.cronSchedule(cronExpression)
                        .withMisfireHandlingInstructionDoNothing();
                //构建时间触发器
                CronTrigger cronTrigger=TriggerBuilder.newTrigger()
                        .withIdentity(triggerKey).withDescription(createTime)
                        .withSchedule(scheduleBuilder).build();
                //加载定时任务对象
                Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(jobName);
                //创建任务
                JobDetail jobDetail=JobBuilder.newJob(clazz).withIdentity(jobKey)
                        .withDescription(jobDescription).build();
                //加入任务
                scheduler.scheduleJob(jobDetail,cronTrigger);
            }
            catch (Exception e){ 
                LOGGER.info("保存定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
                new Exception("类名不存在或执行表达式错误");
            }
        }
    
        /** * 修改定时任务 * @param taskInfo 数据对象 */
        @Override
        public void editTask(TaskInfo taskInfo) { 
    
            String jobName = taskInfo.getJobName();
            String jobGroup =taskInfo.getJobGroup();
            String cronExpression =taskInfo.getCronExpression();
            String jobDescription = taskInfo.getJobDescription();
            String createTime = DateUtil.formatTime(DateUtil.date());
    
            try { 
            if(!existJob(taskInfo.getJobName(),taskInfo.getJobGroup())){ 
                log.info("该定时任务不存在");
                throw  new SchedulerException("该定时任务不存在");
            }
            TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
            JobKey jobKey=new JobKey(jobName,jobGroup);
    
            CronScheduleBuilder scheduleBuilder=CronScheduleBuilder.cronSchedule(cronExpression)
                    .withMisfireHandlingInstructionDoNothing();
    
            CronTrigger cronTrigger=TriggerBuilder.newTrigger()
                    .withIdentity(triggerKey).withDescription(createTime)
                    .withSchedule(scheduleBuilder).build();
    
            //获取定时任务
            JobDetail jobDetail=scheduler.getJobDetail(jobKey);
            jobDetail.getJobBuilder()
                    .withDescription(jobDescription);
            //重新设置触发器
            HashSet<Trigger> hashSet=new HashSet<>();
            hashSet.add(cronTrigger);
    
            scheduler.scheduleJob(jobDetail,hashSet,true);
    
            }catch (Exception e){ 
                LOGGER.info("修改定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
                new Exception("类名不存在或执行表达式错误");
            }
    
        }
    
        /** * 删除定时任务 * @param jobName 任务名字（完全限定名） * @param jobGroup 任务分组 */
        @Override
        public void deleteJob(String jobName, String jobGroup) { 
            //创建触发器
            TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
            //创建定时任务
            JobKey jobKey =new JobKey(jobName,jobGroup);
            try { 
                if(existJob(jobName,jobGroup)){ 
                    //暂停触发器
                    scheduler.pauseTrigger(triggerKey);
                    //移除触发器
                    scheduler.unscheduleJob(triggerKey);
                    //删除定时任务
                    scheduler.deleteJob(jobKey);
                }
            }catch (Exception e){ 
                LOGGER.info("删除定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
                new Exception("类名不存在或执行表达式错误");
            }
    
        }
    
        /** * 暂停定时任务 * @param jobName 任务名字（完全限定名） * @param jobGroup 任务分组 */
        @Override
        public void pauseJob(String jobName, String jobGroup) { 
            //创建触发器
            TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
            //创建定时任务
            JobKey jobKey =new JobKey(jobName,jobGroup);
            try { 
                if(existJob(jobName,jobGroup)){ 
                    //暂停触发器
                    scheduler.pauseTrigger(triggerKey);
                    //删除定时任务
                    scheduler.pauseJob(jobKey);
                }
            }catch (Exception e){ 
                LOGGER.info("暂停定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
                new Exception("类名不存在或执行表达式错误");
            }
        }
    
        /** * 恢复定时任务 * @param jobName 任务名字（完全限定名） * @param jobGroup 任务分组 */
        @Override
        public void resumeJob(String jobName, String jobGroup) { 
            //创建触发器
            TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
            //创建定时任务
            JobKey jobKey =new JobKey(jobName,jobGroup);
            try { 
                if(existJob(jobName,jobGroup)){ 
                    //暂停触发器
                    scheduler.resumeTrigger(triggerKey);
                    //删除定时任务
                    scheduler.resumeJob(jobKey);
                }
            }catch (Exception e){ 
                LOGGER.info("暂停定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
                new Exception("类名不存在或执行表达式错误");
            }
    
        }
    
        /** * 校验定时任务是否已存在 * @param jobName * @param jobGroup * @return * @throws SchedulerException */
        private boolean existJob(String jobName, String jobGroup) throws SchedulerException { 
    
            TriggerKey triggerKey=new TriggerKey(jobName,jobGroup);
    
            return scheduler.checkExists(triggerKey);
        }
    }

#### 接口类定义 ####

*  简单的接口定义，主要用于demo的接口测试。需根据实际业务需求进行字段校验等操作。

/** * 定时任务控制器 */
    @RestController
    @RequestMapping("task")
    public class TaskController { 
    
    	@Autowired
    	private TaskService taskService;
    
    	/** * 添加定时任务 * @param info 数据对象 * @throws SchedulerException */
    	@PostMapping("/add")
    	@ResponseBody
    	public void addTask( TaskInfo info) throws SchedulerException { 
    		taskService.addTask(info);
    	}
    
    	/** * 修改定时任务 * @param info 数据对象 */
    	@PostMapping("/edit")
    	@ResponseBody
    	public void editTask( TaskInfo info)  { 
    		taskService.editTask(info);
    	}
    
    	/** * 暂停定时任务 * @param jobName 任务名称（完全限定名） * @param jobGroup 任务分组 */
    	@PostMapping("/pauseJob")
    	@ResponseBody
    	public void pauseJob( String jobName,String jobGroup) { 
    		taskService.pauseJob(jobName,jobGroup);
    	}
    
    	/** * 恢复定时任务 * @param jobName 任务名称（完全限定名） * @param jobGroup 任务分组 */
    	@PostMapping("/resumeJob")
    	@ResponseBody
    	public void resumeJob( String jobName,String jobGroup) { 
    		taskService.resumeJob(jobName,jobGroup);
    	}
    
    	/** * 删除定时任务 * @param jobName 任务名称（完全限定名） * @param jobGroup 任务分组 */
    	@PostMapping("/deleteJob")
    	@ResponseBody
    	public void deleteJob(String jobName,String jobGroup) { 
    		taskService.deleteJob(jobName,jobGroup);
    	}

#### 测试 ####

*  添加定时器  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70][]

> 注意：定时任务表达式要严格遵守规范 [在线生成地址][Link 1]

这里添加时设置的是3秒执行一次定时任务  
![在这里插入图片描述][20210108000307122.png]

*  修改定时任务  
    注意：完全限定名 和 分组 必须和添加时的一致（下面请求同理）![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 1]

这里把执行时间修改成了 5秒 执行一次  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 2]

*  暂停定时任务  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 3]
 *  恢复定时任务  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 4]
 *  删除定时任务  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 5]  
    完成。

--------------------

嗯，今天成都下雪了~~~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70]: /images/20221119/661661221a624831a728ca1685fe9ed0.png
[Link 1]: https://cron.qqe2.com/
[20210108000307122.png]: /images/20221119/84e14ff2c8434ef4ad5d6e76a6ba4252.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 1]: /images/20221119/e593a51de393410aa4a331c9a361e631.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 2]: /images/20221119/9533ce46b5b345438390f0d047899c5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 3]: /images/20221119/f06c7ed63c22441abfbd7ab64ee9a530.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 4]: /images/20221119/d69be1b286c8496397284971d6f1e7ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODE4MzI1_size_16_color_FFFFFF_t_70 5]: /images/20221119/99067049575840e3be91e15326f69b3c.png