您的位置:

javaquartz(java quartz)

本文目录一览:

如何在java中使用quartz

在java中使用quartz

/** *//**

* 添加一个定时任务,使用默认的任务组名,触发器名,触发器组名

* @param jobName 任务名

* @param job 任务

* @param time 时间设置,参考quartz说明文档

* @throws SchedulerException

* @throws ParseException

*/

public static void addJob(String jobName,Job job,String time)

throws SchedulerException, ParseException{

Scheduler sched = sf.getScheduler();

JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, job.getClass());//任务名,任务组,任务执行类

//触发器

CronTrigger trigger =

new CronTrigger(jobName, TRIGGER_GROUP_NAME);//触发器名,触发器组

trigger.setCronExpression(time);//触发器时间设定

sched.scheduleJob(jobDetail,trigger);

//启动

if(!sched.isShutdown())

sched.start();

}

/** *//**

* 添加一个定时任务

* @param jobName 任务名

* @param jobGroupName 任务组名

* @param triggerName 触发器名

* @param triggerGroupName 触发器组名

* @param job 任务

* @param time 时间设置,参考quartz说明文档

* @throws SchedulerException

* @throws ParseException

*/

public static void addJob(String jobName,String jobGroupName,

String triggerName,String triggerGroupName,

Job job,String time)

throws SchedulerException, ParseException{

Scheduler sched = sf.getScheduler();

JobDetail jobDetail = new JobDetail(jobName, jobGroupName, job.getClass());//任务名,任务组,任务执行类

//触发器

CronTrigger trigger =

new CronTrigger(triggerName, triggerGroupName);//触发器名,触发器组

trigger.setCronExpression(time);//触发器时间设定

sched.scheduleJob(jobDetail,trigger);

if(!sched.isShutdown())

sched.start();

}

/** *//**

* 修改一个任务的触发时间(使用默认的任务组名,触发器名,触发器组名)

* @param jobName

* @param time

* @throws SchedulerException

* @throws ParseException

*/

public static void modifyJobTime(String jobName,String time)

throws SchedulerException, ParseException{

Scheduler sched = sf.getScheduler();

Trigger trigger = sched.getTrigger(jobName,TRIGGER_GROUP_NAME);

if(trigger != null){

CronTrigger ct = (CronTrigger)trigger;

ct.setCronExpression(time);

sched.resumeTrigger(jobName,TRIGGER_GROUP_NAME);

}

}

/** *//**

* 修改一个任务的触发时间

* @param triggerName

* @param triggerGroupName

* @param time

* @throws SchedulerException

* @throws ParseException

*/

public static void modifyJobTime(String triggerName,String triggerGroupName,

String time)

throws SchedulerException, ParseException{

Scheduler sched = sf.getScheduler();

Trigger trigger = sched.getTrigger(triggerName,triggerGroupName);

if(trigger != null){

CronTrigger ct = (CronTrigger)trigger;

//修改时间

ct.setCronExpression(time);

//重启触发器

sched.resumeTrigger(triggerName,triggerGroupName);

}

}

/** *//**

* 移除一个任务(使用默认的任务组名,触发器名,触发器组名)

* @param jobName

* @throws SchedulerException

*/

public static void removeJob(String jobName)

throws SchedulerException{

Scheduler sched = sf.getScheduler();

sched.pauseTrigger(jobName,TRIGGER_GROUP_NAME);//停止触发器

sched.unscheduleJob(jobName,TRIGGER_GROUP_NAME);//移除触发器

sched.deleteJob(jobName,JOB_GROUP_NAME);//删除任务

}

/** *//**

* 移除一个任务

* @param jobName

* @param jobGroupName

* @param triggerName

* @param triggerGroupName

* @throws SchedulerException

*/

public static void removeJob(String jobName,String jobGroupName,

String triggerName,String triggerGroupName)

throws SchedulerException{

Scheduler sched = sf.getScheduler();

sched.pauseTrigger(triggerName,triggerGroupName);//停止触发器

sched.unscheduleJob(triggerName,triggerGroupName);//移除触发器

sched.deleteJob(jobName,jobGroupName);//删除任务

}

java quartz 定时需要的包

1.需要的jar包

实现定时任务 需要quartz-1.5.1.jar和commons-logging-1.1.jar。

2.定义定时任务配置类

该类主要进行定时任务时间的设置和设置对应的定时任务类。

import org.quartz.CronTrigger;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.impl.StdSchedulerFactory;

public class Test{

/**

* 定时任务

*/

public static void cleanUpJob() {

try {

JobDetail jobDetail = new JobDetail();

jobDetail.setName("cleanup");

jobDetail.setJobClass(PrintJob.class);

CronTrigger trigger = new CronTrigger();

trigger.setName("cleanupTrigger");

trigger.setJobName("cleanup");

trigger.setCronExpression("0/5 * * * * ?");

Scheduler sch = StdSchedulerFactory.getDefaultScheduler();

sch.scheduleJob(jobDetail, trigger);

sch.start();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 修改定时任务时间

*/

public static void modifyJobTime(String triggerName, String time) {

System.out.println("modify~~~~~~~~~~~~~~~~");

try {

Scheduler sched = StdSchedulerFactory.getDefaultScheduler();

System.out.println("triggerName " + triggerName);

CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);

if(trigger == null) {

return;

}

String oldTime = trigger.getCronExpression();

System.out.println("oldTime " + oldTime);

if (!oldTime.equalsIgnoreCase(time)) {

System.out.println("time " + time);

// 修改时间

trigger.setCronExpression(time);

}

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

public static void main(String[] args) {

cleanUpJob();

modifyJobTime("cleanupTrigger", "0/2 * * * * ?");

}

}

3.定时任务类

该类主要定义定时任务执行的内容。

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class PrintJob implements Job{

@Override

public void execute(JobExecutionContext arg0) throws JobExecutionException {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

String time = sdf.format(new Date());

System.out.println("print job" + time);

}

}

4.输出结果

modify~~~~~~~~~~~~~~~~

triggerName cleanupTrigger

oldTime 0/5 * * * * ?

time 0/2 * * * * ?

print job2014-12-03 17:06:40.031

print job2014-12-03 17:06:42.015

print job2014-12-03 17:06:44.016

print job2014-12-03 17:06:46.019

print job2014-12-03 17:06:48.019

print job2014-12-03 17:06:50.020

从输出的结果中可以看到,原本的定时任务为每5秒执行一次,但是由于后面对定时任务表达式做了修改,所以后来安照修改后的每2秒执行一次。

java如何利用第三方Quartz实现定时任务

给你一个简单的案例加详细注解

/*

* job是一个接口,只有一个方法void execute(JobExecutionContext context),

* 被调度的作业(类)需实现该接口中execute()方法,

* JobExecutionContext类提供了调度上下文的各种信息。每次执行该Job均重新创建一个Job实例

*/

public class MyJob  implements Job {

//MyJob类为需要定时执行的类,execute为定时执行的方法。一个定时任务对应一个Job实现类。

@Override

public void execute(JobExecutionContext arg0) throws JobExecutionException {

// TODO Auto-generated method stub

perform();

}

public void perform(){ //执行报表统计入口函数

//业务逻辑

System.out.println("执行时间:"+new Date());

}

}

public class QuartzTest5 {

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

//SchedulerFactory 是一个接口,用于Scheduler的创建和管理

SchedulerFactory factory = new StdSchedulerFactory();

//从工厂里面拿到一个scheduler实例

//计划表(可能翻译的不太贴切),现在我们有了要做的内容,

//与调度程序交互的主要API

/*

* Scheduler的生命期,从SchedulerFactory创建它时开始,

到Scheduler调用shutdown()方法时结束;Scheduler被创建后,

可以增加、删除和列举Job和Trigger,以及执行其它与调度相关的操作

(如暂停Trigger)。但是,Scheduler只有在调用start()方法后,

才会真正地触发trigger(即执行job)

*/

Scheduler scheduler = factory.getScheduler();

//具体任务.

//用于定义作业的实例

//JobBuilder - 用于定义/构建JobDetail实例,用于定义作业的实例。

JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();

//Trigger(即触发器) - 定义执行给定作业的计划的组件

//TriggerBuilder - 用于定义/构建触发器实例

CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")

.withSchedule(CronScheduleBuilder.cronSchedule("0/1  * * * * ?")).build();

scheduler.scheduleJob(job, trigger);

scheduler.start();

}

}

Java中定时任务quartz如何将历史数据写入新表

我建议的做法是在数据库中建一些Quartz的表,MySQL的建、删表脚本,最主要的修改是quartz.properties,如果你使用的是其他数据库,可以下载Quartz的distribution,在\docs\dbTables下。然后我们可以启动Bootstrap类,注册、运行定时任务。你可以发现MySQL的表中已经有此定时任务的记录了。

然后你可以停止Bootstrap类,将Bootstrap类中关于注册、启动定时任务的代码删除或注释,然后启动Bootstrap类,看上一次操作注册的定时任务会不会继续运行。

如无意外,看上一次操作注册的定时任务会继续运行。

java quartz job 执行时间配置

第一步:引包

要使用Quartz,必须要引入以下这几个包:

1、log4j-1.2.16

2、quartz-2.1.7

3、slf4j-api-1.6.1.jar

4、slf4j-log4j12-1.6.1.jar

这些包都在下载的Quartz包里面包含着,因此没有必要为寻找这几个包而头疼。

第二步:创建要被定执行的任务类

这一步也很简单,只需要创建一个实现了org.quartz.Job接口的类,并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如:

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class myJob implements Job {

@Override

public void execute(JobExecutionContext arg0) throws JobExecutionException {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(sdf.format(new Date()));

}

}

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class myJob implements Job {

@Override

public void execute(JobExecutionContext arg0) throws JobExecutionException {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(sdf.format(new Date()));

}

}

这个例子很简单,就不用解说了。

第三步:创建任务调度,并执行

这一步应该算是最难的一步的,但其实是非常简单的,直接上代码

import static org.quartz.CronScheduleBuilder.cronSchedule;

import static org.quartz.JobBuilder.newJob;

import static org.quartz.TriggerBuilder.newTrigger;

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.CronTrigger;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerFactory;

import org.quartz.impl.StdSchedulerFactory;

public class Test {

public void go() throws Exception {

// 首先,必需要取得一个Scheduler的引用

SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sched = sf.getScheduler();

//jobs可以在scheduled的sched.start()方法前被调用

//job 1将每隔20秒执行一次

JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();

CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

Date ft = sched.scheduleJob(job, trigger);

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + ",并且以如下重复规则重复执行: " + trigger.getCronExpression());

// job 2将每2分钟执行一次(在该分钟的第15秒)

job = newJob(myJob.class).withIdentity("job2", "group1").build();

trigger = newTrigger().withIdentity("trigger2", "group1").withSchedule(cronSchedule("15 0/2 * * * ?")).build();

ft = sched.scheduleJob(job, trigger);

System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + ",并且以如下重复规则重复执行: "+ trigger.getCronExpression());

// 开始执行,start()方法被调用后,计时器就开始工作,计时调度中允许放入N个Job

sched.start();

try {

//主线程等待一分钟

Thread.sleep(60L * 1000L);

} catch (Exception e) {}

//关闭定时调度,定时器不再工作

sched.shutdown(true);

}

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

Test test = new Test();

test.go();

}

}

import static org.quartz.CronScheduleBuilder.cronSchedule;

import static org.quartz.JobBuilder.newJob;

import static org.quartz.TriggerBuilder.newTrigger;

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.CronTrigger;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerFactory;

import org.quartz.impl.StdSchedulerFactory;

public class Test {

public void go() throws Exception {

// 首先,必需要取得一个Scheduler的引用

SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sched = sf.getScheduler();

//jobs可以在scheduled的sched.start()方法前被调用

//job 1将每隔20秒执行一次

JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();

CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

Date ft = sched.scheduleJob(job, trigger);

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + ",并且以如下重复规则重复执行: " + trigger.getCronExpression());

// job 2将每2分钟执行一次(在该分钟的第15秒)

job = newJob(myJob.class).withIdentity("job2", "group1").build();

trigger = newTrigger().withIdentity("trigger2", "group1").withSchedule(cronSchedule("15 0/2 * * * ?")).build();

ft = sched.scheduleJob(job, trigger);

System.out.println(job.getKey() + " 已被安排执行于: " + sdf.format(ft) + ",并且以如下重复规则重复执行: "+ trigger.getCronExpression());

// 开始执行,start()方法被调用后,计时器就开始工作,计时调度中允许放入N个Job

sched.start();

try {

//主线程等待一分钟

Thread.sleep(60L * 1000L);

} catch (Exception e) {}

//关闭定时调度,定时器不再工作

sched.shutdown(true);

}

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

Test test = new Test();

test.go();

}

}

OK了,Job1和Job2就会被安排为定时执行了。此时程序是可以执行的了,但是可能会输出WARN级别日志,这是因为没有加log4j的配置文件,加上配置文件,就OK了。这里需要说明的地方只有一个,其它的可以直接Copy到您的项目里面。看代码:

CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();

CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchedule(cronSchedule("0/20 * * * * ?")).build();