下面列出了怎么用org.quartz.JobBuilder的API类实例代码及写法，或者点击链接到github查看源代码。
public static TaskTrigger getIntervalTask(long interval, long delay, Class<? extends Job> jobClass) {
JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobClass.getName()).build();
Trigger trigger;
if (delay > 0) {
trigger = TriggerBuilder.newTrigger()
.withIdentity(jobClass.getName())
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startAt(new Date(System.currentTimeMillis() + delay)).build();
} else {
trigger = TriggerBuilder.newTrigger()
.withIdentity(jobClass.getName())
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startNow().build();
}
return new TaskTrigger(job, trigger);
}
public static TaskTrigger getIntervalTask(long interval, long delay, String taskName, TaskJob taskJob) {
JobDetail job = JobBuilder.newJob(TaskObjJob.class).withIdentity(taskName).build();
Trigger trigger;
if (delay > 0) {
trigger = TriggerBuilder.newTrigger()
.withIdentity(taskName)
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startAt(new Date(System.currentTimeMillis() + delay)).build();
} else {
trigger = TriggerBuilder.newTrigger()
.withIdentity(taskName)
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startNow().build();
}
TaskObjJob.bindTriggerWithObj(trigger, taskJob);
return new TaskTrigger(job, trigger);
}
private void scheduleImport(String file, String siteId) {
JobDataMap jobData = new JobDataMap();
jobData.put("zip", file);
if (siteId != null) {
jobData.put("siteId", siteId);
}
JobDetail jobDetail = JobBuilder.newJob(ImportJob.class)
.withIdentity("Import Job")
.setJobData(jobData)
.build();
Scheduler scheduler = schedulerManager.getScheduler();
try {
scheduler.addJob(jobDetail, true, true);
scheduler.triggerJob(jobDetail.getKey());
} catch (SchedulerException e) {
log.warn("Problem adding job to scheduler to import "+ file, e);
}
}
/**
* Convenience method for creating a JobDetail object from a JobBeanWrapper. The JobDetail object is
* used to actually create a job within Quartz, and is also tracked by the {@link getJobDetail()} property
* for use during the property editting process.
*
* @param job
* @return JobDetail object constructed from the job argument
*/
private JobDetail createJobDetail (JobBeanWrapper job) {
jobName = escapeEntities(jobName);
JobDetail
jd = JobBuilder.newJob(job.getJobClass())
.withIdentity(jobName, Scheduler.DEFAULT_GROUP)
.requestRecovery()
.storeDurably()
.build();
JobDataMap
map = jd.getJobDataMap();
map.put(JobBeanWrapper.SPRING_BEAN_NAME, job.getBeanId());
map.put(JobBeanWrapper.JOB_NAME, job.getJobName());
return jd;
}
@Override
public void afterPropertiesSet () throws Exception
{
Map<String, AbstractJob> webappBeanNames =
applicationContext.getBeansOfType (AbstractJob.class);
triggers = new HashMap<> ();
for (String webappBeanName : webappBeanNames.keySet ())
{
AbstractJob cron = webappBeanNames.get (webappBeanName);
CronTriggerFactoryBean trigger = new CronTriggerFactoryBean ();
JobDetail job = JobBuilder.newJob (cron.getClass ()).
storeDurably (true).build ();
trigger.setJobDetail (job);
trigger.setCronExpression (cron.getCronExpression ());
trigger.setName (webappBeanName + "Trigger");
trigger.afterPropertiesSet ();
triggers.put (cron.getClass(), trigger.getObject ());
}
super.setTriggers (triggers.values ().toArray (
new Trigger[triggers.size ()]));
super.setJobFactory (autowiringJobFactory);
super.afterPropertiesSet ();
}
public JobDetail addStatefulMethodJob(String schedulerName, String jobName, String jobGroup, String jobClass,
Object[] constructorArguments, String jobClassMethodName,
Object[] jobClassMethodArgs, String description) throws SchedulerException {
Assert.notNull(jobClass, "jobClass can not be null");
Assert.notEmpty(schedulerName, "schedulerName can not be empty");
Assert.notEmpty(jobName, "jobName can not be empty");
Assert.notEmpty(jobGroup, "jobGroup can not be empty");
Assert.notEmpty(jobClassMethodName, "jobClassMethodName can not be empty");
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put("jobClass", jobClass);
jobDataMap.put("constructorArguments", constructorArguments);
jobDataMap.put("jobClassMethodName", jobClassMethodName);
jobDataMap.put("jobClassMethodArgs", jobClassMethodArgs);
JobDetail jobDetail = JobBuilder.newJob(StatefulMethodInvokeJob.class).withIdentity(jobName, jobGroup)
.withDescription(description).setJobData(jobDataMap).storeDurably().build();
addJob(schedulerName, jobDetail);
return jobDetail;
}
public JobDetail updateStatefulMethodJob(String schedulerName, String jobName, String jobGroup, String jobClass,
Object[] constructorArguments, String jobClassMethodName,
Object[] jobClassMethodArgs, String description) throws SchedulerException {
Assert.notNull(jobClass, "jobClass can not be null");
Assert.notEmpty(schedulerName, "schedulerName can not be empty");
Assert.notEmpty(jobName, "jobName can not be empty");
Assert.notEmpty(jobGroup, "jobGroup can not be empty");
Assert.notEmpty(jobClassMethodName, "jobClassMethodName can not be empty");
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put("jobClass", jobClass);
jobDataMap.put("constructorArguments", constructorArguments);
jobDataMap.put("jobClassMethodName", jobClassMethodName);
jobDataMap.put("jobClassMethodArgs", jobClassMethodArgs);
JobDetail jobDetail = JobBuilder.newJob(StatefulMethodInvokeJob.class).withIdentity(jobName, jobGroup)
.withDescription(description).setJobData(jobDataMap).storeDurably().build();
updateJob(schedulerName, jobDetail);
return jobDetail;
}
public static JobDetail createDetails(MessageChannel channel, Member member, String message) {
String userId;
String guildId = null;
if (channel instanceof PrivateChannel) {
userId = ((PrivateChannel) channel).getUser().getId();
} else {
guildId = member.getGuild().getId();
userId = member.getUser().getId();
}
return JobBuilder
.newJob(ReminderJob.class)
.withIdentity(GROUP + " - " + UUID.randomUUID(), GROUP)
.usingJobData(ATTR_GUILD_ID, guildId)
.usingJobData(ATTR_USER_ID, userId)
.usingJobData(ATTR_CHANNEL_ID, channel.getId())
.usingJobData(ATTR_MESSAGE, message)
.build();
}
private void scheduleImport(String file, String siteId) {
JobDataMap jobData = new JobDataMap();
jobData.put("zip", file);
if (siteId != null) {
jobData.put("siteId", siteId);
}
JobDetail jobDetail = JobBuilder.newJob(ImportJob.class)
.withIdentity("Import Job")
.setJobData(jobData)
.build();
Scheduler scheduler = schedulerManager.getScheduler();
try {
scheduler.addJob(jobDetail, true, true);
scheduler.triggerJob(jobDetail.getKey());
} catch (SchedulerException e) {
log.warn("Problem adding job to scheduler to import "+ file, e);
}
}
@Test
public void triggeredJobCompleteNonConcurrent() throws JobPersistenceException {
JobDetail job = JobBuilder.newJob(TestJobNonConcurrent.class)
.withIdentity("testJobNonConcurrent1", "jobGroupNonConcurrent1")
.usingJobData("timeout", 42)
.withDescription("I am describing a job!")
.build();
CronTriggerImpl trigger1 = getCronTrigger("triggerNonConcurrent1", "triggerNonConcurrentGroup1", job.getKey());
CronTriggerImpl trigger2 = getCronTrigger("triggerNonConcurrent2", "triggerNonConcurrentGroup1", job.getKey());
storeJobAndTriggers(job, trigger1, trigger2);
jobStore.triggeredJobComplete(trigger1, job, Trigger.CompletedExecutionInstruction.SET_TRIGGER_COMPLETE);
assertEquals(Trigger.TriggerState.COMPLETE, jobStore.getTriggerState(trigger1.getKey()));
final String jobHashKey = schema.jobHashKey(job.getKey());
assertFalse(jedis.sismember(schema.blockedJobsSet(), jobHashKey));
}
public void updateJob(String group, String name, JobDescriptor descriptor) {
try {
JobDetail oldJobDetail = scheduler.getJobDetail(jobKey(name, group));
if(Objects.nonNull(oldJobDetail)) {
JobDataMap jobDataMap = oldJobDetail.getJobDataMap();
jobDataMap.put("subject", descriptor.getSubject());
jobDataMap.put("messageBody", descriptor.getMessageBody());
jobDataMap.put("to", descriptor.getTo());
jobDataMap.put("cc", descriptor.getCc());
jobDataMap.put("bcc", descriptor.getBcc());
JobBuilder jb = oldJobDetail.getJobBuilder();
JobDetail newJobDetail = jb.usingJobData(jobDataMap).storeDurably().build();
scheduler.addJob(newJobDetail, true);
log.info("Updated job with key - {}", newJobDetail.getKey());
return;
}
log.warn("Could not find job with key - {}.{} to update", group, name);
} catch (SchedulerException e) {
log.error("Could not find job with key - {}.{} to update due to error - {}", group, name, e.getLocalizedMessage());
}
}
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());
}
}
@Test
public void jobDataOnlySavedWhenDirty() throws Exception {
JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("testJob").build();
OperableTrigger trigger = (OperableTrigger) TriggerBuilder.newTrigger().withIdentity("testJob").forJob(job).build();
jobStore.storeJobAndTrigger(job, trigger);
int baseRecordVersion = queryJobDetail("testJob").getVersion();
// same job data after trigger fired...
jobStore.triggersFired(Arrays.asList(trigger));
jobStore.triggeredJobComplete(trigger, job, CompletedExecutionInstruction.NOOP);
// ...should not save the job
assertThat(queryJobDetail("testJob").getVersion(), is(baseRecordVersion));
// different job data after trigger fired...
jobStore.triggersFired(Arrays.asList(trigger));
job.getJobDataMap().put("testKey", "testValue");
jobStore.triggeredJobComplete(trigger, job, CompletedExecutionInstruction.NOOP);
// ...should save the job
assertThat(queryJobDetail("testJob").getVersion(), greaterThan(baseRecordVersion));
}
private void addJob(ScheduleJob scheduleJob) throws Exception{
checkNotNull(scheduleJob);
Preconditions.checkNotNull(StringUtils.isEmpty(scheduleJob.getCronExpression()), "CronExpression is null");
TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
if(trigger != null){
throw new Exception("job already exists!");
}
// simulate job info db persist operation
scheduleJob.setJobId(String.valueOf(QuartzJobFactory.jobList.size()+1));
QuartzJobFactory.jobList.add(scheduleJob);
JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class).withIdentity(scheduleJob.getJobName(),scheduleJob.getJobGroup()).build();
jobDetail.getJobDataMap().put("scheduleJob", scheduleJob);
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
trigger = TriggerBuilder.newTrigger().withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
}
private synchronized void scheduleLocalTask(String taskName, boolean paused) throws TaskException {
TaskInfo taskInfo = this.getTaskRepository().getTask(taskName);
String taskGroup = this.getTenantTaskGroup();
if (taskInfo == null) {
throw new TaskException("Non-existing task for scheduling with name: " + taskName,
TaskException.Code.NO_TASK_EXISTS);
}
if (this.isPreviouslyScheduled(taskName, taskGroup)) {
/* to make the scheduleLocalTask operation idempotent */
return;
}
Class<? extends Job> jobClass = taskInfo.getTriggerInfo().isDisallowConcurrentExecution() ?
NonConcurrentTaskQuartzJobAdapter.class :
TaskQuartzJobAdapter.class;
JobDetail job = JobBuilder.newJob(jobClass).withIdentity(taskName, taskGroup).usingJobData(
this.getJobDataMapFromTaskInfo(taskInfo)).build();
Trigger trigger = this.getTriggerFromInfo(taskName, taskGroup, taskInfo.getTriggerInfo());
try {
this.getScheduler().scheduleJob(job, trigger);
if (paused) {
this.getScheduler().pauseJob(job.getKey());
}
log.info("Task scheduled: [" + this.getTaskType() + "][" + taskName + "]" + (paused ? " [Paused]." : "."));
} catch (SchedulerException e) {
throw new TaskException("Error in scheduling task with name: " + taskName, TaskException.Code.UNKNOWN, e);
}
}
private void createExpressionObserverJob(
JobKey jobKey, UUID triggerKey, String configExpression, String cronExpression) throws SchedulerException
{
if (!ClassDeactivationUtils.isActivated(DynamicExpressionObserverJob.class))
{
return;
}
JobKey observerJobKey =
new JobKey(jobKey.getName() + DynamicExpressionObserverJob.OBSERVER_POSTFIX, jobKey.getGroup());
JobDetail jobDetail = JobBuilder.newJob(DynamicExpressionObserverJob.class)
.usingJobData(DynamicExpressionObserverJob.CONFIG_EXPRESSION_KEY, configExpression)
.usingJobData(DynamicExpressionObserverJob.TRIGGER_ID_KEY, triggerKey.toString())
.usingJobData(DynamicExpressionObserverJob.ACTIVE_CRON_EXPRESSION_KEY, cronExpression)
.withDescription("Config observer for: " + jobKey)
.withIdentity(observerJobKey)
.build();
Trigger trigger = TriggerBuilder.newTrigger()
.forJob(observerJobKey)
.withSchedule(CronScheduleBuilder.cronSchedule(
SchedulerBaseConfig.JobCustomization.DYNAMIC_EXPRESSION_OBSERVER_INTERVAL))
.build();
this.scheduler.scheduleJob(jobDetail, trigger);
}
public JobDetail loadHTLCJobDetail(
String jobName, String dataKey, HTLCResourcePair htlcResourcePair) {
// create job
JobDetail jobDetail =
JobBuilder.newJob(HTLCJob.class)
.withIdentity(jobName, Scheduler.DEFAULT_GROUP)
.build();
// send args to job context
jobDetail.getJobDataMap().putIfAbsent(dataKey, htlcResourcePair);
return jobDetail;
}
/**
* 创建定时任务
*/
public static void createScheduleJob(Scheduler scheduler, SysJob job) throws SchedulerException, TaskException
{
Class<? extends Job> jobClass = getQuartzJobClass(job);
// 构建job信息
Long jobId = job.getJobId();
String jobGroup = job.getJobGroup();
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(getJobKey(jobId, jobGroup)).build();
// 表达式调度构建器
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);
// 按新的cronExpression表达式构建一个新的trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(jobId, jobGroup))
.withSchedule(cronScheduleBuilder).build();
// 放入参数，运行时的方法可以获取
jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);
// 判断是否存在
if (scheduler.checkExists(getJobKey(jobId, jobGroup)))
{
// 防止创建时存在数据问题 先移除，然后在执行创建操作
scheduler.deleteJob(getJobKey(jobId, jobGroup));
}
scheduler.scheduleJob(jobDetail, trigger);
// 暂停任务
if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
{
scheduler.pauseJob(ScheduleUtils.getJobKey(jobId, jobGroup));
}
}
public void addJob(QuartzJob quartzJob){
try {
// 构建job信息
JobDetail jobDetail = JobBuilder.newJob(ExecutionJob.class).
withIdentity(JOB_NAME + quartzJob.getId()).build();
//通过触发器名和cron 表达式创建 Trigger
Trigger cronTrigger = newTrigger()
.withIdentity(JOB_NAME + quartzJob.getId())
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(quartzJob.getCronExpression()))
.build();
cronTrigger.getJobDataMap().put(QuartzJob.JOB_KEY, quartzJob);
//重置启动时间
((CronTriggerImpl)cronTrigger).setStartTime(new Date());
//执行定时任务
scheduler.scheduleJob(jobDetail,cronTrigger);
// 暂停任务
if (quartzJob.getIsPause()) {
pauseJob(quartzJob);
}
} catch (Exception e){
log.error("创建定时任务失败", e);
throw new BadRequestException("创建定时任务失败");
}
}
private void scheduleJob(Scheduler sched, String name,
int mode, long interval, Class task, JobDataMap data)
throws SchedulerException {
Trigger t = createTrigger(name, updateIndexGroupName, mode, interval);
JobBuilder d = newJob(task).withIdentity(name, updateIndexGroupName);
d.usingJobData(data);
sched.scheduleJob(d.build(), t);
}
@Test
void testJobWithGroup() throws SchedulerException {
JobDetail job = JobBuilder.newJob(TestJob.class)
.withIdentity("dummyJobName", "group1").build();
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("myTrigger")
.withSchedule(
SimpleScheduleBuilder.repeatSecondlyForTotalCount(1, 1))
.build();
scheduler.scheduleJob(job, trigger);
verifyJobDetails(job);
}
@Test
void testJobWithoutGroup() throws SchedulerException {
JobDetail job = JobBuilder.newJob(TestJob.class)
.withIdentity("dummyJobName").build();
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("myTrigger")
.withSchedule(
SimpleScheduleBuilder.repeatSecondlyForTotalCount(1, 1))
.build();
scheduler.scheduleJob(job, trigger);
verifyJobDetails(job);
}
@Test
void testSpringJob() throws SchedulerException {
JobDetail job = JobBuilder.newJob(TestSpringJob.class)
.withIdentity("dummyJobName", "group1").build();
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("myTrigger")
.withSchedule(
SimpleScheduleBuilder.repeatSecondlyForTotalCount(1, 1))
.build();
scheduler.scheduleJob(job, trigger);
verifyJobDetails(job);
}
@Test
void testJobWithResult() throws SchedulerException {
JobDetail job = JobBuilder.newJob(TestJobWithResult.class)
.withIdentity("dummyJobName").build();
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("myTrigger")
.withSchedule(
SimpleScheduleBuilder.repeatSecondlyForTotalCount(1, 1))
.build();
scheduler.scheduleJob(job, trigger);
verifyJobDetails(job);
assertThat(reporter.getTransactions().get(0).getResult()).isEqualTo("this is the result");
}
private void createOrUpdateAlertJob(Set<JobKey> scheduledJobs, DetectionAlertConfigDTO alertConfig)
throws SchedulerException {
Long id = alertConfig.getId();
boolean isActive = alertConfig.isActive();
JobKey key = new JobKey(getJobKey(id, TaskConstants.TaskType.DETECTION_ALERT), QUARTZ_SUBSCRIPTION_GROUPER);
JobDetail job = JobBuilder.newJob(DetectionAlertJob.class).withIdentity(key).build();
boolean isScheduled = scheduledJobs.contains(key);
if (isActive) {
if (isScheduled) {
String cronInDatabase = alertConfig.getCronExpression();
List<Trigger> triggers = (List<Trigger>) scheduler.getTriggersOfJob(key);
CronTrigger cronTrigger = (CronTrigger) triggers.get(0);
String cronInSchedule = cronTrigger.getCronExpression();
// cron expression has been updated, restart this job
if (!cronInDatabase.equals(cronInSchedule)) {
LOG.info(
"Cron expression for config {} with jobKey {} has been changed from {} to {}. " + "Restarting schedule",
id, key, cronInSchedule, cronInDatabase);
stopJob(key);
startJob(alertConfig, job);
}
} else {
LOG.info("Found active but not scheduled {}", id);
startJob(alertConfig, job);
}
} else {
if (isScheduled) {
LOG.info("Found inactive but scheduled {}", id);
stopJob(key);
}
// for all jobs with not isActive, and not isScheduled, no change required
}
}
/**
* 添加任务
*
* @param quartzJob
*/
public void addJob(QuartzJob quartzJob) {
try {
log.info("开始创建任务{}", quartzJob.getJobName());
// 构建job信息
JobDetail jobDetail = JobBuilder.newJob(ExecutionJob.class).
withIdentity(JOB_NAME + quartzJob.getId()).build();
//通过触发器名和cron 表达式创建 Trigger
Trigger cronTrigger = newTrigger()
.withIdentity(JOB_NAME + quartzJob.getId())
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(quartzJob.getCronExpression()))
.build();
cronTrigger.getJobDataMap().put(QuartzJob.JOB_KEY, quartzJob);
//重置启动时间
((CronTriggerImpl) cronTrigger).setStartTime(new Date());
//执行定时任务
scheduler.scheduleJob(jobDetail, cronTrigger);
// 暂停任务
if (!quartzJob.getStatus().booleanValue()) {
pauseJob(quartzJob);
}
} catch (Exception e) {
log.error("创建定时任务失败", e);
throw new CustomException("创建定时任务失败");
}
}
public static TaskTrigger getCronTask(String cron, Class<? extends Job> jobClass) {
JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobClass.getName()).build();
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(jobClass.getName())
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.startNow().build();
return new TaskTrigger(job, trigger);
}
public static TaskTrigger getCronTask(String cron, MethodInvoke methodInvoke) {
JobDetail job = JobBuilder.newJob(TaskMethodJob.class).withIdentity(methodInvoke.getMethod().getName(), methodInvoke.getObj().getClass().getName()).build();
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(methodInvoke.getMethod().getName(), methodInvoke.getObj().getClass().getName())
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.startNow().build();
TaskMethodJob.bindTriggerWithMethod(trigger, methodInvoke);
return new TaskTrigger(job, trigger);
}
/**
* 创建任务
*
* @param scheduler scheduler
* @param job job
* @param params params
*/
public static void createJob(Scheduler scheduler, JobInfo job, Map<String, Object> params) throws SchedulerException {
Class<? extends Job> jobClass = JobQuartzJobBean.class;
// 构建job信息
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(job.getJobName(), job.getJobGroup()).build();
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCron());
// 按新的cron表达式构建一个新的trigger
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())
.withSchedule(scheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
}
private void scheduleJob(
Class<? extends Job> jobClass, SimpleScheduleBuilder simpleScheduleBuilder)
throws SchedulerException {
JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobClass.getSimpleName()).build();
Trigger trigger =
TriggerBuilder.newTrigger().startNow().withSchedule(simpleScheduleBuilder).build();
_scheduler.scheduleJob(job, trigger);
}