下面列出了org.quartz.JobDetail#getKey ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public void cancel(JobDetail jd) {
if (jd == null) {
return;
}
if (jd.getKey() == null) {
throw new CronServiceException("JobDetail should have JobKey");
}
try {
scheduler.deleteJob(jd.getKey());
} catch (SchedulerException e) {
throw new CronServiceException("Failed to delete Job", e);
}
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof JobDetail)) {
return false;
}
JobDetail other = (JobDetail) obj;
if(other.getKey() == null || getKey() == null)
return false;
if (!other.getKey().equals(getKey())) {
return false;
}
return true;
}
private synchronized void schedule()
{
try
{
scheduler = schedulerFactory.getScheduler();
JobDetail job = JobBuilder.newJob()
.withIdentity(jobName)
.ofType(ConfigSchedulerJob.class)
.build();
jobKey = job.getKey();
job.getJobDataMap().put(CONFIG_SCHEDULER, this);
CronExpression cronExpression = normalCronSchedule ? this.cronExpression : initialAndOnErrorCronExpression;
CronTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(jobName+"Trigger", Scheduler.DEFAULT_GROUP)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
scheduler.startDelayed(0);
scheduler.scheduleJob(job, trigger);
log.debug("Schedule set "+cronExpression);
}
catch (Exception e)
{
log.error("Error scheduling "+e.getMessage());
}
}
/**
* The user may configure this binding to update the internal clock of
* FHT80b devices via rf command. The method takes care of scheduling this
* job.
*/
private JobKey scheduleJob(Class<? extends Job> jobClass, String cronExpression) {
JobKey jobKey = null;
try {
Scheduler sched = StdSchedulerFactory.getDefaultScheduler();
JobDetail detail = JobBuilder.newJob(jobClass).withIdentity("FHT " + jobClass.getSimpleName(), "cul")
.build();
detail.getJobDataMap().put(FHTBinding.class.getName(), this);
CronTrigger trigger = TriggerBuilder.newTrigger().forJob(detail)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();
jobKey = detail.getKey();
sched.scheduleJob(detail, trigger);
} catch (SchedulerException e) {
logger.error("Can't schedule time update job", e);
}
return jobKey;
}
public JobParamsDetail(JobDetail jobDetail) {
this.setJobClass(jobDetail.getJobClass());
this.setDescription(jobDetail.getDescription());
if (jobDetail.getKey() == null)
this.setKey(new JobKey(Key.createUniqueName(null), null));
this.setKey(jobDetail.getKey());
this.setDurability(jobDetail.isDurable());
this.setRequestsRecovery(jobDetail.requestsRecovery());
if (!jobDetail.getJobDataMap().isEmpty())
this.setJobDataMap(jobDetail.getJobDataMap());
}
@SuppressWarnings("unchecked")
private void setJobStartTime(JobDetail jobDetail)
throws SchedulerException {
Scheduler scheduler = factory.getScheduler();
JobKey jobKey = jobDetail.getKey();
List<Trigger> triggers =
(List<Trigger>) scheduler.getTriggersOfJob(jobKey);
Date triggerTime = triggers.get(0).getPreviousFireTime();
jobStartTime = triggerTime.getTime();
}
/**
* 执行计划任务
* @param job
* @param trigger
* @return
* @throws SchedulerException
*/
public static ScheduleJobResult executeScheduleJob(JobDetail job, Trigger trigger) throws SchedulerException {
ScheduleJobResult scheduleJobResult = new ScheduleJobResult();
//判断是否满足计划任务的创建条件
if(job.getKey() == null || trigger.getKey() == null || job.getJobDataMap() == null){
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.FAILED);
//不满足计划任务的创建条件，返回scheduleJobResult值类
return scheduleJobResult;
}
scheduleJobResult.setJobDetail(job);
scheduleJobResult.setTrigger(trigger);
//开始分配计划任务
Scheduler scheduler = SchedulerFactory.getScheduler();
//开始判断是否存在相同的计划任务
if(scheduler.checkExists(job.getKey())){
log.info("存在相同的计划任务:{}",job.getKey());
scheduler.deleteJob(job.getKey());
scheduleJobResult.setJobKey(job.getKey());
scheduleJobResult.setTriggerKey(trigger.getKey());
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.ISEXIST);
scheduler.scheduleJob(job,trigger);
scheduler.start();
}else{
scheduler.scheduleJob(job,trigger);
scheduler.start();
scheduleJobResult.setJobKey(job.getKey());
scheduleJobResult.setTriggerKey(trigger.getKey());
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.SUCCESS);
}
//计划任务分配成功
return scheduleJobResult;
}
/**
* Interrupt all instances of the identified InterruptableJob executing in
* this Scheduler instance.
*
* <p>
* This method is not cluster aware. That is, it will only interrupt
* instances of the identified InterruptableJob currently executing in this
* Scheduler instance, not across the entire cluster.
* </p>
*
* @see org.quartz.core.RemotableQuartzScheduler#interrupt(JobKey)
*/
public boolean interrupt(JobKey jobKey) throws UnableToInterruptJobException {
List<JobExecutionContext> jobs = getCurrentlyExecutingJobs();
JobDetail jobDetail = null;
Job job = null;
boolean interrupted = false;
for(JobExecutionContext jec : jobs) {
jobDetail = jec.getJobDetail();
if (jobKey.equals(jobDetail.getKey())) {
job = jec.getJobInstance();
if (job instanceof InterruptableJob) {
((InterruptableJob)job).interrupt();
interrupted = true;
} else {
throw new UnableToInterruptJobException(
"Job " + jobDetail.getKey() +
" can not be interrupted, since it does not implement " +
InterruptableJob.class.getName());
}
}
}
return interrupted;
}
public List<ScheduleJob> getRunningJobList() throws SchedulerException{
List<JobExecutionContext> executingJobList = scheduler.getCurrentlyExecutingJobs();
List<ScheduleJob> jobList = new ArrayList<>(executingJobList.size());
for(JobExecutionContext executingJob : executingJobList){
ScheduleJob scheduleJob = new ScheduleJob();
JobDetail jobDetail = executingJob.getJobDetail();
JobKey jobKey = jobDetail.getKey();
Trigger trigger = executingJob.getTrigger();
this.wrapScheduleJob(scheduleJob,scheduler,jobKey,trigger);
jobList.add(scheduleJob);
}
return jobList;
}
/**
* 执行计划任务
* @param job
* @param trigger
* @return
* @throws SchedulerException
*/
public static ScheduleJobResult executeScheduleJob(JobDetail job, Trigger trigger) throws SchedulerException {
ScheduleJobResult scheduleJobResult = new ScheduleJobResult();
//判断是否满足计划任务的创建条件
if(job.getKey() == null || trigger.getKey() == null || job.getJobDataMap() == null){
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.FAILED);
//不满足计划任务的创建条件，返回scheduleJobResult值类
return scheduleJobResult;
}
scheduleJobResult.setJobDetail(job);
scheduleJobResult.setTrigger(trigger);
//开始分配计划任务
Scheduler scheduler = SchedulerFactory.getScheduler();
//开始判断是否存在相同的计划任务
if(scheduler.checkExists(job.getKey())){
log.info("存在相同的计划任务:{}",job.getKey());
scheduler.deleteJob(job.getKey());
scheduleJobResult.setJobKey(job.getKey());
scheduleJobResult.setTriggerKey(trigger.getKey());
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.ISEXIST);
scheduler.scheduleJob(job,trigger);
scheduler.start();
}else{
scheduler.scheduleJob(job,trigger);
scheduler.start();
scheduleJobResult.setJobKey(job.getKey());
scheduleJobResult.setTriggerKey(trigger.getKey());
scheduleJobResult.setScheduleJobStatus(ScheduleJobStatus.SUCCESS);
}
//计划任务分配成功
return scheduleJobResult;
}
/**
* Helper to update all triggers for a job (except the fired trigger)
* which are WAITING/PAUSED to BLOCKED/PAUSE_BLOCKED state.
*
* @see #triggersFired
*/
private void blockTriggers(final ODatabaseDocumentTx db,
final TriggerKey firedTriggerKey,
final JobDetail jobDetail)
{
JobKey jobKey = jobDetail.getKey();
log.trace("Blocking other triggers: firedTriggerKey={}, jobKey={}", firedTriggerKey, jobKey);
Iterable<TriggerEntity> matches = triggerEntityAdapter.browseWithPredicate
(db, input -> {
switch (input.getState()) {
case WAITING:
case PAUSED:
return jobKey.equals(input.getValue().getJobKey());
}
return false;
});
if (isMultiNodeTask(jobDetail)) {
matches = local(matches); // multinode task; each node only needs to block local triggers
}
for (TriggerEntity entity : matches) {
if (entity.getState() == PAUSED) {
entity.setState(PAUSED_BLOCKED);
}
else {
entity.setState(BLOCKED);
}
triggerEntityAdapter.editEntity(db, entity);
}
}
/**
* Helper to update all triggers for a job which are BLOCKED/PAUSED_BLOCKED to WAITING/PAUSED state.
*
* @see #triggeredJobComplete
*/
private void unblockTriggers(final ODatabaseDocumentTx db, final JobDetail jobDetail) {
JobKey jobKey = jobDetail.getKey();
log.trace("Unblock triggers: jobKey={}", jobKey);
Iterable<TriggerEntity> matches = triggerEntityAdapter.browseWithPredicate
(db, input -> {
switch (input.getState()) {
case BLOCKED:
case PAUSED_BLOCKED:
return jobKey.equals(input.getValue().getJobKey());
}
return false;
});
if (isMultiNodeTask(jobDetail)) {
matches = local(matches); // multinode task; each node only needs to unblock local triggers
}
for (TriggerEntity entity : matches) {
if (entity.getState() == PAUSED_BLOCKED) {
entity.setState(PAUSED);
}
else {
entity.setState(WAITING);
}
triggerEntityAdapter.editEntity(db, entity);
}
}
/**
* Populate entity fields used for indexing.
*/
@Override
public void setValue(final JobDetail value) {
super.setValue(value);
JobKey key = value.getKey();
checkState(key != null, "Missing key");
setName(key.getName());
setGroup(key.getGroup());
Class clazz = value.getJobClass();
checkState(clazz != null, "Missing job-class");
setJobType(clazz.getCanonicalName());
}
/**
* Attach {@link QuartzTaskJobListener} to job.
*/
private QuartzTaskJobListener attachJobListener(final JobDetail jobDetail,
final Trigger trigger) throws SchedulerException
{
log.debug("Initializing task-state: jobDetail={}, trigger={}", jobDetail, trigger);
Date now = new Date();
TaskConfiguration taskConfiguration = configurationOf(jobDetail);
Schedule schedule = triggerConverter.convert(trigger);
QuartzTaskState taskState = new QuartzTaskState(
taskConfiguration,
schedule,
trigger.getFireTimeAfter(now)
);
QuartzTaskFuture future = null;
if (schedule instanceof Now) {
future = new QuartzTaskFuture(
this,
jobDetail.getKey(),
taskConfiguration.getTaskLogName(),
now,
schedule,
null
);
}
QuartzTaskJobListener listener = new QuartzTaskJobListener(
listenerName(jobDetail.getKey()),
eventManager,
this,
new QuartzTaskInfo(eventManager, this, jobDetail.getKey(), taskState, future)
);
scheduler.getListenerManager().addJobListener(listener, keyEquals(jobDetail.getKey()));
return listener;
}
/**
* Creates a stub of a {@link QuartzTaskJobListener} attached to the job with scheduling unset.
* See NEXUS-18983
*/
private QuartzTaskJobListener stubJobListener(final JobDetail jobDetail) throws SchedulerException {
log.debug("Stubbing task-state: jobDetail={}", jobDetail);
TaskConfiguration taskConfiguration = configurationOf(jobDetail);
Schedule schedule = scheduleFactory.manual();
QuartzTaskState taskState = new QuartzTaskState(taskConfiguration, schedule, null);
QuartzTaskJobListener listener = new QuartzTaskJobListener(listenerName(jobDetail.getKey()), eventManager, this,
new QuartzTaskInfo(eventManager, this, jobDetail.getKey(), taskState, null));
scheduler.getListenerManager().addJobListener(listener, keyEquals(jobDetail.getKey()));
return listener;
}
@Test
public void testServiceJobDetail() throws SchedulerException, ParseException {
JobDetail job = createServiceJob("test1");
assertNotNull(job);
JobKey details = job.getKey();
assertEquals("test1", details.getName());
assertEquals(SchedulerHelper.DEFAULT_GROUP, details.getGroup());
assertEquals(3, job.getJobDataMap().size());
}
@Test
public void testConfiguredJobDetail() throws SchedulerException, ParseException {
JobDetail job = createConfiguredJob("test2");
assertNotNull(job);
JobKey details = job.getKey();
assertEquals("test2", details.getName());
assertEquals(SchedulerHelper.DEFAULT_GROUP, details.getGroup());
assertEquals(2, job.getJobDataMap().size());
}
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
JobDetail jobDetail = context.getJobDetail();
Object params = jobDetail.getJobDataMap().get(QuartzConst.QUARTZ_PARAMS_KEY);
JobKey jobKey = jobDetail.getKey();
Long taskId = SmartQuartzUtil.getTaskIdByJobKey(jobKey);
QuartzTaskService quartzTaskService = (QuartzTaskService) SmartApplicationContext.getBean("quartzTaskService");
QuartzTaskEntity quartzTaskEntity = quartzTaskService.getByTaskId(taskId);
QuartzTaskLogService quartzTaskLogService = (QuartzTaskLogService) SmartApplicationContext.getBean("quartzTaskLogService");
QuartzTaskLogEntity taskLogEntity = new QuartzTaskLogEntity();
taskLogEntity.setTaskId(taskId);
taskLogEntity.setIpAddress(SmartIPUtil.getLocalHostIP());
taskLogEntity.setTaskName(quartzTaskEntity.getTaskName());
String paramsStr = null;
if (params != null) {
paramsStr = params.toString();
taskLogEntity.setTaskParams(paramsStr);
}
taskLogEntity.setUpdateTime(new Date());
taskLogEntity.setCreateTime(new Date());
//任务开始时间
long startTime = System.currentTimeMillis();
try {
ITask taskClass = (ITask) SmartApplicationContext.getBean(quartzTaskEntity.getTaskBean());
taskClass.execute(paramsStr);
taskLogEntity.setProcessStatus(TaskResultEnum.SUCCESS.getStatus());
} catch (Exception e) {
log.error("", e);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw, true);
e.printStackTrace(pw);
pw.flush();
sw.flush();
taskLogEntity.setProcessStatus(TaskResultEnum.FAIL.getStatus());
taskLogEntity.setProcessLog(sw.toString());
} finally {
long times = System.currentTimeMillis() - startTime;
taskLogEntity.setProcessDuration(times);
quartzTaskLogService.save(taskLogEntity);
}
}
JobWrapper(JobDetail jobDetail) {
this.jobDetail = jobDetail;
key = jobDetail.getKey();
}
/**
* <p>
* Add the <code>{@link org.quartz.Job}</code> identified by the given
* <code>{@link org.quartz.JobDetail}</code> to the Scheduler, and
* associate the given <code>{@link org.quartz.Trigger}</code> with it.
* </p>
*
* <p>
* If the given Trigger does not reference any <code>Job</code>, then it
* will be set to reference the Job passed with it into this method.
* </p>
*
* @throws SchedulerException
* if the Job or Trigger cannot be added to the Scheduler, or
* there is an internal Scheduler error.
*/
public Date scheduleJob(JobDetail jobDetail,
Trigger trigger) throws SchedulerException {
validateState();
if (jobDetail == null) {
throw new SchedulerException("JobDetail cannot be null");
}
if (trigger == null) {
throw new SchedulerException("Trigger cannot be null");
}
if (jobDetail.getKey() == null) {
throw new SchedulerException("Job's key cannot be null");
}
if (jobDetail.getJobClass() == null) {
throw new SchedulerException("Job's class cannot be null");
}
OperableTrigger trig = (OperableTrigger)trigger;
if (trigger.getJobKey() == null) {
trig.setJobKey(jobDetail.getKey());
} else if (!trigger.getJobKey().equals(jobDetail.getKey())) {
throw new SchedulerException(
"Trigger does not reference given job!");
}
trig.validate();
Calendar cal = null;
if (trigger.getCalendarName() != null) {
cal = resources.getJobStore().retrieveCalendar(trigger.getCalendarName());
}
Date ft = trig.computeFirstFireTime(cal);
if (ft == null) {
throw new SchedulerException(
"Based on configured schedule, the given trigger '" + trigger.getKey() + "' will never fire.");
}
resources.getJobStore().storeJobAndTrigger(jobDetail, trig);
notifySchedulerListenersJobAdded(jobDetail);
notifySchedulerThread(trigger.getNextFireTime().getTime());
notifySchedulerListenersSchduled(trigger);
return ft;
}