java编程式控制quartz Scheduler 启动和停止,无法停止的问题解决

在项目中需要手动启停某些服务，那么需要有一个控制这些任务的类。由于任务是有Quartz控制的，我们只需要通过Quartz的相关的API实现相关的功能即可。

      在spring 配置中把自启动关闭就可以用了

class="org.springframework.scheduling.quartz.SchedulerFactoryBean"
autowire="no">






false

 package com.easyway.app.quartz.mgr;

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

 import org.quartz.JobDataMap;
 import org.quartz.JobDetail;
 import org.quartz.JobKey;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.SchedulerFactory;
 import org.quartz.Trigger;
 import org.quartz.TriggerKey;
 import org.quartz.impl.StdSchedulerFactory;
 import org.quartz.impl.matchers.GroupMatcher;

 /**
  * 一个简单的quartz任务管理器
  * @author longgangbai
  *
  */
 public class QuartzScheduleMgr {
     private static  Scheduler scheduler=getScheduler();
     /**
      * 创建一个调度对象
      * @return
      * @throws SchedulerException
      */
     private static Scheduler getScheduler() {
             SchedulerFactory sf = new StdSchedulerFactory();
             Scheduler scheduler=null;
             try {
                 scheduler = sf.getScheduler();
             } catch (SchedulerException e) {
                 e.printStackTrace();
             }
             return scheduler;
     }
     public static Scheduler getInstanceScheduler(){
         return scheduler;
     }

     /**
      * 启动一个调度对象
      * @throws SchedulerException
      */
     public  void start() throws SchedulerException
     {
         scheduler.start();
     }

     /**
      * 检查调度是否启动
      * @return
      * @throws SchedulerException
      */
     public  boolean isStarted() throws SchedulerException
     {
         return scheduler.isStarted();
     }

     /**
      * 关闭调度信息
      * @throws SchedulerException
      */
     public  void shutdown() throws SchedulerException   {
         scheduler.shutdown();
     }
     /**
      * 添加调度的job信息
      * @param jobdetail
      * @param trigger
      * @return
      * @throws SchedulerException
      */
     public  Date scheduleJob(JobDetail jobdetail, Trigger trigger)
             throws SchedulerException{
                 return scheduler.scheduleJob(jobdetail, trigger);
     }
     /**
      * 添加相关的触发器
      * @param trigger
      * @return
      * @throws SchedulerException
      */
     public  Date scheduleJob(Trigger trigger) throws SchedulerException{
         return scheduler.scheduleJob(trigger);
     }
      /**
       * 添加多个job任务
       * @param triggersAndJobs
       * @param replace
       * @throws SchedulerException
       */
      public  void scheduleJobs(Map> triggersAndJobs, boolean replace) throws SchedulerException
      {
         scheduler.scheduleJobs(triggersAndJobs, replace);
     }
     /**
      * 停止调度Job任务
      * @param triggerkey
      * @return
      * @throws SchedulerException
      */
     public  boolean unscheduleJob(TriggerKey triggerkey)
             throws SchedulerException{
         return scheduler.unscheduleJob(triggerkey);
     }

     /**
      * 停止调度多个触发器相关的job
      * @param list
      * @return
      * @throws SchedulerException
      */
     public  boolean unscheduleJobs(List triggerKeylist) throws SchedulerException{
         return scheduler.unscheduleJobs(triggerKeylist);
     }
     /**
      * 重新恢复触发器相关的job任务
      * @param triggerkey
      * @param trigger
      * @return
      * @throws SchedulerException
      */
     public  Date rescheduleJob(TriggerKey triggerkey, Trigger trigger)
     throws SchedulerException{
         return scheduler.rescheduleJob(triggerkey, trigger);
     }
     /**
      * 添加相关的job任务
      * @param jobdetail
      * @param flag
      * @throws SchedulerException
      */
     public  void addJob(JobDetail jobdetail, boolean flag)
             throws SchedulerException   {
         scheduler.addJob(jobdetail, flag);
     }

     /**
      * 删除相关的job任务
      * @param jobkey
      * @return
      * @throws SchedulerException
      */
     public  boolean deleteJob(JobKey jobkey) throws SchedulerException{
         return scheduler.deleteJob(jobkey);
     }

     /**
      * 删除相关的多个job任务
      * @param jobKeys
      * @return
      * @throws SchedulerException
      */
     public     boolean deleteJobs(List jobKeys)
     throws SchedulerException{
         return scheduler.deleteJobs(jobKeys);
     }
     /**
      *
      * @param jobkey
      * @throws SchedulerException
      */
     public  void triggerJob(JobKey jobkey) throws SchedulerException    {
         scheduler.triggerJob(jobkey);
     }
     /**
      *
      * @param jobkey
      * @param jobdatamap
      * @throws SchedulerException
      */
     public  void triggerJob(JobKey jobkey, JobDataMap jobdatamap)
             throws SchedulerException   {
         scheduler.triggerJob(jobkey, jobdatamap);
     }
     /**
      * 停止一个job任务
      * @param jobkey
      * @throws SchedulerException
      */
     public  void pauseJob(JobKey jobkey) throws SchedulerException  {
         scheduler.pauseJob(jobkey);
     }
     /**
      * 停止多个job任务
      * @param groupmatcher
      * @throws SchedulerException
      */
     public  void pauseJobs(GroupMatcher groupmatcher)
             throws SchedulerException   {
         scheduler.pauseJobs(groupmatcher);
     }
     /**
      * 停止使用相关的触发器
      * @param triggerkey
      * @throws SchedulerException
      */
     public  void pauseTrigger(TriggerKey triggerkey)
             throws SchedulerException   {
         scheduler.pauseTrigger(triggerkey);
     }

     public  void pauseTriggers(GroupMatcher groupmatcher)
             throws SchedulerException   {
         scheduler.pauseTriggers(groupmatcher);
     }
     /**
      * 恢复相关的job任务
      * @param jobkey
      * @throws SchedulerException
      */
     public  void resumeJob(JobKey jobkey) throws SchedulerException {
         scheduler.pauseJob(jobkey);
     }

     public  void resumeJobs(GroupMatcher matcher)
             throws SchedulerException   {
         scheduler.resumeJobs(matcher);
     }

     public  void resumeTrigger(TriggerKey triggerkey)
             throws SchedulerException   {
         scheduler.resumeTrigger(triggerkey);
     }

     public  void resumeTriggers(GroupMatcher  groupmatcher)
             throws SchedulerException
     {
         scheduler.resumeTriggers(groupmatcher);
     }
     /**
      * 暂停调度中所有的job任务
      * @throws SchedulerException
      */
     public  void pauseAll() throws SchedulerException
     {
         scheduler.pauseAll();
     }
     /**
      * 恢复调度中所有的job的任务
      * @throws SchedulerException
      */
     public  void resumeAll() throws SchedulerException
     {
         scheduler.resumeAll();
     }



 }

 

 

 

创建一个Job任务：

 /*
  * Copyright 2005 - 2009 Terracotta, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy
  * of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  *
  */

 package com.easyway.app.quartz.mgr;

 import java.util.Date;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;

 /**
  * 一个简单的quartz调用job
  * @author longgangbai
  *
  */
 public class HelloJob implements Job {

     private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

     public HelloJob() {
     }

     public void execute(JobExecutionContext context)
         throws JobExecutionException {
         _log.info("Hello World! - " + new Date());
     }

 }

 

 

创建触发器和调用相关的Job

 /*
  * Copyright 2005 - 2009 Terracotta, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy
  * of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  *
  */

 package com.easyway.app.quartz.mgr;

 import static org.quartz.DateBuilder.evenMinuteDate;
 import static org.quartz.JobBuilder.newJob;
 import static org.quartz.TriggerBuilder.newTrigger;

 import java.util.Date;

 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.Trigger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * 一个简单的测试quartz任务管理器测试类
  * @author longgangbai
  *
  */
 public class QuartzScheduleMain {


     /**
      *
      * @throws Exception
      */
     public void run() throws Exception {
         Logger log = LoggerFactory.getLogger(QuartzScheduleMain.class);

         log.info("------- Initializing ----------------------");

         // First we must get a reference to a scheduler
         //从调度管理器中获取调度对象
         Scheduler sched = QuartzScheduleMgr.getInstanceScheduler();
         log.info("------- Initialization Complete -----------");

         // computer a time that is on the next round minute
         Date runTime = evenMinuteDate(new Date());

         log.info("------- Scheduling Job  -------------------");

         // define the job and tie it to our HelloJob class
         //创建相关的job信息
         JobDetail job = newJob(HelloJob.class)
             .withIdentity("job1", "group1")
             .build();

         // Trigger the job to run on the next round minute
         //创建一个触发器的名称
         Trigger trigger = newTrigger()
             .withIdentity("trigger1", "group1")
             .startAt(runTime)
             .build();

         // Tell quartz to schedule the job using our trigger
         //设置调度相关的Job
         sched.scheduleJob(job, trigger);
         log.info(job.getKey() + " will run at: " + runTime);

         // Start up the scheduler (nothing can actually run until the
         // scheduler has been started)
         //启动调度任务
         sched.start();

         log.info("------- Started Scheduler -----------------");

         try {
             Thread.sleep(25L * 1000L);
             // executing...
         } catch (Exception e) {
         }
         //暂时停止Job任务开始执行
         log.info("-------pauseJob.. -------------");
         sched.pauseJob(job.getKey());

         try {
             Thread.sleep(10L * 1000L);
         } catch (Exception e) {
         }
         log.info("------- resumeJob... -------------");
         //恢复Job任务开始执行
         sched.resumeJob(job.getKey());
         try {
             Thread.sleep(10L * 1000L);
             // executing...
         } catch (Exception e) {
         }


         // wait long enough so that the scheduler as an opportunity to
         // run the job!
         log.info("------- Waiting 65 seconds... -------------");
         try {
             // wait 65 seconds to show job
             Thread.sleep(65L * 1000L);
             // executing...
         } catch (Exception e) {
         }

         // shut down the scheduler
         log.info("------- Shutting Down ---------------------");
         sched.shutdown(true);
         log.info("------- Shutdown Complete -----------------");
     }

     public static void main(String[] args) throws Exception {

         QuartzScheduleMain example = new QuartzScheduleMain();
         example.run();

     }

 }