Quartz新ipad多任务怎么设置多任务
点击联系发帖人
时间：2015-12-15 05:40
博客分类：
参见上一篇 可以知道如何设置多个规则的定时任务，但有时需要客户自己设置指定的时间来启动新的任务处理不同的事情。
实现方式：用户在前台自行维护任务列表和任务执行时间，后台将任务执行时间解析成对应的cronexpression后与任务列表一起保存到数据库中。在 服务器运行期间添加的任务通过验证的（quartz会验证cronexpression是否合法以及对应时间是否已经过期）将直接添加一个任务以及触发器。
简而言之，就是自己创建一个新的jobdetail ---新的 Trigger 指定行的定时规则--启动新增定时器任务
(执行完新任务可以选择取消新的任务)
这里实现的思路是：按照定时规则扫描用户设置的任务开始时间，如定时发短信，有定时的就发出去。
1、首先加入定时规则扫描的任务，
package net.nilm61.timeT
import java.text.DateF
import java.text.SimpleDateF
import java.util.D
import java.util.L
import java.util.L
import javax.persistence.EntityM
import javax.persistence.EntityManagerF
import net.nilm61.entity.R
import net.nilm61.service.RepayS
import org.quartz.CronT
import org.quartz.JobD
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.quartz.S
import org.quartz.SchedulerE
import org.springframework.context.ApplicationC
import org.springframework.orm.jpa.EntityManagerH
import org.springframework.scheduling.quartz.QuartzJobB
import org.springframework.transaction.support.TransactionSynchronizationM
public class AutoRepayBidTask extends QuartzJobBean{
private RepayService repayS
public void setRepayService(RepayService repayService) {
this.repayService = repayS
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
EntityManagerFactory emf =
EntityManager em =
//System.out.println("Start!!!!!!!!!");
scheduler = context.getScheduler();
ApplicationContext ac = (ApplicationContext)scheduler.getContext().get("theScheduler");
emf = (EntityManagerFactory) ac.getBean("entityManagerFactory", EntityManagerFactory.class);
em = emf.createEntityManager();
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
RepayService repayService = (RepayService)ac.getBean("recordService");
setRepayService(repayService);
doBiz(scheduler);
}catch(Exception e){
e.printStackTrace();
//logger.error(e.getMessage());
//System.out.println("over!!!!!!!!!!!!!!!!!");
if(em!=null){
em.close();
private void doBiz(Scheduler scheduler) {
List&Repay&
repays = repayService.getByAutoRepay();
//从数据库中查询定时处理的条目
if(repays != null && repays.size() &0){
DateFormat df = new SimpleDateFormat("ss mm HH dd MM ? yyyy ",Locale.ENGLISH);
for(Repay repay : repays){
actualTime =repay.getActualTime();
if(actualTime != null){
cronExpression = df.format(actualTime);
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为DoBiz4TestTask.class
JobDetail jobDetail =
new JobDetail("AutoRepayBidsJob_" + repay.getId(), Scheduler.DEFAULT_GROUP,
DoBiz4TestTask.class);
CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(
"AutoRepayBidsTrigger_"+repay.getId(), Scheduler.DEFAULT_GROUP);
if(cronTrigger == null){
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
cronTrigger = new CronTrigger("AutoRepayBidsTrigger_" + repay.getId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
System.out.println(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
2.增加DoBiz4TestTask （具体执行的定时任务）
所有的触发器执行的任务类均为DoBiz4TestTask.class，DoBiz4TestTask 需要实现接口：org.quartz.Job中的方法execute方法，这里继承的是org.quartz.Job的子类org.springframework.scheduling.quartz.QuartzJobBean 参考代码如下
package net.nilm61.timeT
import javax.persistence.EntityM
import javax.persistence.EntityManagerF
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.quartz.S
import org.quartz.T
import org.springframework.context.ApplicationC
import org.springframework.orm.jpa.EntityManagerH
import org.springframework.scheduling.quartz.QuartzJobB
import org.springframework.transaction.support.TransactionSynchronizationM
public class DoBiz4TestTask extends QuartzJobBean{
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
EntityManagerFactory emf =
EntityManager em =
scheduler = context.getScheduler();
ApplicationContext ac = (ApplicationContext)scheduler.getContext().get("theScheduler");
Trigger trigger = context.getTrigger();
emf = (EntityManagerFactory) ac.getBean("entityManagerFactory", EntityManagerFactory.class);
em = emf.createEntityManager();
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
doBiz(scheduler,trigger);
}catch(Exception e){
e.printStackTrace();
//logger.error(e.getMessage());
if(em!=null){
em.close();
private void doBiz(Scheduler
scheduler,Trigger trigger) {
//获取触发器名称
String triggerName = trigger.getName();
//根据触发器名称得到对应的任务Id
Integer id = Integer.valueOf(triggerName.split("_")[1]);
//处理指定的任务
//TODO: ...
System.out.println("triggerName === "+triggerName);
//根据触发器名称得到对应的任务Id
if(null != trigger){
//执行完移除该任务
scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());
}catch(Exception e){
e.printStackTrace();
3.配置文件中加入
&bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="net.nilm61.timeTask.DoAutoRepayBidTask"/&
&!-- &property name="jobDataMap" &&/property& --&
&bean id="DoBiz4TestTask" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="net.nilm61.timeTask.DoBiz4TestTask"/&
&!-- &property name="jobDataMap" &&/property& --&
&bean id="AutoRepayTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="jobDetail"/&
&property name="cronExpression" value="0 0/1 14-18 * * ?"/&
&bean id="DoBiz4TestTaskss" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="DoBiz4TestTask"/&
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="AutoRepayTrigger"/&
&/property&
&property name="applicationContextSchedulerContextKey"&
&value&theScheduler&/value&
&/property&
浏览: 113150 次
来自: 北京
我的也是，看完特地登陆来，赞一个！
这个少了 种情况吧。就是一个时间段完全包含另外一个时间段，这应 ...
vip 写道为什么会报NULL错误，路径是 ...
为什么会报NULL错误，
路径是对的啊。
68行报NULL错误 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Spring中Quartz调度器的使用 13:25Quartz使用Trigger, Job以及JobDetail等对象来进行各种类型的任务调度。关于Quartz的基本概念，请参阅http://www.opensymphony.com/quartz。为了让基于Spring的应用程序方便使用，Spring提供了一些类来简化Quartz的用法。 下文主要介绍一下Spring对Quartz的使用。
一、Quartz的特点
* 按作业类的继承方式来分，主要有以下两种：
1.作业类继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
2.作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
注：个人比较推崇第二种，因为这种方式下的作业类仍然是POJO。
* 按任务调度的触发时机来分，主要有以下两种：
1.每隔指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.SimpleTriggerBean
2.每到指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.CronTriggerBean
注：这两种触发方式均可以跟两种作业继承方式相互组合来使用。
下面简单演示一下在Spring对Quartz的用法。
二、作业类继承org.springframework.scheduling.quartz.QuartzJobBean类，每到指定时间则触发一次
1.编写作业类
package bean.jobDetailB
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
public class Job1 extends QuartzJobBean {
private static int i = 0;
&&& //调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout =
* 要调度的具体任务
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("继承QuartzJobBean的方式-调度" + ++i + "进行中...");
2.配置作业类
&!-- 作业使用继承QuartzJobBean的方式& --&
&bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="bean.jobDetailBean.Job1" /&
&property name="jobDataAsMap"&
&entry key="timeout" value="0" /&
&/property&
3.配置作业调度的触发方式
&!-- 对应于作业继QuartzJobBean类的方式& --&
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job1" /&
"cronExpression"的配置说明
字段&& 允许值&& 允许的特殊字符
秒&&& 0-59&&& , - * /
分&&& 0-59&&& , - * /
小时&&& 0-23&&& , - * /
日期&&& 1-31&&& , - * ? / L W C
月份&&& 1-12 或者 JAN-DEC&&& , - * /
星期&&& 1-7 或者 SUN-SAT&&& , - * ? / L C #
年（可选）&&& 留空, &&& , - * /
? 你不想设置那个字段
&!-- 每分钟的第0,10,20,30,40,50秒调度一次 --&
&property name="cronExpression" value="0,10,20,30,40,50 * * * * ?" /&
4.配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
5.开启调度
import org.springframework.beans.factory.BeanF
import org.springframework.context.support.ClassPathXmlApplicationC
public class ScheduleTest {
public static void main(String[] args){
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext*.xml");
6.调度执行的结果
继承QuartzJobBean的方式-调度1进行中...
继承QuartzJobBean的方式-调度2进行中...
继承QuartzJobBean的方式-调度3进行中...
继承QuartzJobBean的方式-调度4进行中...
继承QuartzJobBean的方式-调度5进行中...
继承QuartzJobBean的方式-调度6进行中...
继承QuartzJobBean的方式-调度7进行中...
继承QuartzJobBean的方式-调度8进行中...
继承QuartzJobBean的方式-调度9进行中...
三、作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类，每隔指定时间则触发一次
1.编写作业类
package bean.jobDetailB
public class Job2 {
private static int i = 0;
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度" + ++i + "进行中...");
2.配置作业类
&bean id="job2"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&bean class="bean.jobDetailBean.Job2" /&
&/property&
&property name="targetMethod" value="doJob2" /&
&property name="concurrent" value="false" /&&!-- 作业不并发调度 --&
3.配置作业调度的触发方式
&bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"&
&property name="jobDetail" ref="job2" /&
&property name="startDelay" value="0" /&&!-- 调度工厂实例化后，经过0秒开始执行调度 --&
&property name="repeatInterval" value="2000" /&&!-- 每2秒调度一次 --&
4.配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="simpleTrigger" /&
&/property&
5.开启调度
import org.springframework.beans.factory.BeanF
import org.springframework.context.support.ClassPathXmlApplicationC
public class ScheduleTest {
public static void main(String[] args){
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext*.xml");
6.调度执行的结果
不继承QuartzJobBean方式-调度1进行中...
不继承QuartzJobBean方式-调度2进行中...
不继承QuartzJobBean方式-调度3进行中...
不继承QuartzJobBean方式-调度4进行中...
不继承QuartzJobBean方式-调度5进行中...
不继承QuartzJobBean方式-调度6进行中...
不继承QuartzJobBean方式-调度7进行中...
不继承QuartzJobBean方式-调度8进行中...
不继承QuartzJobBean方式-调度9进行中...
不继承QuartzJobBean方式-调度10进行中...
liangzedong
浏览: 3346 次
来自: 广州
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Spring quartz定时器动态多任务实现
项目中经常会碰到需要定时执行的任务，并且需要执行什么任务，以及任务执行的时间都由用户自定义的需求。quartz是比较常用的定时器工具，并且在spring框架中也已经做了很好的集成，所以在以spring+hibernate+struts的主流架构中，我们可以采用quartz来做定时器任务的解决方案，下面，我们来看下如何在项目中使用quartz来做动态多任务定时器功能。
1.简单单任务定时器的spring配置
view plaincopy to clipboardprint?&!-- 配置定时任务,用于初始化定时器 --&
&bean id="InitJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="ReportJobTodo"/&
&/property&
&property name="targetMethod"&
&value&initJobTrigger&/value&
&/property&
&property name="concurrent" value ="false"/&
&bean id="ReportJobTodo"
class="cn.com.gsoft.report.timetask.ReportJobTodo"&
&bean id="InitTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="InitJobDetail"/&
&/property&
&property name="cronExpression"&
&value&* * * * * ?&/value&
&/property&
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="InitTrigger"/&
&/property&
&!-- 配置定时任务,用于初始化定时器 --& &bean id="InitJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="ReportJobTodo"/&
&/property&
&property name="targetMethod"&
&value&initJobTrigger&/value&
&/property&
&property name="concurrent" value ="false"/&
&/bean& &bean id="ReportJobTodo"
class="cn.com.gsoft.report.timetask.ReportJobTodo"& &/bean& &bean id="InitTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="InitJobDetail"/&
&/property&
&property name="cronExpression"&
&value&* * * * * ?&/value&
&/property& &/bean& &bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="InitTrigger"/&
&/property& &/bean&
说明：(1).InitJobDetail实例声明了需要执行的任务。其中targetObject说明了需要执行的方法所在的实例对象，targetMethod说明了要执行的方法，concurrent用于说明多个任务是否同步执行。
(2).InitTrigger声明了一个触发器。jobDetail属性指明需要执行的任务，cronExpression声明了该任务在什么时候执行，该表达式跟linux下的crontab定时程序中使用的表达式是一样的，具体使用方法可以参考文后的参考资料。
(3).SchedulerFactoryBean中可以定义多个触发器，以实现多任务。
2.动态多任务实现
实现方式：用户在前台自行维护任务列表和任务执行时间，后台将任务执行时间解析成对应的cronexpression后与任务列表一起保存到数据库中。在服务器运行期间添加的任务通过验证的（quartz会验证cronexpression是否合法以及对应时间是否已经过期）将直接添加一个任务以及触发器。如果服务器重启，在项目启动时读取配置文件执行一次任务初始化动作，保证通过验证的任务能在触发队列中，并在到达指定时间时能够触发执行。
(1).在applicationContext.xml中添加如1中的配置，配置的任务只执行一次后即被禁用，initJobTrigger方法如下：
view plaincopy to clipboardprint?/**
* 容器启动时初始化任务
* @throws SchedulerException
* @throws ParseException
public void initJobTrigger() throws SchedulerException, ParseException{
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//获取任务列表的HQL语句
String hql = "from ReportJob r where r.enabled = ?";
List list = baseDao.selectByHql(hql, new Object[]{ReportJobConstants.TRUE_STRING});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务对象
ReportJob rj = (ReportJob)ite.next();
//定时表达式
String cronExpression = rj.getCronExpression();
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为ReportJobTodo.class
JobDetail jobDetail =
new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
rj.setEnabled(ReportJobConstants.FALSE_STRING);
baseDao.updateObject(rj);
//初始化任务只需要执行一次，执行一次后移除初始化触发器
scheduler.unscheduleJob("InitTrigger", Scheduler.DEFAULT_GROUP);
//任务启动
scheduler.start();
* 容器启动时初始化任务
* @throws SchedulerException
* @throws ParseException
*/ public void initJobTrigger() throws SchedulerException, ParseException{
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//获取任务列表的HQL语句
String hql = "from ReportJob r where r.enabled = ?";
List list = baseDao.selectByHql(hql, new Object[]{ReportJobConstants.TRUE_STRING});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务对象
ReportJob rj = (ReportJob)ite.next();
//定时表达式
String cronExpression = rj.getCronExpression();
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为ReportJobTodo.class
JobDetail jobDetail =
new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
rj.setEnabled(ReportJobConstants.FALSE_STRING);
baseDao.updateObject(rj);
//初始化任务只需要执行一次，执行一次后移除初始化触发器
scheduler.unscheduleJob("InitTrigger", Scheduler.DEFAULT_GROUP);
//任务启动
scheduler.start(); }
(2).所有的触发器执行的任务类均为ReportJobTodo.class，ReportJobTodo需要实现接口：org.quartz.Job中的方法execute方法，参考代码如下：
view plaincopy to clipboardprint?/**
* 报表生成任务
public void execute(JobExecutionContext je) throws JobExecutionException {
//获取触发器名称
String triggerName = je.getTrigger().getName();
//根据触发器名称得到对应的任务Id
Long reportJobGuId = Long.valueOf(triggerName.split("_")[1]);
//获取任务
ReportJob rj = (ReportJob)baseDao.loadObject(ReportJob.class, reportJobGuId);
//获取任务细节列表
String hql = "from ReportJobDetail t where reportJobGuId = ?";
List list = baseDao.selectByHql(hql, new Object[]{reportJobGuId});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务细节对象
ReportJobDetail rjd = (ReportJobDetail)ite.next();
//根据获取的任务对象来做具体操作
//something to do
//如果有需要，可以将执行过的任务移除
je.getScheduler().unscheduleJob(triggerName, je.getTrigger().getGroup());
//} catch (SchedulerException e) {
throw new BusinessException(e.getMessage());
* 报表生成任务
*/ public void execute(JobExecutionContext je) throws JobExecutionException {
//获取触发器名称
String triggerName = je.getTrigger().getName();
//根据触发器名称得到对应的任务Id
Long reportJobGuId = Long.valueOf(triggerName.split("_")[1]);
//获取任务
ReportJob rj = (ReportJob)baseDao.loadObject(ReportJob.class, reportJobGuId);
//获取任务细节列表
String hql = "from ReportJobDetail t where reportJobGuId = ?";
List list = baseDao.selectByHql(hql, new Object[]{reportJobGuId});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务细节对象
ReportJobDetail rjd = (ReportJobDetail)ite.next();
//根据获取的任务对象来做具体操作
//something to do
//如果有需要，可以将执行过的任务移除
// je.getScheduler().unscheduleJob(triggerName, je.getTrigger().getGroup());
//} catch (SchedulerException e) {
// throw new BusinessException(e.getMessage());
(3).对于每一个任务提供启用和禁用的功能，启用时将任务加入到任务执行列表中，禁用时移除：
view plaincopy to clipboardprint?/**
* 启动或禁止任务触发器
* @param condition
* @throws SchedulerException
* @throws ParseException
public static void enableTrigger(ReportJobCondition condition) throws SchedulerException, ParseException{
//获取任务对象的HQL语句
String hql = "from ReportJob t where t.guId = ?";
List list = dao.selectByHql(hql, new Object[]{condition.getObjGuId()});
if(null != list && list.size() & 0){
//任务对象
ReportJob rj = (ReportJob)list.get(0);
//定时器表达式
String cronExpression = rj.getCronExpression();
//获取调度工厂对象
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//启动任务
if(ReportJobConstants.TRUE_STRING.equals(condition.getEnabled())){
//添加任务
JobDetail jobDetail = new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//添加触发器
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动任务
scheduler.scheduleJob(jobDetail, cronTrigger);
rj.setEnabled(ReportJobConstants.TRUE_STRING);
dao.updateObject(rj);
dao.flush();
//移除触发器
CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
if(null != cronTrigger){
scheduler.unscheduleJob(cronTrigger.getName(), Scheduler.DEFAULT_GROUP);
rj.setEnabled(ReportJobConstants.FALSE_STRING);
dao.updateObject(rj);
dao.flush();
//调度器启动
scheduler.start();
* 启动或禁止任务触发器
* @param condition
* @throws SchedulerException
* @throws ParseException
*/ public static void enableTrigger(ReportJobCondition condition) throws SchedulerException, ParseException{
//获取任务对象的HQL语句
String hql = "from ReportJob t where t.guId = ?";
List list = dao.selectByHql(hql, new Object[]{condition.getObjGuId()});
if(null != list && list.size() & 0){
//任务对象
ReportJob rj = (ReportJob)list.get(0);
//定时器表达式
String cronExpression = rj.getCronExpression();
//获取调度工厂对象
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//启动任务
if(ReportJobConstants.TRUE_STRING.equals(condition.getEnabled())){
//添加任务
JobDetail jobDetail = new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//添加触发器
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动任务
scheduler.scheduleJob(jobDetail, cronTrigger);
rj.setEnabled(ReportJobConstants.TRUE_STRING);
dao.updateObject(rj);
dao.flush();
//移除触发器
CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
if(null != cronTrigger){
scheduler.unscheduleJob(cronTrigger.getName(), Scheduler.DEFAULT_GROUP);
rj.setEnabled(ReportJobConstants.FALSE_STRING);
dao.updateObject(rj);
dao.flush();
//调度器启动
scheduler.start();
参考资料：
1.cronExpression介绍：
2.quartz官方文档：
本文来自CSDN博客，转载请标明出处：
没有更多推荐了，
不良信息举报
举报内容：
Spring quartz定时器动态多任务实现
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！}
参见上一篇 可以知道如何设置多个规则的定时任务，但有时需要客户自己设置指定的时间来启动新的任务处理不同的事情。
实现方式：用户在前台自行维护任务列表和任务执行时间，后台将任务执行时间解析成对应的cronexpression后与任务列表一起保存到数据库中。在 服务器运行期间添加的任务通过验证的（quartz会验证cronexpression是否合法以及对应时间是否已经过期）将直接添加一个任务以及触发器。
简而言之，就是自己创建一个新的jobdetail ---新的 Trigger 指定行的定时规则--启动新增定时器任务
(执行完新任务可以选择取消新的任务)
这里实现的思路是：按照定时规则扫描用户设置的任务开始时间，如定时发短信，有定时的就发出去。
1、首先加入定时规则扫描的任务，
package net.nilm61.timeT
import java.text.DateF
import java.text.SimpleDateF
import java.util.D
import java.util.L
import java.util.L
import javax.persistence.EntityM
import javax.persistence.EntityManagerF
import net.nilm61.entity.R
import net.nilm61.service.RepayS
import org.quartz.CronT
import org.quartz.JobD
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.quartz.S
import org.quartz.SchedulerE
import org.springframework.context.ApplicationC
import org.springframework.orm.jpa.EntityManagerH
import org.springframework.scheduling.quartz.QuartzJobB
import org.springframework.transaction.support.TransactionSynchronizationM
public class AutoRepayBidTask extends QuartzJobBean{
private RepayService repayS
public void setRepayService(RepayService repayService) {
this.repayService = repayS
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
EntityManagerFactory emf =
EntityManager em =
//System.out.println("Start!!!!!!!!!");
scheduler = context.getScheduler();
ApplicationContext ac = (ApplicationContext)scheduler.getContext().get("theScheduler");
emf = (EntityManagerFactory) ac.getBean("entityManagerFactory", EntityManagerFactory.class);
em = emf.createEntityManager();
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
RepayService repayService = (RepayService)ac.getBean("recordService");
setRepayService(repayService);
doBiz(scheduler);
}catch(Exception e){
e.printStackTrace();
//logger.error(e.getMessage());
//System.out.println("over!!!!!!!!!!!!!!!!!");
if(em!=null){
em.close();
private void doBiz(Scheduler scheduler) {
List&Repay&
repays = repayService.getByAutoRepay();
//从数据库中查询定时处理的条目
if(repays != null && repays.size() &0){
DateFormat df = new SimpleDateFormat("ss mm HH dd MM ? yyyy ",Locale.ENGLISH);
for(Repay repay : repays){
actualTime =repay.getActualTime();
if(actualTime != null){
cronExpression = df.format(actualTime);
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为DoBiz4TestTask.class
JobDetail jobDetail =
new JobDetail("AutoRepayBidsJob_" + repay.getId(), Scheduler.DEFAULT_GROUP,
DoBiz4TestTask.class);
CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(
"AutoRepayBidsTrigger_"+repay.getId(), Scheduler.DEFAULT_GROUP);
if(cronTrigger == null){
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
cronTrigger = new CronTrigger("AutoRepayBidsTrigger_" + repay.getId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
System.out.println(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
2.增加DoBiz4TestTask （具体执行的定时任务）
所有的触发器执行的任务类均为DoBiz4TestTask.class，DoBiz4TestTask 需要实现接口：org.quartz.Job中的方法execute方法，这里继承的是org.quartz.Job的子类org.springframework.scheduling.quartz.QuartzJobBean 参考代码如下
package net.nilm61.timeT
import javax.persistence.EntityM
import javax.persistence.EntityManagerF
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.quartz.S
import org.quartz.T
import org.springframework.context.ApplicationC
import org.springframework.orm.jpa.EntityManagerH
import org.springframework.scheduling.quartz.QuartzJobB
import org.springframework.transaction.support.TransactionSynchronizationM
public class DoBiz4TestTask extends QuartzJobBean{
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
EntityManagerFactory emf =
EntityManager em =
scheduler = context.getScheduler();
ApplicationContext ac = (ApplicationContext)scheduler.getContext().get("theScheduler");
Trigger trigger = context.getTrigger();
emf = (EntityManagerFactory) ac.getBean("entityManagerFactory", EntityManagerFactory.class);
em = emf.createEntityManager();
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
doBiz(scheduler,trigger);
}catch(Exception e){
e.printStackTrace();
//logger.error(e.getMessage());
if(em!=null){
em.close();
private void doBiz(Scheduler
scheduler,Trigger trigger) {
//获取触发器名称
String triggerName = trigger.getName();
//根据触发器名称得到对应的任务Id
Integer id = Integer.valueOf(triggerName.split("_")[1]);
//处理指定的任务
//TODO: ...
System.out.println("triggerName === "+triggerName);
//根据触发器名称得到对应的任务Id
if(null != trigger){
//执行完移除该任务
scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());
}catch(Exception e){
e.printStackTrace();
3.配置文件中加入
&bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="net.nilm61.timeTask.DoAutoRepayBidTask"/&
&!-- &property name="jobDataMap" &&/property& --&
&bean id="DoBiz4TestTask" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="net.nilm61.timeTask.DoBiz4TestTask"/&
&!-- &property name="jobDataMap" &&/property& --&
&bean id="AutoRepayTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="jobDetail"/&
&property name="cronExpression" value="0 0/1 14-18 * * ?"/&
&bean id="DoBiz4TestTaskss" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="DoBiz4TestTask"/&
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="AutoRepayTrigger"/&
&/property&
&property name="applicationContextSchedulerContextKey"&
&value&theScheduler&/value&
&/property&
浏览: 113150 次
来自: 北京
我的也是，看完特地登陆来，赞一个！
这个少了 种情况吧。就是一个时间段完全包含另外一个时间段，这应 ...
vip 写道为什么会报NULL错误，路径是 ...
为什么会报NULL错误，
路径是对的啊。
68行报NULL错误 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Spring中Quartz调度器的使用 13:25Quartz使用Trigger, Job以及JobDetail等对象来进行各种类型的任务调度。关于Quartz的基本概念，请参阅http://www.opensymphony.com/quartz。为了让基于Spring的应用程序方便使用，Spring提供了一些类来简化Quartz的用法。 下文主要介绍一下Spring对Quartz的使用。
一、Quartz的特点
* 按作业类的继承方式来分，主要有以下两种：
1.作业类继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
2.作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
注：个人比较推崇第二种，因为这种方式下的作业类仍然是POJO。
* 按任务调度的触发时机来分，主要有以下两种：
1.每隔指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.SimpleTriggerBean
2.每到指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.CronTriggerBean
注：这两种触发方式均可以跟两种作业继承方式相互组合来使用。
下面简单演示一下在Spring对Quartz的用法。
二、作业类继承org.springframework.scheduling.quartz.QuartzJobBean类，每到指定时间则触发一次
1.编写作业类
package bean.jobDetailB
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
public class Job1 extends QuartzJobBean {
private static int i = 0;
&&& //调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout =
* 要调度的具体任务
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("继承QuartzJobBean的方式-调度" + ++i + "进行中...");
2.配置作业类
&!-- 作业使用继承QuartzJobBean的方式& --&
&bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="bean.jobDetailBean.Job1" /&
&property name="jobDataAsMap"&
&entry key="timeout" value="0" /&
&/property&
3.配置作业调度的触发方式
&!-- 对应于作业继QuartzJobBean类的方式& --&
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job1" /&
"cronExpression"的配置说明
字段&& 允许值&& 允许的特殊字符
秒&&& 0-59&&& , - * /
分&&& 0-59&&& , - * /
小时&&& 0-23&&& , - * /
日期&&& 1-31&&& , - * ? / L W C
月份&&& 1-12 或者 JAN-DEC&&& , - * /
星期&&& 1-7 或者 SUN-SAT&&& , - * ? / L C #
年（可选）&&& 留空, &&& , - * /
? 你不想设置那个字段
&!-- 每分钟的第0,10,20,30,40,50秒调度一次 --&
&property name="cronExpression" value="0,10,20,30,40,50 * * * * ?" /&
4.配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
5.开启调度
import org.springframework.beans.factory.BeanF
import org.springframework.context.support.ClassPathXmlApplicationC
public class ScheduleTest {
public static void main(String[] args){
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext*.xml");
6.调度执行的结果
继承QuartzJobBean的方式-调度1进行中...
继承QuartzJobBean的方式-调度2进行中...
继承QuartzJobBean的方式-调度3进行中...
继承QuartzJobBean的方式-调度4进行中...
继承QuartzJobBean的方式-调度5进行中...
继承QuartzJobBean的方式-调度6进行中...
继承QuartzJobBean的方式-调度7进行中...
继承QuartzJobBean的方式-调度8进行中...
继承QuartzJobBean的方式-调度9进行中...
三、作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类，每隔指定时间则触发一次
1.编写作业类
package bean.jobDetailB
public class Job2 {
private static int i = 0;
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度" + ++i + "进行中...");
2.配置作业类
&bean id="job2"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&bean class="bean.jobDetailBean.Job2" /&
&/property&
&property name="targetMethod" value="doJob2" /&
&property name="concurrent" value="false" /&&!-- 作业不并发调度 --&
3.配置作业调度的触发方式
&bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"&
&property name="jobDetail" ref="job2" /&
&property name="startDelay" value="0" /&&!-- 调度工厂实例化后，经过0秒开始执行调度 --&
&property name="repeatInterval" value="2000" /&&!-- 每2秒调度一次 --&
4.配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="simpleTrigger" /&
&/property&
5.开启调度
import org.springframework.beans.factory.BeanF
import org.springframework.context.support.ClassPathXmlApplicationC
public class ScheduleTest {
public static void main(String[] args){
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext*.xml");
6.调度执行的结果
不继承QuartzJobBean方式-调度1进行中...
不继承QuartzJobBean方式-调度2进行中...
不继承QuartzJobBean方式-调度3进行中...
不继承QuartzJobBean方式-调度4进行中...
不继承QuartzJobBean方式-调度5进行中...
不继承QuartzJobBean方式-调度6进行中...
不继承QuartzJobBean方式-调度7进行中...
不继承QuartzJobBean方式-调度8进行中...
不继承QuartzJobBean方式-调度9进行中...
不继承QuartzJobBean方式-调度10进行中...
liangzedong
浏览: 3346 次
来自: 广州
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Spring quartz定时器动态多任务实现
项目中经常会碰到需要定时执行的任务，并且需要执行什么任务，以及任务执行的时间都由用户自定义的需求。quartz是比较常用的定时器工具，并且在spring框架中也已经做了很好的集成，所以在以spring+hibernate+struts的主流架构中，我们可以采用quartz来做定时器任务的解决方案，下面，我们来看下如何在项目中使用quartz来做动态多任务定时器功能。
1.简单单任务定时器的spring配置
view plaincopy to clipboardprint?&!-- 配置定时任务,用于初始化定时器 --&
&bean id="InitJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="ReportJobTodo"/&
&/property&
&property name="targetMethod"&
&value&initJobTrigger&/value&
&/property&
&property name="concurrent" value ="false"/&
&bean id="ReportJobTodo"
class="cn.com.gsoft.report.timetask.ReportJobTodo"&
&bean id="InitTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="InitJobDetail"/&
&/property&
&property name="cronExpression"&
&value&* * * * * ?&/value&
&/property&
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="InitTrigger"/&
&/property&
&!-- 配置定时任务,用于初始化定时器 --& &bean id="InitJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="ReportJobTodo"/&
&/property&
&property name="targetMethod"&
&value&initJobTrigger&/value&
&/property&
&property name="concurrent" value ="false"/&
&/bean& &bean id="ReportJobTodo"
class="cn.com.gsoft.report.timetask.ReportJobTodo"& &/bean& &bean id="InitTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="InitJobDetail"/&
&/property&
&property name="cronExpression"&
&value&* * * * * ?&/value&
&/property& &/bean& &bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="InitTrigger"/&
&/property& &/bean&
说明：(1).InitJobDetail实例声明了需要执行的任务。其中targetObject说明了需要执行的方法所在的实例对象，targetMethod说明了要执行的方法，concurrent用于说明多个任务是否同步执行。
(2).InitTrigger声明了一个触发器。jobDetail属性指明需要执行的任务，cronExpression声明了该任务在什么时候执行，该表达式跟linux下的crontab定时程序中使用的表达式是一样的，具体使用方法可以参考文后的参考资料。
(3).SchedulerFactoryBean中可以定义多个触发器，以实现多任务。
2.动态多任务实现
实现方式：用户在前台自行维护任务列表和任务执行时间，后台将任务执行时间解析成对应的cronexpression后与任务列表一起保存到数据库中。在服务器运行期间添加的任务通过验证的（quartz会验证cronexpression是否合法以及对应时间是否已经过期）将直接添加一个任务以及触发器。如果服务器重启，在项目启动时读取配置文件执行一次任务初始化动作，保证通过验证的任务能在触发队列中，并在到达指定时间时能够触发执行。
(1).在applicationContext.xml中添加如1中的配置，配置的任务只执行一次后即被禁用，initJobTrigger方法如下：
view plaincopy to clipboardprint?/**
* 容器启动时初始化任务
* @throws SchedulerException
* @throws ParseException
public void initJobTrigger() throws SchedulerException, ParseException{
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//获取任务列表的HQL语句
String hql = "from ReportJob r where r.enabled = ?";
List list = baseDao.selectByHql(hql, new Object[]{ReportJobConstants.TRUE_STRING});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务对象
ReportJob rj = (ReportJob)ite.next();
//定时表达式
String cronExpression = rj.getCronExpression();
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为ReportJobTodo.class
JobDetail jobDetail =
new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
rj.setEnabled(ReportJobConstants.FALSE_STRING);
baseDao.updateObject(rj);
//初始化任务只需要执行一次，执行一次后移除初始化触发器
scheduler.unscheduleJob("InitTrigger", Scheduler.DEFAULT_GROUP);
//任务启动
scheduler.start();
* 容器启动时初始化任务
* @throws SchedulerException
* @throws ParseException
*/ public void initJobTrigger() throws SchedulerException, ParseException{
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//获取任务列表的HQL语句
String hql = "from ReportJob r where r.enabled = ?";
List list = baseDao.selectByHql(hql, new Object[]{ReportJobConstants.TRUE_STRING});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务对象
ReportJob rj = (ReportJob)ite.next();
//定时表达式
String cronExpression = rj.getCronExpression();
//新建任务，任务组为默认的Scheduler.DEFAULT_GROUP，需要执行的任务类为ReportJobTodo.class
JobDetail jobDetail =
new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//新建触发器，触发器为默认的Scheduler.DEFAULT_GROUP
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//为触发器设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动新增定时器任务
scheduler.scheduleJob(jobDetail, cronTrigger);
}catch(SchedulerException e){
//启动验证失败，设置任务标记为禁用
e.printStackTrace();
rj.setEnabled(ReportJobConstants.FALSE_STRING);
baseDao.updateObject(rj);
//初始化任务只需要执行一次，执行一次后移除初始化触发器
scheduler.unscheduleJob("InitTrigger", Scheduler.DEFAULT_GROUP);
//任务启动
scheduler.start(); }
(2).所有的触发器执行的任务类均为ReportJobTodo.class，ReportJobTodo需要实现接口：org.quartz.Job中的方法execute方法，参考代码如下：
view plaincopy to clipboardprint?/**
* 报表生成任务
public void execute(JobExecutionContext je) throws JobExecutionException {
//获取触发器名称
String triggerName = je.getTrigger().getName();
//根据触发器名称得到对应的任务Id
Long reportJobGuId = Long.valueOf(triggerName.split("_")[1]);
//获取任务
ReportJob rj = (ReportJob)baseDao.loadObject(ReportJob.class, reportJobGuId);
//获取任务细节列表
String hql = "from ReportJobDetail t where reportJobGuId = ?";
List list = baseDao.selectByHql(hql, new Object[]{reportJobGuId});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务细节对象
ReportJobDetail rjd = (ReportJobDetail)ite.next();
//根据获取的任务对象来做具体操作
//something to do
//如果有需要，可以将执行过的任务移除
je.getScheduler().unscheduleJob(triggerName, je.getTrigger().getGroup());
//} catch (SchedulerException e) {
throw new BusinessException(e.getMessage());
* 报表生成任务
*/ public void execute(JobExecutionContext je) throws JobExecutionException {
//获取触发器名称
String triggerName = je.getTrigger().getName();
//根据触发器名称得到对应的任务Id
Long reportJobGuId = Long.valueOf(triggerName.split("_")[1]);
//获取任务
ReportJob rj = (ReportJob)baseDao.loadObject(ReportJob.class, reportJobGuId);
//获取任务细节列表
String hql = "from ReportJobDetail t where reportJobGuId = ?";
List list = baseDao.selectByHql(hql, new Object[]{reportJobGuId});
if(null != list && list.size() & 0){
Iterator ite = list.iterator();
while(ite.hasNext()){
//任务细节对象
ReportJobDetail rjd = (ReportJobDetail)ite.next();
//根据获取的任务对象来做具体操作
//something to do
//如果有需要，可以将执行过的任务移除
// je.getScheduler().unscheduleJob(triggerName, je.getTrigger().getGroup());
//} catch (SchedulerException e) {
// throw new BusinessException(e.getMessage());
(3).对于每一个任务提供启用和禁用的功能，启用时将任务加入到任务执行列表中，禁用时移除：
view plaincopy to clipboardprint?/**
* 启动或禁止任务触发器
* @param condition
* @throws SchedulerException
* @throws ParseException
public static void enableTrigger(ReportJobCondition condition) throws SchedulerException, ParseException{
//获取任务对象的HQL语句
String hql = "from ReportJob t where t.guId = ?";
List list = dao.selectByHql(hql, new Object[]{condition.getObjGuId()});
if(null != list && list.size() & 0){
//任务对象
ReportJob rj = (ReportJob)list.get(0);
//定时器表达式
String cronExpression = rj.getCronExpression();
//获取调度工厂对象
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//启动任务
if(ReportJobConstants.TRUE_STRING.equals(condition.getEnabled())){
//添加任务
JobDetail jobDetail = new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//添加触发器
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动任务
scheduler.scheduleJob(jobDetail, cronTrigger);
rj.setEnabled(ReportJobConstants.TRUE_STRING);
dao.updateObject(rj);
dao.flush();
//移除触发器
CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
if(null != cronTrigger){
scheduler.unscheduleJob(cronTrigger.getName(), Scheduler.DEFAULT_GROUP);
rj.setEnabled(ReportJobConstants.FALSE_STRING);
dao.updateObject(rj);
dao.flush();
//调度器启动
scheduler.start();
* 启动或禁止任务触发器
* @param condition
* @throws SchedulerException
* @throws ParseException
*/ public static void enableTrigger(ReportJobCondition condition) throws SchedulerException, ParseException{
//获取任务对象的HQL语句
String hql = "from ReportJob t where t.guId = ?";
List list = dao.selectByHql(hql, new Object[]{condition.getObjGuId()});
if(null != list && list.size() & 0){
//任务对象
ReportJob rj = (ReportJob)list.get(0);
//定时器表达式
String cronExpression = rj.getCronExpression();
//获取调度工厂对象
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//启动任务
if(ReportJobConstants.TRUE_STRING.equals(condition.getEnabled())){
//添加任务
JobDetail jobDetail = new JobDetail("reportJob_" + rj.getGuId(), Scheduler.DEFAULT_GROUP,
ReportJobTodo.class);
//添加触发器
CronTrigger cronTrigger = new CronTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
//设置定时表达式
cronTrigger.setCronExpression(cronExpression);
//启动任务
scheduler.scheduleJob(jobDetail, cronTrigger);
rj.setEnabled(ReportJobConstants.TRUE_STRING);
dao.updateObject(rj);
dao.flush();
//移除触发器
CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger("trigger_" + rj.getGuId(), Scheduler.DEFAULT_GROUP);
if(null != cronTrigger){
scheduler.unscheduleJob(cronTrigger.getName(), Scheduler.DEFAULT_GROUP);
rj.setEnabled(ReportJobConstants.FALSE_STRING);
dao.updateObject(rj);
dao.flush();
//调度器启动
scheduler.start();
参考资料：
1.cronExpression介绍：
2.quartz官方文档：
本文来自CSDN博客，转载请标明出处：
没有更多推荐了，
不良信息举报
举报内容：
Spring quartz定时器动态多任务实现
举报原因：
原文地址：
原因补充：
最多只允许输入30个字
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！}
我要回帖
更多关于 苹果6多任务怎么设置 的文章
更多推荐
- ·想找个小时候玩过的像素仙侠网游回合制RPG游戏？
- ·如何进行软件怎样开发一个软件？
- ·怎样写软件程序怎么编写开发运行环境
- ·真主安拉是男的还是女的什么意思
- ·星际2的cpu,gpu资源cpu满载gpu占用率低怎么解决？
- ·哪个版本的热血街霸360版本下载好
- ·为什么我买的手机键盘玩不了穿越火线安卓外接键盘王者之战怎么改键，求大神指导
- ·我这配置消逝的光芒低配置补丁特效能开到多少 CPU:E3 1231 V3 主板：华硕B85-PRO GA
- ·samantha美少女战士周年 钱包系列正版多少钱
- ·大话大话西游2免费版男鬼鬼召唤兽怎么打造
- ·冬之乐乐事薯片大礼包包多少钱
- ·三界包括哪些组成的?从英语什么时候形成成的?
- ·我的世界怎么做化石的世电脑游戏1.8.1怎么得化石
- ·和一岁的孩子玩什么样跟孩子玩的亲子游戏戏
- ·大话西游 镜花影 高清手游方壶胜镜
- ·三国战记风云再起技能中41之后技能为什么不能升级
- ·拳皇98终极之战ol礼包山崎龙二蔡宝奇哪个更厉害
- ·中恒商城有没有跑江湖的吉列的刀架通用吗刀架
- ·全民超神全民奇迹召唤师武器从50级升到70级要多少经验
- ·Quartz新ipad多任务怎么设置多任务
- ·安卓系统怎么重玩列王
- ·问道自动领取任务玉鉴上人那怎么领不了1星
- ·猎人从森林里白狼王带走猎人了什么主要讲了什么
- ·LOL借号玩玩没想到
- ·实况足球2018画面设置3怎么画面有点不清楚，怎么调一下啊
- ·搞一个商加直接面对刷首的公会大家觉得如何降低股票交易佣金？降低商的费用提高刷的佣金！q+++40+++50+++2
- ·天天酷跑伯爵夫人得了10个碎片就可以得夫人了吗
- ·最终幻想13雷光归来pc霆归来技能效果怎么样 技能效果分析讲解
- ·炫迈pin码大全 zhidao.baiducom.com
- ·洪荒小说主角有玲珑塔重生洪荒我是通天教主主的大弟子
- ·我的方块世界游戏的世界，两边会折叠那是什么游戏
- ·金立f303线刷包玩全民超神要用什么游戏手柄
- ·求，游狗新倚天天2不玩的帐号给我个啊。，非常感谢。
- ·boss gt12 gt1050什么时候出的
- ·17173可以交易天龙八部手游元宝交易的元宝吗
