今天给各位分享javaquartz文档的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
1、定时器（quartz 一）2、如何在java中使用quartz3、java quartz 定时需要的包4、java quartz 如何配置， 两天执行一次，且0点执行？5、java如何利用第三方Quartz实现定时任务6、java quartz的配置文件quartz_reminder.xml 可以放其他路径吗？
定时器（quartz 一）
优点：与spring集成、动态添加任务、支持集群
缺点：不支持分布式（只能一个任务在一台服务器上执行，不能分片）
将一个任务拆分成多个独立的任务项，由分布式的服务器分别执行某一个或几个分片项。而传统的定时器任务都在一台服务器上执行，如果数据很大那么压力很大。
举例：处理一百万的订单：A服务器处理尾数偶数的订单，B服务器处理尾数奇数的订单。
整合java项目
1、引入quartz 依赖
2、quartz.properties
3、
注意：
1、每一个job执行都是一个新的线程（即使是同一个任务，这个elastic-job不同）但是如果在配置文件quartz.properties中配置的线程消耗完，也还是会陷入阻塞的。根据业务来预估线程池的大小。（所以的任务共享一个线程池）
2、每一个job执行都会创建一个新的job对象，所以想通过job的成员变量来传递信息是不可行的（每次都会初始化）
3、myJob类必须要有空的构造方法
1、方式1：在创建jobDetail是传递JobDataMap，然后通过JobExecutionContext获取JobDataMap
2、方式2：在myjob中定义成员变量，并生成get,set方法
上面我们知道任务间都是并发处理的，那么要考虑并发安全问题。
1、使用@DisallowConcurrentExecution
使用@PersistJobDataAfterExecution注解和jobDataMap.put方法
1、startTime属性：设置trigger第一次触发的时间
2、endTime属性：表示trigger的失效时间点
3、优先级（priority）当多个Trigger并发执行，但是线程不够时触发，会优先执行级别高的Trigger
TriggerBuilder.newTrigger().withPriority(10)；
默认时5，数字越大优先级越高
4、错过触发（misfire instructions）
1、withMisfireHandlingInstructionDoNothing策略：错过了什么都不做，等待下一次触发时间
设置每5秒执行一次，任务7秒。
发现这样是不会生效的，因为内部判断了一下错过的时间是否大于misfireThreshold这个值（默认5秒），如果小于还是立即执行。这里我们只失效了2秒，是小于5秒的。
通过quartz.properties设置misfireThreshold的值
这样再运行，发现withMisfireHandlingInstructionDoNothing策略生效了。
2、withMisfireHandlingInstructionFireAndProceed策略：错过立即执行
5、日历（calendar）
1、可以在具体的时间点执行一次
2、可以按照指定间隔时间重复若干次
1、使用cron表达式触发
, 代表并且，如果10,20 10秒和20秒都指向
? 只能出现在日期和星期内，代表没有特定的值。如果使用*号日期了星期会有歧义，这是使用?
L 只能出现在日期和星期内，表示月的最后一天，或者星期六
W 只能出现在日期内，表示最接近这个日期的工作日
如何在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 如何配置， 两天执行一次，且0点执行？
如果你是直接写的代码设置时间的，可以设置每48小时，翻翻API就有了，既然你问了，肯定是通过XML配置文件写的，那只能给一个解决方案了，在配置文件中虽然有0 0 0 1/2 * ? 来表示从每月1号起每2天0点0分0秒执行一次，但遇到31这样的月份就会错，不建议使用。
想到的解决方案有2种，一种设置成每天跑一次，定义个static boolean变量 第一次执行的时候改成false并执行，第2天的执行获取该值，发现是false把值变成true不执行，发现是true改成false执行。
第2种方法其实是为了防止项目被重启static变量重置的，这个boolean值（或者你自定义的标示符）放到数据库里，没天执行的时候读一下库。当然在指定位置生成一个空文件，每次执行判断该位置的文件是否存在也一样（覆盖项目的时候记得，如果这个文件有复制到相关位置就好了）
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_reminder.xml 可以放其他路径吗？
可以重写org.quartz.impl.StdSchedulerFactory类
public static final String PROPERTIES_FILE = “org.quartz.properties”;
String requestedFile = System.getProperty(PROPERTIES_FILE);
String propFileName = requestedFile != null ? requestedFile
: “quartz.properties”;
File propFile = new File(propFileName);
Properties props = new Properties();
以上为寻找配置文件的部分源码
从源码可以看出 我们可以直接设置
System.setProperty(“org.quartz.properties”,”你要放的自定义路径”)
javaquartz文档的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javaquartz文档的信息别忘了在本站进行查找喔。
微信扫一扫 
支付宝扫一扫 
