Quartz的任务的临时启动和暂停和恢复

所有分类 > 软件开发 > 作业调度框架 > Quartz

Quartz的任务的临时启动和暂停和恢复

您的评价:

     

 

 收藏该经验    

Quartz的任务的临时启动和暂停和恢复

 

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

001package com.gbsoft.rpt.qtz;

002 

003import java.util.Date;

004import java.util.List;

005import java.util.Map;

006 

007import org.quartz.JobDataMap;

008import org.quartz.JobDetail;

009import org.quartz.JobKey;

010import org.quartz.Scheduler;

011import org.quartz.SchedulerException;

012import org.quartz.SchedulerFactory;

013import org.quartz.Trigger;

014import org.quartz.TriggerKey;

015import org.quartz.impl.StdSchedulerFactory;

016import org.quartz.impl.matchers.GroupMatcher;

017 

018/**

019 * 一个简单的quartz任务管理器

020 * @author 123

021 *

022 */

023public classQuartzSchedule {

024    privatestatic  Scheduler scheduler=getScheduler();

025    /**

026     * 创建一个调度对象

027     * @return

028     * @throws SchedulerException

029     */

030    privatestatic Scheduler getScheduler() {

031            SchedulerFactory sf =new StdSchedulerFactory();

032            Scheduler scheduler=null;

033            try{

034                scheduler = sf.getScheduler();

035            }catch (SchedulerException e) {

036                e.printStackTrace();

037            }

038            returnscheduler;

039    }

040    publicstatic Scheduler getInstanceScheduler(){

041        returnscheduler;

042    }

043 

044    /**

045     * 启动一个调度对象

046     * @throws SchedulerException

047     */

048    public void start() throwsSchedulerException

049    {

050        scheduler.start();

051    }

052     

053    /**

054     * 检查调度是否启动

055     * @return

056     * @throws SchedulerException

057     */

058    public boolean isStarted() throwsSchedulerException

059    {

060        returnscheduler.isStarted();

061    }

062 

063    /**

064     * 关闭调度信息

065     * @throws SchedulerException

066     */

067    public void shutdown() throwsSchedulerException   {

068        scheduler.shutdown();

069    }

070    /**

071     * 添加调度的job信息

072     * @param jobdetail

073     * @param trigger

074     * @return

075     * @throws SchedulerException

076     */

077    public Date scheduleJob(JobDetail jobdetail, Trigger trigger)

078            throwsSchedulerException{

079                returnscheduler.scheduleJob(jobdetail, trigger);

080    }

081    /**

082     * 添加相关的触发器

083     * @param trigger

084     * @return

085     * @throws SchedulerException

086     */

087    public Date scheduleJob(Trigger trigger) throwsSchedulerException{

088        returnscheduler.scheduleJob(trigger);

089    }

090     /**

091      * 添加多个job任务

092      * @param triggersAndJobs

093      * @param replace

094      * @throws SchedulerException

095      */

096     public void scheduleJobs(Map<JobDetail, List<Trigger>> triggersAndJobs,boolean replace) throwsSchedulerException

097     {

098        scheduler.scheduleJobs(triggersAndJobs, replace);

099    }

100    /**

101     * 停止调度Job任务

102     * @param triggerkey

103     * @return

104     * @throws SchedulerException

105     */

106    public boolean unscheduleJob(TriggerKey triggerkey)

107            throwsSchedulerException{

108        returnscheduler.unscheduleJob(triggerkey);

109    }

110 

111    /**

112     * 停止调度多个触发器相关的job

113     * @param list

114     * @return

115     * @throws SchedulerException

116     */

117    public boolean unscheduleJobs(List<TriggerKey> triggerKeylist)throws SchedulerException{

118        returnscheduler.unscheduleJobs(triggerKeylist);

119    }

120    /**

121     * 重新恢复触发器相关的job任务

122     * @param triggerkey

123     * @param trigger

124     * @return

125     * @throws SchedulerException

126     */

127    public Date rescheduleJob(TriggerKey triggerkey, Trigger trigger)

128    throwsSchedulerException{

129        returnscheduler.rescheduleJob(triggerkey, trigger);

130    }

131    /**

132     * 添加相关的job任务

133     * @param jobdetail

134     * @param flag

135     * @throws SchedulerException

136     */

137    public void addJob(JobDetail jobdetail,boolean flag)

138            throwsSchedulerException   {

139        scheduler.addJob(jobdetail, flag);

140    }

141 

142    /**

143     * 删除相关的job任务

144     * @param jobkey

145     * @return

146     * @throws SchedulerException

147     */

148    public boolean deleteJob(JobKey jobkey)throws SchedulerException{

149        returnscheduler.deleteJob(jobkey);

150    }

151 

152    /**

153     * 删除相关的多个job任务

154     * @param jobKeys

155     * @return

156     * @throws SchedulerException

157     */

158    public    boolean deleteJobs(List<JobKey> jobKeys)

159    throwsSchedulerException{

160        returnscheduler.deleteJobs(jobKeys);

161    }

162    /**

163     *

164     * @param jobkey

165     * @throws SchedulerException

166     */

167    public void triggerJob(JobKey jobkey) throws SchedulerException    {

168        scheduler.triggerJob(jobkey);

169    }

170    /**

171     *

172     * @param jobkey

173     * @param jobdatamap

174     * @throws SchedulerException

175     */

176    public void triggerJob(JobKey jobkey, JobDataMap jobdatamap)

177            throwsSchedulerException   {

178        scheduler.triggerJob(jobkey, jobdatamap);

179    }

180    /**

181     * 停止一个job任务

182     * @param jobkey

183     * @throws SchedulerException

184     */

185    public void pauseJob(JobKey jobkey) throws SchedulerException  {

186        scheduler.pauseJob(jobkey);

187    }

188    /**

189     * 停止多个job任务

190     * @param groupmatcher

191     * @throws SchedulerException

192     */

193    public void pauseJobs(GroupMatcher<JobKey> groupmatcher)

194            throwsSchedulerException   {

195        scheduler.pauseJobs(groupmatcher);

196    }

197    /**

198     * 停止使用相关的触发器

199     * @param triggerkey

200     * @throws SchedulerException

201     */

202    public void pauseTrigger(TriggerKey triggerkey)

203            throwsSchedulerException   {

204        scheduler.pauseTrigger(triggerkey);

205    }

206 

207    public void pauseTriggers(GroupMatcher<TriggerKey> groupmatcher)

208            throwsSchedulerException   {

209        scheduler.pauseTriggers(groupmatcher);

210    }

211    /**

212     * 恢复相关的job任务

213     * @param jobkey

214     * @throws SchedulerException

215     */

216    public void resumeJob(JobKey jobkey) throws SchedulerException {

217        scheduler.pauseJob(jobkey);

218    }

219     

220    public void resumeJobs(GroupMatcher<JobKey> matcher)

221            throwsSchedulerException   {

222        scheduler.resumeJobs(matcher);

223    }

224 

225    public void resumeTrigger(TriggerKey triggerkey)

226            throwsSchedulerException   {

227        scheduler.resumeTrigger(triggerkey);

228    }

229    

230    public void resumeTriggers(GroupMatcher<TriggerKey>  groupmatcher)

231            throwsSchedulerException

232    {

233        scheduler.resumeTriggers(groupmatcher);

234    }

235    /**

236     * 暂停调度中所有的job任务

237     * @throws SchedulerException

238     */

239    public void pauseAll() throwsSchedulerException

240    {

241        scheduler.pauseAll();

242    }

243    /**

244     * 恢复调度中所有的job的任务

245     * @throws SchedulerException

246     */

247    public void resumeAll() throwsSchedulerException

248    {

249        scheduler.resumeAll();

250    }

251}

创建一个Job任务：

01package com.gbsoft.rpt.qrz;

02 

03import java.util.Date;

04 

05import org.slf4j.Logger;

06import org.slf4j.LoggerFactory;

07import org.quartz.Job;

08import org.quartz.JobExecutionContext;

09import org.quartz.JobExecutionException;

10 

11/**

12 * 一个简单的quartz调用job

13 * @author 123

14 *

15 */

16public classHelloJob implements Job {

17 

18    privatestatic Logger _log = LoggerFactory.getLogger(HelloJob.class);

19 

20    publicHelloJob() {

21    }

22 

23    publicvoid execute(JobExecutionContext context)

24        throwsJobExecutionException {

25        _log.info("Hello World! - "+ new Date());

26    }

27 

28}

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

1package com.gbsoft.rpt.qrz;

2 

3import staticorg.quartz.DateBuilder.evenMinuteDate;

4import staticorg.quartz.JobBuilder.newJob;

5import staticorg.quartz.TriggerBuilder.newTrigger;

6 

7import java.util.Date;

查看源码打印?

001import org.quartz.JobDetail;

002import org.quartz.Scheduler;

003import org.quartz.Trigger;

004import org.slf4j.Logger;

005import org.slf4j.LoggerFactory;

006 

007/**

008 * 一个简单的测试quartz任务管理器测试类

009 * @author 123

010 *

011 */

012public classQuartzScheduleMain {

013 

014     

015    /**

016     *

017     * @throws Exception

018     */

019    publicvoid run() throwsException {

020        Logger log = LoggerFactory.getLogger(QuartzScheduleMain.class);

021 

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

023 

024        // First we must get a reference to a scheduler

025        //从调度管理器中获取调度对象

026        Scheduler sched = QuartzScheduleMgr.getInstanceScheduler();

027        log.info("------- Initialization Complete -----------");

028 

029        // computer a time that is on the next round minute

030        Date runTime = evenMinuteDate(newDate());

031 

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

033 

034        // define the job and tie it to our HelloJob class

035        //创建相关的job信息

036        JobDetail job = newJob(HelloJob.class)

037            .withIdentity("job1","group1")

038            .build();

039         

040        // Trigger the job to run on the next round minute

041        //创建一个触发器的名称

042        Trigger trigger = newTrigger()

043            .withIdentity("trigger1","group1")

044            .startAt(runTime)

045            .build();

046         

047        // Tell quartz to schedule the job using our trigger

048        //设置调度相关的Job

049        sched.scheduleJob(job, trigger);

050        log.info(job.getKey() +" will run at: " + runTime); 

051 

052        // Start up the scheduler (nothing can actually run until the

053        // scheduler has been started)

054        //启动调度任务

055        sched.start();

056 

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

058 

059        try{

060            Thread.sleep(25L * 1000L);

061            // executing...

062        } catch (Exception e) {

063        }

064        //暂时停止Job任务开始执行

065        log.info("-------pauseJob.. -------------");

066        sched.pauseJob(job.getKey());

067         

068        try{

069            Thread.sleep(10L * 1000L);

070        } catch (Exception e) {

071        }

072        log.info("------- resumeJob... -------------");

073        //恢复Job任务开始执行

074        sched.resumeJob(job.getKey());

075        try{

076            Thread.sleep(10L * 1000L);

077            // executing...

078        } catch (Exception e) {

079        }

080         

081         

082        // wait long enough so that the scheduler as an opportunity to

083        // run the job!

084        log.info("------- Waiting 65 seconds... -------------");

085        try{

086            // wait 65 seconds to show job

087            Thread.sleep(65L * 1000L);

088            // executing...

089        } catch (Exception e) {

090        }

091 

092        // shut down the scheduler

093        log.info("------- Shutting Down ---------------------");

094        sched.shutdown(true);

095        log.info("------- Shutdown Complete -----------------");

096    }

097 

098    publicstatic void main(String[] args) throws Exception {

099 

100        QuartzScheduleMain example =new QuartzScheduleMain();

101        example.run();

102 

103    }

104 

105}

转：http://www.open-open.com/lib/view/open1351324322285.html

官网地址：http://www.quartz-scheduler.org/documentation/quartz-2.1.x/quick-start