quartz 定时任务调度管理器

本项目使用的是spring-quartz

以下配置可以开启多个已知定时任务

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">


    <!--<util:properties id="quartz" location="classpath:quartz.properties" />-->

    <!-- single thread -->
    <task:executor id="threadPoolTaskExecutor" pool-size="1"/>

    <!-- Scheduler factory bean to glue together jobDetails and triggers to Configure Quartz Scheduler -->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobFactory">
            <bean class="com.xxx.servicenode.pushtaskserver.quartz.task.MySpringBeanJobFactory"/>
        </property>
        <property name="startupDelay" value="0"/>
        <property name="taskExecutor" ref="threadPoolTaskExecutor"/>
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>
            </list>
        </property>
    </bean>

    <!-- Run the job every 5 seconds -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="myjobDetail"/>
        <!--<property name="cronExpression" value="0/5 * * ? * SAT-SUN" />-->
        <property name="cronExpression" value="#{config['quartz.time']}"/>
    </bean>
    <bean id="myjobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.xxx.servicenode.pushtaskserver.quartz.task.MyJob"/>
    </bean>

</beans>

MySpringBeanJobFactory:

public class MySpringBeanJobFactory  extends SpringBeanJobFactory {

    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle)throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

MyJob:

public class MyJob extends QuartzJobBean {
    
    private final static Logger logger = LoggerFactory.getLogger(MyJob.class);

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
     //处理自己的业务逻辑
    }
}

定时任务调度：

适用场景：多个未知定时任务

public class QuartzManager {

    private final static Logger logger = LoggerFactory.getLogger(QuartzManager.class);

    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
    private static String JOB_GROUP_NAME = "MY_JOBGROUP_NAME";
    private static String TRIGGER_GROUP_NAME = "MY_TRIGGERGROUP_NAME";
    private static Scheduler scheduler;
    
    /**
     * 创建一个地上那个会任务并启动
     *
     * @param jobName
     * @param cls
     * @param cron
     * @param messageId
     */
    public static void addJob(String jobName, Class cls, String cron, int messageId, int timingExpId) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail job = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
            JobDataMap jobDataMap = job.getJobDataMap();
            jobDataMap.put("messageId", messageId);
            jobDataMap.put("timingExpId", timingExpId);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
            // 按新的cronExpression表达式构建一个新的trigger
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
                    .withSchedule(scheduleBuilder).build();
            // 交给scheduler去调度
            sched.scheduleJob(job, trigger);
            // 启动
            if (!sched.isShutdown()) {
                sched.start();
                logger.info("新任务创建完毕，并启动 ！jobName：[" + jobName + "]");
            }
        } catch (Exception e) {
            String message = e.getMessage();
            if (message.contains("will never fire")) {
                logger.info("当前任务不会被触发，设置为失效状态，timingExpId：[" + timingExpId + "] ...");
                PushTaskServerService pushTaskServerService = SpringContextHolder.getInstance().getBean(PushTaskServerService.class);
                pushTaskServerService.setTimingStatus(timingExpId);
            }
            Throwable cause = e.getCause();

            logger.error("新任务创建、并启动 失败", e);
        }
    }

    /**
     * 移除一个定时任务
     *
     * @param jobName
     */
    public static void removeJob(String jobName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }
            // 停止触发器
            sched.pauseTrigger(triggerKey);
            // 移除触发器
            sched.unscheduleJob(triggerKey);
            // 删除任务
            sched.deleteJob(jobKey);
            logger.info("移除任务,完毕!jobName:[" + jobName + "]");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 查到当前任务的状态
     *
     * @param jobName
     * @return NONE 无，
     * NORMAL, 正常
     * PAUSED, 暂停
     * COMPLETE, 完成
     * ERROR, 错误，
     * BLOCKED 受阻；
     */
    public static String getTriggerState(String jobName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
        String name = null;
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            Trigger.TriggerState triggerState = sched.getTriggerState(triggerKey);
            name = triggerState.name();
        } catch (Exception e) {
            logger.error("获取任务状态失败！jobName:[" + jobName + "]", e);
        }
        return name;
    }
    
    /**
     * 暂停一个任务
     *
     * @param jobName
     */
    public static void pauseJob(String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.pauseJob(jobKey);
        } catch (Exception e) {
            logger.error("暂停任务失败！jobName:[" + jobName + "]", e);
        }
    }

    /**
     * 恢复一个任务
     *
     * @param jobName
     */
    public static void resumeJob(String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.resumeJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("恢复任务失败！jobName:[" + jobName + "]", e);

        }
    }
    
    /**
     * 获取定时任务调度中全部任务
     */
    public static void getAllJobs() {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            List<String> triggerGroupNames = sched.getTriggerGroupNames();
            logger.info("定时任务管理器中全部任务 . triggerGroupNames.size:[" + triggerGroupNames.size() + "] ... ");
            for (String group : triggerGroupNames) {
                logger.info("定时任务管理器 TriggerGroupName:[" + group + "] ... ");
                Set<TriggerKey> triggerKeys = sched.getTriggerKeys(GroupMatcher.triggerGroupEquals(group));
                logger.info("定时任务管理器[" + group + "]分组下任务size:[" + triggerKeys.size() + "] ... ");
                for (TriggerKey triggerKey : triggerKeys) {
                    String jobName = triggerKey.getName();
                    logger.info("定时任务管理器[" + group + "]分组下任务Name:[" + jobName + "] ... ");
                    String triggerState = getTriggerState(jobName);
                    logger.info("定时任务管理器[" + group + "]分组下任务Name:[" + jobName + "],任务状态:[" + triggerState + "] ... ");
                }
            }
        } catch (Exception e) {
            logger.info("获取任务调度管理器中全部任务失败", e);
        }
    }
    
    /**
     * 开启全部任务
     */
    public static void startJobs() {
        try {
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 关闭全部任务
     */
    public void shutdownJobs() {
        try {
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            logger.error("关闭全部任务失败", e);
        }
    }

    /**
     * 删除定时任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void startJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            Trigger.TriggerState triggerState = scheduler.getTriggerState(triggerKey);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 创建启动定时任务
     *
     * @param jobClass
     */
    public void createTrgger(Class jobClass) {
        try {
            //定时任务名称
            String jobName = "";
            String triggerName = "";
            String triggerGroupName = "";
            String jobGroupName = "";
            String cron = "";
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            jobDetail.getJobDataMap().put("messageId", "1");
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            logger.error("", e);
        }
    }

    public Scheduler getScheduler() {
        return scheduler;
    }

    public void setScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }
}

经测试：定时任务调度器开启的定时任务，当任务状态为：完成（COMPLETE）时，此任务自动回收

pom.xml(本人是pom版本)

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz-jobs -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>

参考文档：http://www.quartz-scheduler.org/documentation/quartz-2.3.0/cookbook/