2. 程式人生 > >動態Quartz任務排程（Spring結合Quartz）

動態Quartz任務排程（Spring結合Quartz）

阿新 • • 發佈：2019-01-19

之前寫過一遍配置quartz任務排程的博文，連結：點選開啟連結，這種方式不夠靈活，所以今天特地用java程式碼實現動態Quartz任務排程。閒話不多說了，直接上程式碼。

package org.demo.schedule;

import java.text.ParseException;

import org.demo.core.context.SpringContextUtil;
import org.demo.entity.quartz.QuartzScheduleJob;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

public class QuartzJobFactory {

	private static Scheduler scheduler = getScheduler();
	
	/**
     * 建立一個定時任務
     * 
     * @param scheduler
     * @param job
	 * @return 
     * @throws SchedulerException
     * @throws Exception
     */
    public static void createSheduler(QuartzScheduleJob job) throws Exception {
        // 在工作狀態可用時,即job_status = 1 ,開始建立
        if (job.getJobStatus().equals("1")) {
            // 新建一個基於Spring的管理Job類
            MethodInvokingJobDetailFactoryBean methodInvJobDetailFB = 
            		new MethodInvokingJobDetailFactoryBean();
            // 設定Job名稱
            methodInvJobDetailFB.setName(job.getJobName());
            // 是Spring中定義的Bean
            if (job.getIsSpringBean().equals("1")) {
                methodInvJobDetailFB
                        .setTargetObject(SpringContextUtil.getBean(job.getTargetObject()));
            } else {// 不是
                methodInvJobDetailFB.setTargetObject(Class.forName(job.getClazz()).newInstance());
            }
            // 設定任務方法
            methodInvJobDetailFB.setTargetMethod(job.getTargetMethod());
            // 將管理Job類提交到計劃管理類
            methodInvJobDetailFB.afterPropertiesSet();
            /** 併發設定 */
            methodInvJobDetailFB.setConcurrent(job.getConcurrent().equals("1") ? true : false);

            JobDetail jobDetail = methodInvJobDetailFB.getObject();// 動態
            jobDetail.getJobDataMap().put("scheduleJob", job);

            //	方式2
            CronScheduleBuilder scheduleBuilder = 
            		CronScheduleBuilder.cronSchedule(job.getCronExpression());
            // 按新的cronExpression表示式構建一個新的trigger
            CronTrigger trigger = 
            		TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())
                    .withSchedule(scheduleBuilder).build();
            //如果任務排程器未啟動
            if(!scheduler.isStarted()){  
            	start();  
                scheduler.scheduleJob(jobDetail, trigger);// 將相關的Job注入到管理類
            }
        }
    }
    
    /**
     * 修改CronExpression
     * @param job
     */
    public static void modifyJobCronExpression(QuartzScheduleJob job){
    	//構建trigger的兩種方式  方式1
        String triggerName;
		try {
			if (!isShutdown()) {
				triggerName = scheduler.getTriggersOfJob(new JobKey(job.getJobName(), 
						job.getJobGroup())).get(0).getKey().getName();
				CronTriggerImpl triggerCron;
				triggerCron = (CronTriggerImpl)scheduler.getTrigger(new TriggerKey(triggerName));
				triggerCron.setCronExpression(job.getCronExpression());
				scheduler.rescheduleJob(new TriggerKey(job.getJobName(), 
						job.getJobGroup()), triggerCron);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
    }
    
    /**
     * 啟動一個排程物件
     * @throws SchedulerException
     */
    public static void start() throws SchedulerException {
    	if (!scheduler.isShutdown()) {
        	scheduler.start();
		}
    } 
    
    /**
     * 判斷排程器是否關閉
     * @return
     */
    private static boolean isShutdown(){
    	try {
			return scheduler.isShutdown();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
    	return false;
    }
    
    /**
     * 排程是否啟動
     * @return
     * @throws SchedulerException
     */
    public static boolean isStarted() throws SchedulerException { 
    	return scheduler.isStarted(); 
    } 
    
    /**
     * 關閉排程器
     * @throws SchedulerException
     */
    public static void shutdown() throws SchedulerException { 
    	scheduler.shutdown(); 
    } 
    
    /**
     * 暫停排程任務
     * @param triggerkey
     * @return
     * @throws SchedulerException
     */
    public static void unscheduleJob(QuartzScheduleJob job) 
    		throws SchedulerException{ 
    	if (!isShutdown()) {
    		scheduler.pauseJob(new JobKey(job.getJobName(), 
    				job.getJobGroup()));
    		scheduler.pauseTrigger(new TriggerKey(job.getJobName(), 
    				job.getJobGroup())); 
    	}
    }
    
    /**
     * 重啟任務排程
     * @param job
     */
    public static void resumeJob(QuartzScheduleJob job){
    	try {
    		if (!isShutdown()) {
    			scheduler.resumeJob(new JobKey(job.getJobName(), 
    					job.getJobGroup()));
    			scheduler.resumeTrigger(new TriggerKey(job.getJobName(), 
    					job.getJobGroup()));
    		}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
    }
    
    /**
     * 暫停觸發器
     * @param job
     */
    public static void pauseTrigger(QuartzScheduleJob job) {  
        try {  
        	if (!isShutdown()) {
        		scheduler.pauseTrigger(new TriggerKey(job.getJobName(), 
        				job.getJobGroup()));// 停止觸發器  
        	}
        } catch (SchedulerException e) {  
            throw new RuntimeException(e);  
        }  
    }

    /**
     * 恢復觸發器
     * @param job
     */
    public static void resumeTrigger(QuartzScheduleJob job) {  
        try {  
        	if (!isShutdown()) {
        		scheduler.resumeTrigger(new TriggerKey(job.getJobName(), 
        				job.getJobGroup()));// 重啟觸發器  
        	}
        } catch (SchedulerException e) {  
            throw new RuntimeException(e);  
        }  
    } 
    
    /**
     * 刪除觸發器 
     * @param job
     * @return
     */
    public static boolean removeTrigdger(QuartzScheduleJob job) {  
        TriggerKey triggerKey = new TriggerKey(job.getJobName(), 
        		job.getJobGroup());  
        try {  
        	if (!isShutdown()) {
        		scheduler.pauseTrigger(triggerKey);// 停止觸發器  
        	}
            return scheduler.unscheduleJob(triggerKey);// 移除觸發器  
        } catch (SchedulerException e) {  
            throw new RuntimeException(e);  
        }  
    }  
	/**
     * 暫停排程中所有的job
     * 恢復任務時，停止時間段之間的任務會被執行
     */
    public static void pauseAll() {
		try {
			if (!isShutdown()) {
				scheduler.pauseAll();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
    
    /**
     * 恢復排程中所有的job
     * @throws SchedulerException
     */
    public  void resumeAll() throws SchedulerException {  
    	if (!isShutdown()) {
    		scheduler.resumeAll();
		}
    }
    
    /**
     * 刪除一個任務
     * @param job
     * @param triggerkey
     * @throws SchedulerException
     */
    public static void removeJob(QuartzScheduleJob job,TriggerKey triggerkey) 
           throws SchedulerException{
    	if (!isShutdown()) {
    		scheduler.pauseTrigger(triggerkey);//停止觸發器
    		scheduler.unscheduleJob(triggerkey);//移除觸發器
    		scheduler.deleteJob(new JobKey(job.getJobName(), 
    				job.getJobGroup()));//刪除任務
    	}
    }
    
    /**
	 * 建立一個排程物件
	 * 
	 * @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;
	}
}

 


package org.demo.entity.quartz;

import java.io.Serializable;

public class QuartzScheduleJob implements Serializable{
    /**
	 * 
	 */
	private static final long serialVersionUID = -5715967643524351738L;

	private String id;

	/**
	 * jobName
	 */
    private String jobName;

    /**
     * 任務狀態 
     * 0：禁用 1：啟用
     */
    private String jobStatus;

    /**
     * 觸發時間
     */
    private String cronExpression;

    /**
     * 是否併發啟動任務 
     * 0：禁用 1：啟用
     */
    private String concurrent;

    /**
     * 任務描述
     */
    private String description;

    /**
     * jobGroup
     */
    private String jobGroup;

    /**
     * 執行job的類
     */
    private String targetObject;

    /**
     * 執行job的方法
     */
    private String targetMethod;

    /**
     * 是否是Spring中定義的Bean 0：不是 1：是  如果是0需要設定全類名,測試CLAZZ欄位需要配置
     */
    private String isSpringBean;

    /**
     * 全類名
     * 前置條件，當isSpringBean為0時
     */
    private String clazz;

    /**
     * job的子任務
     */
    private String childJobs;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName == null ? 
        		null : jobName.trim();
    }

    public String getJobStatus() {
        return jobStatus;
    }

    public void setJobStatus(String jobStatus) {
        this.jobStatus = jobStatus == null ? 
        		null : jobStatus.trim();
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression == null ? 
        		null : cronExpression.trim();
    }

    public String getConcurrent() {
        return concurrent;
    }

    public void setConcurrent(String concurrent) {
        this.concurrent = concurrent == null ? 
        		null : concurrent.trim();
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description == null ? 
        		null : description.trim();
    }

    public String getJobGroup() {
        return jobGroup;
    }

    public void setJobGroup(String jobGroup) {
        this.jobGroup = jobGroup == null ? 
        		null : jobGroup.trim();
    }

    public String getTargetObject() {
        return targetObject;
    }

    public void setTargetObject(String targetObject) {
        this.targetObject = targetObject == null ? 
        		null : targetObject.trim();
    }

    public String getTargetMethod() {
        return targetMethod;
    }

    public void setTargetMethod(String targetMethod) {
        this.targetMethod = targetMethod == null ? 
        		null : targetMethod.trim();
    }

    public String getIsSpringBean() {
        return isSpringBean;
    }

    public void setIsSpringBean(String isSpringBean) {
        this.isSpringBean = isSpringBean == null ? 
        		null : isSpringBean.trim();
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz == null ? 
        		null : clazz.trim();
    }

    public String getChildJobs() {
        return childJobs;
    }

    public void setChildJobs(String childJobs) {
        this.childJobs = childJobs == null ? 
        		null : childJobs.trim();
    }
}

測試類 
package org.demo.schedule;

import org.demo.entity.quartz.QuartzScheduleJob;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.quartz.Scheduler;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
public class QuartzTest {

	@Test
	public void print(){
		
         try {
			 QuartzScheduleJob job = new QuartzScheduleJob();
			 job.setChildJobs(null);
			 job.setClazz(null);
			 job.setConcurrent("0");
			 job.setCronExpression("0/5 * * * * ?");
			 job.setDescription("QuartzScheduleJob");
			 job.setIsSpringBean("1");
			 job.setJobGroup(Scheduler.DEFAULT_GROUP);
			 job.setJobName("quartzSchedule");
			 job.setJobStatus("1");
			 job.setTargetMethod("printString");
			 job.setTargetObject("scheduleTest");
			 QuartzJobFactory.createSheduler(job);
			 Thread.sleep(60*1000);
//			 QuartzJobFactory.shutdown();
			 System.out.println("pauseTrigger");
			 QuartzJobFactory.unscheduleJob(job);
			 Thread.sleep(60*1000);
			 System.out.println("resumeTrigger");
			 QuartzJobFactory.resumeJob(job);
			 System.out.println("modifyJobCronExpression");
			 job.setCronExpression("0/1 * * * * ?");
			 QuartzJobFactory.modifyJobCronExpression(job);
			 Thread.sleep(60*1000);
			 System.out.println("任務是否啟動:"+QuartzJobFactory.isStarted());
		} catch (Exception e) {
			e.printStackTrace();
		}    
	}

}

測試結果如下：

QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
pauseTrigger
resumeTrigger
modifyJobCronExpression
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
QuartzScheduleJob Start Run!
任務是否啟動:true

相關推薦

動態Quartz任務排程（Spring結合Quartz）

之前寫過一遍配置quartz任務排程的博文，連結：點選開啟連結，這種方式不夠靈活，所以今天特地用java程式碼實現動態Quartz任務排程。閒話不多說了，直接上程式碼。 package org.demo.schedule; import java.text.ParseEx

spring整合quartz任務排程（註解式）

配置springmvc.xml xmlns 多加下面的內容、 xmlns:task="http://www.springframework.org/schema/task" 然後xsi:schemaLocation多加下面的內容、 http://w

spring結合quartz實現定時排程

quartz所需jar包 <!-- 定時任務quartz --> <dependency> <groupId>org.quartz-scheduler</groupId>    <artifactId>qua

Quartz任務排程框架--任務執行流程（二）

       上一篇部落格Quartz任務排程框架--簡介與示例（一）中我們已經簡介和示例程式碼對quartz有了初步的認識，這篇部落格我們通過追蹤quartz的定時任務執行流程來加深對quartz的瞭解。 1、執行活動執行緒 （1）Quartz_Worker-*執行

Quartz任務排程框架（啟動定時任務框架）

Quartz任務排程框架（啟動定時任務框架） Quartz是OpenSymphony開源組織在Jobscheduling領域又一個開源專案，它可以與J2EE與J2SE應用程式相結合也可以單獨使用。Quartz可以用來建立簡單或為執行十個，百個，甚至是好幾萬個Jobs這樣複雜的

quartz任務排程框架實現任務定時執行，不傳參的配置（一）

quartz是一個任務排程框架，可以用它來實現一些需要定時執行的任務。 本次實現的是spring配置整合quartz 1.配置如下：目標bean和bean中的方法需要自己定義，這個方法就是要執行

Quartz--任務排程的實現（例項+原始碼+驚喜）

首先，說一下什麼叫做任務排程    詢問度娘中....看了一下，度娘說的還挺囉嗦的，實在不懂的可以去問問度娘，在這我就不貼上了。就我的話來說，任務排程，就是在一個合適的時機去執行一項任務，當然這個時機是有計劃的。例如，你定了一個鬧鐘，到了指定的時間鬧鐘就會響，這就是一個任務的

Spring研磨分析、Quartz任務排程、Hibernate深入淺出系列文章筆記彙總

這系列文章主要是對Spring、Quartz、Hibernate等JavaWeb相關框架學習、並用於實踐開發相當一段時間後，進行回顧總結的一系列筆記記錄，對其中重點難點如IOC、AOP、資料庫連線等進行了分析。主要是基於一些經典書籍文件講解的基礎上，融入自己實踐

控制檯基於Quartz.Net元件實現定時任務排程（一）

前言：    你曾經需要應用執行一個任務嗎？比如現在有一個需求，需要每天在零點定時執行一些操作，那應該怎樣操作呢？    這個時候，如果你和你的團隊是用.NET程式設計的話，可以考慮使用Quartz.NET排程器。允許開發人員根據日期間隔來實現任務排程任務。非常

Window服務基於Quartz.Net元件實現定時任務排程（二）

前言：    在上一章中，我們通過利用控制檯實現定時任務排程，已經大致瞭解瞭如何基於Quartz.Net元件實現任務，至少包括三部分：job(作業），trigger（觸發器），scheduler（排程器）。其中job是需要在一個定時任務中具體執行的業務邏輯，trigger通過規定job何

Quartz任務排程框架初探

Quartz任務排程框架初探 什麼是Quartz? Quartz 是一個完全由 Java 編寫的開源作業排程框架，為在 Java 應用程式中進行作業排程提供了簡單卻強大的機制。 Quartz 可以與 J2EE 與 J2SE 應用程式相結合也可以單獨使用。

Quartz任務排程，訪問Servlet Context容器中的資料

  Quartz任務排程，訪問Servlet Context容器中的資料 2014年08月07日 18:55:37 閱讀數：1102 Quartz是一種功能豐富的開源作業排程庫，它可以在幾乎任何Java應用程式整合，從最小的單機應用到最大的電子商務系統。 Quartz可以用

.NET中Quartz任務排程器的簡單應用例項

1.首先從NuGet中安裝Quartz，安裝最新版本就OK 2.新建一個Job類實現Quart中的IJob介面用於執行業務邏輯，程式碼如下： class CheckUpdateJob : IJob { public async Task Exec

Quartz任務排程的概念

什麼是Quartz任務排程？ Quartz任務排程就是一個在預先確定（被納入日程）的時間到達時，負責執行（或者通知）一個job(作業) 例如： ①外賣訂單下單後未付款，15分鐘後自動撤消訂單，並自動解鎖鎖定的商品… ②訂購車票時，在付款時先鎖定該車票，在特定時間，比

初入Quartz任務排程

package org.miya.quartz.job; import java.util.Date; import org.quartz.JobBuilder; import org.quartz.JobDetail; import org.quartz.Scheduler; impo

Quartz任務排程的簡單應用

Quartz框架主要分為三部分： 1 任務 2 觸發器 3 排程器 謝了一個簡單例子，大家可以看下 public class RemindJob implements Job { int[]param=new int[]{1,2,3,4,5,6,7};

初始quartz（spring和quartz整合）

初識quartz quartz是完全由java開發的一個開源的任務日程管理系統，“任務進度管理器”就是一個在預先確定（被納入日程）的時間到達時，負責執行（或者通知）其他軟體元件的系統。 1.quartz有兩種儲存方式： RAM儲存和JDBC儲存，顯然ram儲存就

spring task 任務排程 （定時任務）

0 0 10,14,16 * * ? 每天上午10點，下午2點，4點 0 0/30 9-17 * * ?   朝九晚五工作時間內每半小時 0 0 12 ? * WED 表示每個星期三中午12點  "0 0 12 * * ?" 每天中午12點觸發  "0 15 10 ? * *" 每天上午10:15觸發  "0

Quartz任務排程(1)概念例析快速入門

Quartz框架需求引入 在現實開發中，我們常常會遇到需要系統在特定時刻完成特定任務的需求，在《spring學習筆記(14)引介增強詳解：定時器例項：無侵入式動態增強類功能》，我們通過引介增強來簡單地模擬實現了一個定時器。它可能只需要我們自己維護一條執行緒就足

quartz任務排程框架入門

1、 CronTrigger時間格式配置說明 CronTrigger配置格式: 格式: [秒] [分] [小時] [日] [月] [周] [年] 序號 說明 是否必填 允許填寫的值 允許的萬用字元 1 秒 是 0-59  , - * /