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/