springboot quartz动态任务处理

ゞ浴缸里的玫瑰 2022-02-17 12:09 228阅读 0赞

现实中的很多定时任务并不像网上的那种写法那么简单都是直接通过注解的形式实现（@Scheduled(fixedRate = 10000)）。我就遇到了从数据库读取相关的数据（可能有n条）然后根据数据的触发时间生成多个动态任务添加到Scheduler中，当到达触发点时自动触发该任务。

废话不多说，直接上代码：

核心调度类：

package com.xx.task;
    
    import org.apache.commons.lang3.StringUtils;
    import org.quartz.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Map;
    
    /**
     * @author xiaofeng
     * @version V1.0
     * @title: CustomQuartzScheduler
     * @package: com.xx.task
     * @description: 自定义job
     * @date 2019/4/19 10:32
     */
    @Component
    public class CustomQuartzScheduler {
    
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        @Autowired
        private Scheduler scheduler;
    
        /**
         * 开始执行所有任务
         */
        public void startJob() {
            try {
                scheduler.start();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 获取job信息
         *
         * @param jobName
         * @param groupName
         * @return
         */
        public String getJobInfo(String jobName, String groupName) {
            TriggerKey triggerKey = new TriggerKey(jobName, groupName);
            CronTrigger cronTrigger = null;
            try {
                cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),
                        scheduler.getTriggerState(triggerKey).name());
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 修改某个任务的执行时间
         *
         * @param jobName
         * @param groupName
         * @param cronExpress
         * @return
         */
        public boolean modifyJobWithCronExpress(String jobName, String groupName, String cronExpress) {
            Date date = null;
            TriggerKey triggerKey = new TriggerKey(jobName, groupName);
            CronTrigger cronTrigger = null;
            try {
                cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                String oldTime = cronTrigger.getCronExpression();
                if (!oldTime.equalsIgnoreCase(cronExpress)) {
                    CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpress);
                    CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName).withSchedule(cronScheduleBuilder).build();
                    date = scheduler.rescheduleJob(triggerKey, trigger);
                }
                return date != null;
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
            return false;
        }
    
        /**
         * 修改某个任务的执行时间
         *
         * @param jobName
         * @param groupName
         * @param startAt
         * @param endAt
         * @return
         */
        public boolean modifyJobWithTime(String jobName, String groupName, Date startAt, Date endAt) {
            Date date = null;
            TriggerKey triggerKey = new TriggerKey(jobName, groupName);
            Trigger oldTrigger = null;
            try {
                oldTrigger = scheduler.getTrigger(triggerKey);
                Date startTime = oldTrigger.getStartTime();
                Date endTime = oldTrigger.getEndTime();
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().withIdentity(jobName, groupName);
                if (startTime.compareTo(startAt) != 0) {
                    triggerBuilder.startAt(startAt);
                }
                if (endTime.compareTo(endAt) != 0) {
                    triggerBuilder.endAt(endAt);
                }
                Trigger trigger = triggerBuilder.build();
                date = scheduler.rescheduleJob(triggerKey, trigger);
                return date != null;
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
            return false;
        }
    
        /**
         * 暂停所有任务
         */
        public void pauseAllJob() {
            try {
                scheduler.pauseAll();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 暂停某个任务
         *
         * @param jobName
         * @param groupName
         */
        public void pauseJob(String jobName, String groupName) {
            JobKey jobKey = new JobKey(jobName, groupName);
            JobDetail jobDetail = null;
            try {
                jobDetail = scheduler.getJobDetail(jobKey);
                if (jobDetail == null) {
                    return;
                }
                scheduler.pauseJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 恢复所有任务
         */
        public void resumeAllJob() {
            try {
                scheduler.resumeAll();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 恢复某个任务
         *
         * @param jobName
         * @param groupName
         */
        public void resumeJob(String jobName, String groupName) {
            JobKey jobKey = new JobKey(jobName, groupName);
            JobDetail jobDetail = null;
            try {
                jobDetail = scheduler.getJobDetail(jobKey);
                if (jobDetail == null) {
                    return;
                }
                scheduler.resumeJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 删除某个任务
         *
         * @param jobName
         * @param groupName
         */
        public void deleteJob(String jobName, String groupName) {
            JobKey jobKey = new JobKey(jobName, groupName);
            JobDetail jobDetail = null;
            try {
                jobDetail = scheduler.getJobDetail(jobKey);
                if (jobDetail == null) {
                    return;
                }
                scheduler.deleteJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * add job
         *
         * @param jobName
         * @param groupName
         * @param cronExpress
         * @param clz         execute class
         * @param params      jobData
         */
        public void addJobByCron(String jobName, String groupName, String cronExpress, Class clz, Map<String, String> params) {
            if (StringUtils.isBlank(cronExpress)) {
                logger.error("{} cronExpress can't be null, CronScheduleBuilder need cronExpress to execute ~ ");
                return;
            }
            // build job
            JobBuilder jobBuilder = JobBuilder.newJob(clz);
            if (params != null) {
                params.entrySet().stream().forEach(stringObjectEntry -> {
                    jobBuilder.usingJobData(stringObjectEntry.getKey(), stringObjectEntry.getValue());
                });
            }
            JobDetail jobDetail = jobBuilder.withIdentity(jobName, groupName).build();
            // build trigger base on CronTrigger
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpress);
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
                    .withSchedule(cronScheduleBuilder).build();
            try {
                scheduler.scheduleJob(jobDetail, cronTrigger);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
    
        }
    
        /**
         * add job
         *
         * @param jobName
         * @param groupName
         * @param clz       execute class
         * @param startAt   startTime
         * @param endAt     endTime
         * @param params    jobData
         */
        public void addJob(String jobName, String groupName, Class clz, Date startAt, Date endAt, Map<String, String> params) {
            if (startAt == null) {
                logger.error("{} startAt can't be null, TriggerBuilder need trigger time to execute ~ ");
                return;
            }
            //build job
            JobBuilder jobBuilder = JobBuilder.newJob(clz);
            if (params != null) {
                params.entrySet().stream().forEach(stringObjectEntry -> {
                    jobBuilder.usingJobData(stringObjectEntry.getKey(), stringObjectEntry.getValue());
                });
            }
            JobDetail jobDetail = jobBuilder.withIdentity(jobName, groupName).build();
            //build trigger base time
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().startAt(startAt).withIdentity(jobName, groupName);
            if (endAt != null) {
                triggerBuilder.endAt(endAt);
            }
            Trigger trigger = triggerBuilder.build();
            try {
                scheduler.scheduleJob(jobDetail, trigger);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
    }

其中注意需要传递参数可以使用**usingJobData这个方法。**

**通过启动加载所有的任务到容器中：**

package com.xx.init;
    
    import com.google.common.collect.Maps;
    import com.lema.rakeback.model.extra.CompanyInfoVo;
    import com.lema.rakeback.service.superm.CompanyInfoService;
    import com.lema.rakeback.task.CustomQuartzScheduler;
    import com.lema.rakeback.task.job.EnterpriseGrantEndJob;
    import com.lema.rakeback.task.job.EnterpriseGrantStartJob;
    import com.lema.rakeback.utils.DateUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.ApplicationArguments;
    import org.springframework.boot.ApplicationRunner;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author xiaofeng
     * @version V1.0
     * @title: AppStartupRunner.java
     * @package: com.xx.init
     * @description: 服务器启动加载数据
     * @date 2019/4/19 10:41
     */
    @Component
    @Order(value = 0)
    public class AppStartupRunner implements ApplicationRunner {
        Logger logger = LoggerFactory.getLogger(getClass());
        @Autowired
        private CustomQuartzScheduler quartzScheduler;
        @Autowired
        private CompanyInfoService companyInfoService;
    
        @Override
        public void run(ApplicationArguments applicationArguments) {
            logger.info(">>>>>>>>>服务启动后初始化操作，执行后台job操作<<<<<<<<<");
            List<CompanyInfoVo> companyInfoVos = companyInfoService.queryForList(0, null, null, null, 0, Integer.MAX_VALUE);
            if (!CollectionUtils.isEmpty(companyInfoVos)) {
                companyInfoVos.stream().forEach(companyInfoVo -> {
                    String jobName1 = "job_" + companyInfoVo.getId() + "_start";
                    String groupName1 = "group_" + companyInfoVo.getId() + "_start";
                    String jobName2 = "job_" + companyInfoVo.getId() + "_end";
                    String groupName2 = "group_" + companyInfoVo.getId() + "_end";
                    Map<String, String> params = Maps.newHashMap();
                    params.put("id", String.valueOf(companyInfoVo.getId()));
    //                quartzScheduler.addJob(jobName1, gropName1, EnterpriseGrantStartJob.class, DateUtil.string2date2(companyInfoVo.getStartTime()), null, params);
    //                quartzScheduler.addJob(jobName2, groupName2, EnterpriseGrantEndJob.class, DateUtil.string2date2(companyInfoVo.getEndTime()), null, params);
                    quartzScheduler.addJobByCron(jobName1, groupName1, DateUtil.getCron(DateUtil.string2date2(companyInfoVo.getStartTime())), EnterpriseGrantStartJob.class, params);
                    quartzScheduler.addJobByCron(jobName2, groupName2, DateUtil.getCron(DateUtil.string2date2(companyInfoVo.getEndTime())), EnterpriseGrantEndJob.class, params);
    
                });
            }
            logger.info(">>>>>>>>>后台job任务已经启动...<<<<<<<<<");
        }
    }

业务执行相关类：

package com.xx.task.job;
    
    import org.quartz.Job;
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * @author xiaofeng
     * @version V1.0
     * @title: EnterpriseGrantStartJob
     * @package: com.xx.task.job
     * @description: 企业授权开始job
     * @date 2019/4/19 11:40
     */
    public class EnterpriseGrantStartJob implements Job {
    
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        private void before() {
            logger.info("=================StartJob before===============");
        }
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            before();
            JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
            /**
             * @// TODO: 2019/4/19 获取参数，执行业务 
             */
            Long id = jobDataMap.getLong("id");
            after();
    
        }
    
        private void after() {
            logger.info("=================StartJob before===============");
        }
    
    }

注意：需要引入的pom依赖

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

ok，启动即可