下面列出了怎么用org.quartz.SimpleTrigger的API类实例代码及写法,或者点击链接到github查看源代码。
public static String getPlanification(Trigger trigger) {
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
try {
return CronExpressionDescriptor.getDescription(cronTrigger.getCronExpression())
+ "<br/>(" + cronTrigger.getCronExpression() + ")";
} catch (ParseException e) {
return cronTrigger.getCronExpression();
}
}
SimpleTrigger simpleTrigger = (SimpleTrigger) trigger;
return getPlanification(simpleTrigger.getRepeatCount(), simpleTrigger.getRepeatInterval());
}
/**
* Schedules new quartz scheduler job for uploading calendar entries to Google
*/
private void scheduleUploadJob() {
try {
scheduler = StdSchedulerFactory.getDefaultScheduler();
JobDetail job = newJob(SynchronizationJob.class).withIdentity("Upload_GCal-Entries", GCAL_SCHEDULER_GROUP)
.build();
SimpleTrigger trigger = newTrigger().withIdentity("Upload_GCal-Entries", GCAL_SCHEDULER_GROUP)
.withSchedule(repeatSecondlyForever(uploadInterval)).build();
scheduler.scheduleJob(job, trigger);
logger.debug("Scheduled Google Calendar Upload-Job with interval '{}'", uploadInterval);
} catch (SchedulerException e) {
logger.warn("Could not create Google Calendar Upload-Job: {}", e.getMessage());
}
}
private Trigger createTrigger(String name, String group, int mode,
long interval) {
SimpleTrigger trigger = newTrigger()
.withIdentity(name, "default")
.forJob(name, group)
.startAt(new Date())
.endAt(null)
.withSchedule(simpleSchedule()
.withRepeatCount(mode)
.withIntervalInMilliseconds(interval))
.build();
if (trigger instanceof MutableTrigger) {
MutableTrigger mtrigger = (MutableTrigger) trigger;
mtrigger.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT);
return mtrigger;
}
else {
log.error("Cannot set MisfireInstruction since trigger is not instance of MutableTrigger: " + trigger);
}
return trigger;
}
@Override
public SafeFuture<?> doStart() {
try {
SimpleTrigger trigger =
newTrigger()
.withIdentity("TimerTrigger")
.startAt(DateBuilder.futureDate(START_DELAY, DateBuilder.IntervalUnit.MILLISECOND))
.withSchedule(simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.build();
sched.scheduleJob(job, trigger);
sched.start();
return SafeFuture.COMPLETE;
} catch (SchedulerException e) {
return SafeFuture.failedFuture(new RuntimeException("TimerService failed to start", e));
}
}
/**
* Schedule a job by jobName at given date.
*/
@Override
public boolean scheduleCronJob(String jobName, Class<? extends QuartzJobBean> jobClass, Date date, String cronExpression) {
System.out.println("Request received to scheduleJob");
String jobKey = jobName;
String groupKey = "SampleGroup";
String triggerKey = jobName;
JobDetail jobDetail = JobUtil.createJob(jobClass, false, context, jobKey, groupKey);
System.out.println("creating trigger for key :"+jobKey + " at date :"+date);
Trigger cronTriggerBean = JobUtil.createCronTrigger(triggerKey, date, cronExpression, SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
try {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
Date dt = scheduler.scheduleJob(jobDetail, cronTriggerBean);
System.out.println("Job with key jobKey :"+jobKey+ " and group :"+groupKey+ " scheduled successfully for date :"+dt);
return true;
} catch (SchedulerException e) {
System.out.println("SchedulerException while scheduling job with key :"+jobKey + " message :"+e.getMessage());
e.printStackTrace();
}
return false;
}
/**
* Update one time scheduled job.
*/
@Override
public boolean updateOneTimeJob(String jobName, Date date) {
System.out.println("Request received for updating one time job.");
String jobKey = jobName;
System.out.println("Parameters received for updating one time job : jobKey :"+jobKey + ", date: "+date);
try {
//Trigger newTrigger = JobUtil.createSingleTrigger(jobKey, date, SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT);
Trigger newTrigger = JobUtil.createSingleTrigger(jobKey, date, SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
Date dt = schedulerFactoryBean.getScheduler().rescheduleJob(TriggerKey.triggerKey(jobKey), newTrigger);
System.out.println("Trigger associated with jobKey :"+jobKey+ " rescheduled successfully for date :"+dt);
return true;
} catch ( Exception e ) {
System.out.println("SchedulerException while updating one time job with key :"+jobKey + " message :"+e.getMessage());
e.printStackTrace();
return false;
}
}
/**
* Update scheduled cron job.
*/
@Override
public boolean updateCronJob(String jobName, Date date, String cronExpression) {
System.out.println("Request received for updating cron job.");
String jobKey = jobName;
System.out.println("Parameters received for updating cron job : jobKey :"+jobKey + ", date: "+date);
try {
//Trigger newTrigger = JobUtil.createSingleTrigger(jobKey, date, SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT);
Trigger newTrigger = JobUtil.createCronTrigger(jobKey, date, cronExpression, SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
Date dt = schedulerFactoryBean.getScheduler().rescheduleJob(TriggerKey.triggerKey(jobKey), newTrigger);
System.out.println("Trigger associated with jobKey :"+jobKey+ " rescheduled successfully for date :"+dt);
return true;
} catch ( Exception e ) {
System.out.println("SchedulerException while updating cron job with key :"+jobKey + " message :"+e.getMessage());
e.printStackTrace();
return false;
}
}
public int insertExtendedTriggerProperties(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
SimpleTrigger simpleTrigger = (SimpleTrigger)trigger;
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(Util.rtp(INSERT_SIMPLE_TRIGGER, tablePrefix, schedNameLiteral));
ps.setString(1, trigger.getKey().getName());
ps.setString(2, trigger.getKey().getGroup());
ps.setInt(3, simpleTrigger.getRepeatCount());
ps.setBigDecimal(4, new BigDecimal(String.valueOf(simpleTrigger.getRepeatInterval())));
ps.setInt(5, simpleTrigger.getTimesTriggered());
return ps.executeUpdate();
} finally {
Util.closeStatement(ps);
}
}
public int updateExtendedTriggerProperties(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
SimpleTrigger simpleTrigger = (SimpleTrigger)trigger;
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(Util.rtp(UPDATE_SIMPLE_TRIGGER, tablePrefix, schedNameLiteral));
ps.setInt(1, simpleTrigger.getRepeatCount());
ps.setBigDecimal(2, new BigDecimal(String.valueOf(simpleTrigger.getRepeatInterval())));
ps.setInt(3, simpleTrigger.getTimesTriggered());
ps.setString(4, simpleTrigger.getKey().getName());
ps.setString(5, simpleTrigger.getKey().getGroup());
return ps.executeUpdate();
} finally {
Util.closeStatement(ps);
}
}
/**
* Get a {@link ScheduleBuilder} that is configured to produce a
* schedule identical to this trigger's schedule.
*
* @see #getTriggerBuilder()
*/
@Override
public ScheduleBuilder<SimpleTrigger> getScheduleBuilder() {
SimpleScheduleBuilder sb = SimpleScheduleBuilder.simpleSchedule()
.withIntervalInMilliseconds(getRepeatInterval())
.withRepeatCount(getRepeatCount());
switch(getMisfireInstruction()) {
case MISFIRE_INSTRUCTION_FIRE_NOW : sb.withMisfireHandlingInstructionFireNow();
break;
case MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT : sb.withMisfireHandlingInstructionNextWithExistingCount();
break;
case MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT : sb.withMisfireHandlingInstructionNextWithRemainingCount();
break;
case MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT : sb.withMisfireHandlingInstructionNowWithExistingCount();
break;
case MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT : sb.withMisfireHandlingInstructionNowWithRemainingCount();
break;
}
return sb;
}
/**
* Schedules new quartz scheduler jobs for committing transactions and
* backing up the database
*/
private void scheduleJob() {
try {
Scheduler sched = StdSchedulerFactory.getDefaultScheduler();
// schedule commit-job
JobDetail job = newJob(CommitJob.class).withIdentity("Commit_Transaction", SCHEDULER_GROUP).build();
SimpleTrigger trigger = newTrigger().withIdentity("Commit_Transaction", SCHEDULER_GROUP)
.withSchedule(repeatSecondlyForever(commitInterval)).build();
sched.scheduleJob(job, trigger);
logger.debug("Scheduled Commit-Job with interval {}sec.", commitInterval);
// schedule backup-job
JobDetail backupJob = newJob(BackupJob.class).withIdentity("Backup_DB", SCHEDULER_GROUP).build();
CronTrigger backupTrigger = newTrigger().withIdentity("Backup_DB", SCHEDULER_GROUP)
.withSchedule(CronScheduleBuilder.cronSchedule(backupInterval)).build();
sched.scheduleJob(backupJob, backupTrigger);
logger.debug("Scheduled Backup-Job with cron expression '{}'", backupInterval);
} catch (SchedulerException e) {
logger.warn("Could not create Job: {}", e.getMessage());
}
}
/**
* <p>
* Insert the simple trigger data.
* </p>
*
* @param conn
* the DB Connection
* @param trigger
* the trigger to insert
* @return the number of rows inserted
*/
public int insertSimpleTrigger(Connection conn, SimpleTrigger trigger)
throws SQLException {
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(rtp(INSERT_SIMPLE_TRIGGER));
ps.setString(1, trigger.getName());
ps.setString(2, trigger.getGroup());
ps.setInt(3, trigger.getRepeatCount());
ps.setBigDecimal(4, new BigDecimal(String.valueOf(trigger
.getRepeatInterval())));
ps.setInt(5, trigger.getTimesTriggered());
return ps.executeUpdate();
} finally {
closeStatement(ps);
}
}
/**
* <p>
* Update the simple trigger data.
* </p>
*
* @param conn
* the DB Connection
* @param trigger
* the trigger to insert
* @return the number of rows updated
*/
public int updateSimpleTrigger(Connection conn, SimpleTrigger trigger)
throws SQLException {
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(rtp(UPDATE_SIMPLE_TRIGGER));
ps.setInt(1, trigger.getRepeatCount());
ps.setBigDecimal(2, new BigDecimal(String.valueOf(trigger
.getRepeatInterval())));
ps.setInt(3, trigger.getTimesTriggered());
ps.setString(4, trigger.getName());
ps.setString(5, trigger.getGroup());
return ps.executeUpdate();
} finally {
closeStatement(ps);
}
}
@Test
public void serialization(){
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.forJob("testJob", "testGroup")
.withIdentity("testTrigger", "testTriggerGroup")
.usingJobData("timeout", 5)
.withDescription("A description!")
.withSchedule(SimpleScheduleBuilder.repeatHourlyForever())
.build();
Map<String, String> triggerMap = mapper.convertValue(trigger, new TypeReference<HashMap<String, String>>() {});
assertThat(triggerMap, hasKey("name"));
assertEquals("testTrigger", triggerMap.get("name"));
assertThat(triggerMap, hasKey("group"));
assertEquals("testTriggerGroup", triggerMap.get("group"));
assertThat(triggerMap, hasKey("jobName"));
assertEquals("testJob", triggerMap.get("jobName"));
SimpleTriggerImpl simpleTrigger = mapper.convertValue(triggerMap, SimpleTriggerImpl.class);
assertEquals(trigger.getKey().getName(), simpleTrigger.getKey().getName());
assertEquals(trigger.getKey().getGroup(), simpleTrigger.getKey().getGroup());
assertEquals(trigger.getStartTime(), simpleTrigger.getStartTime());
assertEquals(trigger.getRepeatInterval(), simpleTrigger.getRepeatInterval());
}
/**
* Will create/schedule a trigger for the passed in indexName.
* Note: Only one trigger per indexName is allowed, if subsequent calls
* are made before the current trigger finishes completion, this request
* will be dropped.
* @param indexName
* @return
*/
public boolean triggerIndexTask(String indexName) {
if (!isSupported(indexName)) {
log.info(indexName + " is not a supported for scheduler modifications.");
return false;
}
// Define a Trigger that will fire "now" and associate it with the existing job
Trigger trigger = new SimpleTrigger("immediateTrigger-" + indexName,
"group1", new Date());
trigger.setJobName(indexName);
trigger.setJobGroup(updateIndexGroupName);
try {
// Schedule the trigger
log.info("Scheduling trigger: " + trigger);
scheduler.scheduleJob(trigger);
}
catch (SchedulerException e) {
log.warn("Scheduling trigger: " + trigger + " failed.");
log.warn("Exception was caught: ", e);
return false;
}
return true;
}
@Test
public void createWithoutJobDetail() throws ParseException {
SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
factory.setName("myTrigger");
factory.setRepeatCount(5);
factory.setRepeatInterval(1000L);
factory.afterPropertiesSet();
SimpleTrigger trigger = factory.getObject();
assertEquals(5, trigger.getRepeatCount());
assertEquals(1000L, trigger.getRepeatInterval());
}
public CronTriggerFactoryBean createCronTrigger(JobDetail jobDetail, String cronExpression) {
CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
factoryBean.setCronExpression(cronExpression);
factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
return factoryBean;
}
/**
* 创建cron触发器
*
* @param jobDetail job信息
* @param cronExpression cron表达式
* @param triggerName 触发器名称
* @param triggerGroup 触发器组
* @return
*/
private CronTriggerFactoryBean createCronTrigger(JobDetail jobDetail, String cronExpression,
String triggerName, String triggerGroup) {
CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setName(triggerName);
factoryBean.setGroup(triggerGroup);
factoryBean.setCronExpression(cronExpression);
factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
return factoryBean;
}
@Override
public Class<?> getObjectType() {
try {
if ("simple".equals(config.getProperty("schedule.mode." + getName())))
return SimpleTrigger.class;
else
return CronTrigger.class;
} catch (Throwable t) {
return SimpleTrigger.class;
}
}
private void updateJobInstanceState(JobExecutionContext context)
throws IOException {
SimpleTrigger simpleTrigger = (SimpleTrigger) context.getTrigger();
int repeatCount = simpleTrigger.getRepeatCount();
int fireCount = simpleTrigger.getTimesTriggered();
if (fireCount > repeatCount) {
saveJobInstance(null, NOT_FOUND);
}
}
public static SimpleTrigger createSimpleTrigger(
int repeatCount,
int triggerCount) {
SimpleTriggerImpl trigger = new SimpleTriggerImpl();
trigger.setRepeatCount(repeatCount);
trigger.setTimesTriggered(triggerCount);
trigger.setPreviousFireTime(new Date());
return trigger;
}
/**
* Schedule a job by jobName at given date.
*/
@Override
public boolean scheduleOneTimeJob(String jobName, Class<? extends QuartzJobBean> jobClass, Date date) {
System.out.println("Request received to scheduleJob");
String jobKey = jobName;
String groupKey = "SampleGroup";
String triggerKey = jobName;
JobDetail jobDetail = JobUtil.createJob(jobClass, false, context, jobKey, groupKey);
System.out.println("creating trigger for key :"+jobKey + " at date :"+date);
Trigger cronTriggerBean = JobUtil.createSingleTrigger(triggerKey, date, SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
//Trigger cronTriggerBean = JobUtil.createSingleTrigger(triggerKey, date, SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT);
try {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
Date dt = scheduler.scheduleJob(jobDetail, cronTriggerBean);
System.out.println("Job with key jobKey :"+jobKey+ " and group :"+groupKey+ " scheduled successfully for date :"+dt);
return true;
} catch (SchedulerException e) {
System.out.println("SchedulerException while scheduling job with key :"+jobKey + " message :"+e.getMessage());
e.printStackTrace();
}
return false;
}
protected OperableTrigger createRecoveryTrigger(TriggerWrapper tw, JobWrapper jw,
String name, FiredTrigger recovering) {
final SimpleTriggerImpl recoveryTrigger = new SimpleTriggerImpl(name, Scheduler.DEFAULT_RECOVERY_GROUP, new Date(recovering.getScheduledFireTime()));
recoveryTrigger.setJobName(jw.getKey().getName());
recoveryTrigger.setJobGroup(jw.getKey().getGroup());
recoveryTrigger.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY);
recoveryTrigger.setPriority(tw.getPriority());
return recoveryTrigger;
}
public void startLoading() {
if (execService != null) {
return;
}
log.trace("starting execution...");
int i = 0;
for (final CalendarRuntime eventRuntime : EventStorage.getInstance().getEventCache().values()) {
try {
JobDetail job = JobBuilder.newJob().ofType(EventReloaderJob.class)
.usingJobData(EventReloaderJob.KEY_CONFIG, eventRuntime.getConfig().getKey())
.withIdentity(eventRuntime.getConfig().getKey(), JOB_NAME_EVENT_RELOADER).storeDurably()
.build();
this.scheduler.addJob(job, false);
SimpleTrigger jobTrigger = TriggerBuilder.newTrigger().forJob(job)
.withIdentity(eventRuntime.getConfig().getKey(), JOB_NAME_EVENT_RELOADER)
.startAt(DateBuilder.futureDate(10 + i, IntervalUnit.SECOND)).withSchedule(SimpleScheduleBuilder
.repeatMinutelyForever(eventRuntime.getConfig().getReloadMinutes()))
.build();
this.scheduler.scheduleJob(jobTrigger);
log.info("reload job scheduled for: {}", eventRuntime.getConfig().getKey());
} catch (SchedulerException e) {
log.warn("Cannot schedule calendar reloader", e);
}
// next event 10 seconds later
i += 10;
}
}
@Bean(name = "sampleJobTrigger")
public SimpleTriggerFactoryBean sampleJobTrigger(@Qualifier("sampleJobDetail") JobDetail jobDetail) {
SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setStartDelay(0L);
factoryBean.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT);
return factoryBean;
}
@Bean(name="simpleJobTrigger2")
public SimpleTriggerFactoryBean createSimpleTrigger2(@Qualifier("simpleJobDetail") JobDetail jobDetail) {
Map<String, Object> map = new HashMap<>(1);
map.put("myKey", "myValue");
return QuartzUtils.createSimpleTrigger(jobDetail, "STName2", "STGroup2", "STDesc2", 10000L, 30000L,
SimpleTrigger.REPEAT_INDEFINITELY,
SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT, map, 1000);
}
@Bean(name="simpleJobTrigger2")
public SimpleTriggerFactoryBean createSimpleTrigger2(@Qualifier("simpleJobDetail") JobDetail jobDetail) {
Map<String, Object> map = new HashMap<>(1);
map.put("myKey", "myValue");
return QuartzUtils.createSimpleTrigger(jobDetail, "STName2", "STGroup2", "STDesc2", 10000L, 30000L,
SimpleTrigger.REPEAT_INDEFINITELY,
SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT, map, 1000);
}
@Profile("!disablescheduling")
@Bean
public SimpleTriggerFactoryBean triggerExpiringBlobCleanup(@Qualifier("jobDetailDatabaseBlobStorageCleanupJob") JobDetail job) {
logger.info("Configure jobDetailDatabaseBlobStorageCleanupJob");
SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
trigger.setJobDetail(job);
trigger.setRepeatInterval(Duration.ofMinutes(5).toMillis());
trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
return trigger;
}
@Bean
public SimpleTriggerFactoryBean triggerAssetExtractionCleanup(@Qualifier("jobDetailAssetExtractionCleanup") JobDetail job) {
SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
trigger.setJobDetail(job);
trigger.setRepeatInterval(Duration.ofMinutes(5).toMillis());
trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
return trigger;
}
@Bean
public SimpleTriggerFactoryBean triggerPollableTaskCleanup(@Qualifier("jobDetailPollableTaskCleanup") JobDetail job) {
SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
trigger.setJobDetail(job);
trigger.setRepeatInterval(REPEAT_INTERVAL);
trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
return trigger;
}