当前位置：首页 » 编程语言 » quartzjava

quartzjava

发布时间: 2021-03-12 10:26:01

A. java quartz 怎么读

扩儿词
发音顺序：四声，轻声，三声

B. 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.Scheler;
import org.quartz.impl.StdSchelerFactory;

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 * * * * ?");

Scheler sch = StdSchelerFactory.getDefaultScheler();
sch.scheleJob(jobDetail, trigger);
sch.start();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 修改定时任务时间
*/
public static void modifyJobTime(String triggerName, String time) {
System.out.println("modify~~~~~~~~~~~~~~~~");
try {
Scheler sched = StdSchelerFactory.getDefaultScheler();
System.out.println("triggerName " + triggerName);
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, Scheler.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秒执行一次。

C. 用quartzi给一个java程序做定时任务，怎样传递参数

java定时任务Timer
关于定时任务，似乎跟时间操作的联系并不是很大

D. java中jdk1.4.2版本支持那个quartz版本啊!!急

怎么不升级？可以查看quartz的文档，里面有说明。建议使用1.8之前的版本试一下。

E. java Quartz时间调度

<?xmlversion="1.1"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"
	default-autowire="byName"default-lazy-init="false">
	<!--定时器工作类-->
	<beanclass="com.wits.schele.BusinessJob"id="businessJob"/>
	<!--定义调用对象和调用对象的方法-->
	<beanclass="org.springframework.scheling.quartz."id="interfaceTrigger">
		<!--调用的类-->
		<propertyname="targetObject">
			<refbean="businessJob"/>
		</property>
		<!--调用方法-->
		<propertyname="targetMethod">
			<value>generateBusinessInfo</value>
		</property>
	</bean>
	<beanclass="org.springframework.scheling.quartz."id="killProcessTrigger">
		<!--调用的类-->
		<propertyname="targetObject">
			<refbean="businessJob"/>
		</property>
		<!--调用方法-->
		<propertyname="targetMethod">
			<value>killProcess</value>
		</property>
	</bean>
	<!--定义触发时间-->
	<beanclass="org.springframework.scheling.quartz.CronTriggerBean"id="excuteTrigger">
		<propertyname="jobDetail">
			<refbean="interfaceTrigger"/>
		</property>
		<!--cron表达式-->
		<propertyname="cronExpression">
			<value>0022**?</value>
		</property>
	</bean>
	<beanclass="org.springframework.scheling.quartz.CronTriggerBean"id="excuteKillProcessTrigger">
		<propertyname="jobDetail">
			<refbean="killProcessTrigger"/>
		</property>
		<!--cron表达式-->
		<propertyname="cronExpression">
			<value>0023**?</value>
		</property>
	</bean>
	<beanid="startQuertz"lazy-init="false"autowire="no"class="org.springframework.scheling.quartz.SchelerFactoryBean">
		<propertyname="triggers">
			<list>
				<refbean="excuteTrigger"/>
				<refbean="excuteKillProcessTrigger"/>
			</list>
		</property>
	</bean>	
</beans>

F. 如何在java中使用quartz

在java中使用quartz
/** *//**
* 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
* @param jobName 任务名
* @param job 任务
* @param time 时间设置，参考quartz说明文档
* @throws SchelerException
* @throws ParseException
*/
public static void addJob(String jobName,Job job,String time)
throws SchelerException, ParseException{
Scheler sched = sf.getScheler();
JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, job.getClass());//任务名，任务组，任务执行类
//触发器
CronTrigger trigger =
new CronTrigger(jobName, TRIGGER_GROUP_NAME);//触发器名,触发器组
trigger.setCronExpression(time);//触发器时间设定
sched.scheleJob(jobDetail,trigger);
//启动
if(!sched.isShutdown())
sched.start();
}

/** *//**
* 添加一个定时任务
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param job 任务
* @param time 时间设置，参考quartz说明文档
* @throws SchelerException
* @throws ParseException
*/
public static void addJob(String jobName,String jobGroupName,
String triggerName,String triggerGroupName,
Job job,String time)
throws SchelerException, ParseException{
Scheler sched = sf.getScheler();
JobDetail jobDetail = new JobDetail(jobName, jobGroupName, job.getClass());//任务名，任务组，任务执行类
//触发器
CronTrigger trigger =
new CronTrigger(triggerName, triggerGroupName);//触发器名,触发器组
trigger.setCronExpression(time);//触发器时间设定
sched.scheleJob(jobDetail,trigger);
if(!sched.isShutdown())
sched.start();
}

/** *//**
* 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
* @param jobName
* @param time
* @throws SchelerException
* @throws ParseException
*/
public static void modifyJobTime(String jobName,String time)
throws SchelerException, ParseException{
Scheler sched = sf.getScheler();
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 SchelerException
* @throws ParseException
*/
public static void modifyJobTime(String triggerName,String triggerGroupName,
String time)
throws SchelerException, ParseException{
Scheler sched = sf.getScheler();
Trigger trigger = sched.getTrigger(triggerName,triggerGroupName);
if(trigger != null){
CronTrigger ct = (CronTrigger)trigger;
//修改时间
ct.setCronExpression(time);
//重启触发器
sched.resumeTrigger(triggerName,triggerGroupName);
}
}

/** *//**
* 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
* @param jobName
* @throws SchelerException
*/
public static void removeJob(String jobName)
throws SchelerException{
Scheler sched = sf.getScheler();
sched.pauseTrigger(jobName,TRIGGER_GROUP_NAME);//停止触发器
sched.unscheleJob(jobName,TRIGGER_GROUP_NAME);//移除触发器
sched.deleteJob(jobName,JOB_GROUP_NAME);//删除任务
}

/** *//**
* 移除一个任务
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
* @throws SchelerException
*/
public static void removeJob(String jobName,String jobGroupName,
String triggerName,String triggerGroupName)
throws SchelerException{
Scheler sched = sf.getScheler();
sched.pauseTrigger(triggerName,triggerGroupName);//停止触发器
sched.unscheleJob(triggerName,triggerGroupName);//移除触发器
sched.deleteJob(jobName,jobGroupName);//删除任务
}

G. java：如何使用 quartz定时执行任务，例如定时执行System.out.pintln("aa")；看清楚用quartz

}
importstaticorg.quartz.CronScheleBuilder.cronSchele;
importstaticorg.quartz.JobBuilder.newJob;
importstaticorg.quartz.TriggerBuilder.newTrigger;

importjava.text.SimpleDateFormat;
importjava.util.Date;

importorg.quartz.CronTrigger;
importorg.quartz.JobDetail;
importorg.quartz.Scheler;
importorg.quartz.SchelerFactory;
importorg.quartz.impl.StdSchelerFactory;

publicclassTest{
publicvoidgo()throwsException{
//首先，必需要取得一个Scheler的引用
SchelerFactorysf=newStdSchelerFactory();
Schelersched=sf.getScheler();
//jobs可以在scheled的sched.start()方法前被调用

//job1将每隔30分钟执行一次
JobDetailjob=newJob(myJob.class).withIdentity("job1","group1").build();
CronTriggertrigger=newTrigger().withIdentity("trigger1","group1").withSchele(cronSchele("00/30***?")).build();
Dateft=sched.scheleJob(job,trigger);
SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS");
System.out.pintln("aa")；


//开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job
sched.start();
try{
//主线程等待一分钟
Thread.sleep(60L*1000L);
}catch(Exceptione){}	
//关闭定时调度，定时器不再工作
sched.shutdown(true);
}

publicstaticvoidmain(String[]args)throwsException{

Testtest=newTest();
test.go();
}

}

H. 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.CronScheleBuilder.cronSchele;
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.Scheler;
import org.quartz.SchelerFactory;
import org.quartz.impl.StdSchelerFactory;

public class Test {
public void go() throws Exception {
// 首先，必需要取得一个Scheler的引用
SchelerFactory sf = new StdSchelerFactory();
Scheler sched = sf.getScheler();
//jobs可以在scheled的sched.start()方法前被调用

//job 1将每隔20秒执行一次
JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
Date ft = sched.scheleJob(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").withSchele(cronSchele("15 0/2 * * * ?")).build();
ft = sched.scheleJob(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.CronScheleBuilder.cronSchele;
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.Scheler;
import org.quartz.SchelerFactory;
import org.quartz.impl.StdSchelerFactory;

public class Test {
public void go() throws Exception {
// 首先，必需要取得一个Scheler的引用
SchelerFactory sf = new StdSchelerFactory();
Scheler sched = sf.getScheler();
//jobs可以在scheled的sched.start()方法前被调用

//job 1将每隔20秒执行一次
JobDetail job = newJob(myJob.class).withIdentity("job1", "group1").build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();
Date ft = sched.scheleJob(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").withSchele(cronSchele("15 0/2 * * * ?")).build();
ft = sched.scheleJob(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").withSchele(cronSchele("0/20 * * * * ?")).build();
CronTrigger trigger = newTrigger().withIdentity("trigger1", "group1").withSchele(cronSchele("0/20 * * * * ?")).build();

I. 我可以用java的quartz来定时执行shell脚本吗

可以，其实你的问题就是java程序怎么调用shell脚本。

ProcessBuilderpb=newProcessBuilder("xx.sh");
try{
Processp=pb.start();
}catch(IOExceptione){
e.printStackTrace();
}

J. 关于 java quartz 执行并发性大虾赶快来帮忙啊

<prop key="org.quartz.threadPool.threadCount">5</prop>
quartz可以设置线程并发数，同一个job不存在并发（处于线程等待状态）。

阅读全文

quartzjava

与quartzjava相关的阅读推荐