下面列出了怎么用org.quartz.TriggerBuilder的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public void produce(Map<String, String> lastOffsets, int maxBatchSize) {
try {
JobDetail job = JobBuilder.newJob(SchedulerJob.class)
.withIdentity(context.getPipelineId(), "dataCollectorJobGroup")
.build();
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(conf.cronExpression)
.inTimeZone(TimeZone.getTimeZone(ZoneId.of(conf.timeZoneID)));
cronTrigger = TriggerBuilder.newTrigger()
.withIdentity(context.getPipelineId(), "dataCollectorJobGroup")
.withSchedule(cronScheduleBuilder)
.build();
scheduler.getContext().put(PUSH_SOURCE_CONTEXT, context);
scheduler.scheduleJob(job, cronTrigger);
scheduler.start();
while (!context.isStopped()) {
dispatchErrors();
}
} catch (Exception e) {
LOG.error(e.getMessage(), e);
context.reportError(e);
}
}
public Trigger getTrigger(Trigger trigger) throws ParseException {
fixParameters();
TriggerBuilder<Trigger> builder = TriggerBuilder.newTrigger().forJob(trigger.getJobKey().getName(), trigger.getJobKey().getGroup())
.withIdentity(trigger.getKey().getName(), trigger.getKey().getGroup())
.startAt(startTime).endAt(endTime)
.usingJobData(JobDataMapUtils.fromDataMapStr(dataMap));
if (repeatCount == -1) {
builder.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever()
.withIntervalInMilliseconds(intervalInMilliseconds));
} else {
builder.withSchedule(SimpleScheduleBuilder.simpleSchedule().withRepeatCount(repeatCount)
.withIntervalInMilliseconds(intervalInMilliseconds));
}
return builder.build();
}
public void schedule(Runnable r, String cronExpression, boolean longRunning) {
try {
JobDataMap jdm = new JobDataMap();
jdm.put(RunnableRunner.KEY_RUNNABLE_OBJECT, r);
jdm.put(RunnableRunner.KEY_PROPERTY_IS_LONGRUNNING_TASK, longRunning);
jdm.put(RunnableRunner.KEY_CRON_EXPRESSION, cronExpression);
String jobId = "Started at ms" + System.currentTimeMillis() + "; ns" + System.nanoTime();
JobKey jobKey = new JobKey("JobKey:" + jobId);
JobDetail jobDetail = JobBuilder.newJob(runnableRunner).usingJobData(jdm).withIdentity(jobKey).build();
CronScheduleBuilder csb = CronScheduleBuilder.cronSchedule(cronExpression);
CronTrigger trigger = TriggerBuilder.newTrigger().withSchedule(csb).build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (Exception e) {
throw new CronServiceException("Failed to start job", e);
}
}
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);
}
public static TaskTrigger getIntervalTask(long interval, long delay, MethodInvoke methodInvoke) {
JobDetail job = JobBuilder.newJob(TaskMethodJob.class).withIdentity(methodInvoke.getMethod().getName(), methodInvoke.getObj().getClass().getName()).build();
Trigger trigger;
if (delay > 0) {
trigger = TriggerBuilder.newTrigger()
.withIdentity(methodInvoke.getMethod().getName(), methodInvoke.getObj().getClass().getName())
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startAt(new Date(System.currentTimeMillis() + delay)).build();
} else {
trigger = TriggerBuilder.newTrigger()
.withIdentity(methodInvoke.getMethod().getName(), methodInvoke.getObj().getClass().getName())
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(interval).repeatForever())
.startNow().build();
}
TaskMethodJob.bindTriggerWithMethod(trigger, methodInvoke);
return new TaskTrigger(job, trigger);
}
/**
* Refresh metadata. Schedules the job to retrieve metadata.
* @throws SchedulerException the scheduler exception
*/
@PostConstruct
public void refreshMetadata() throws SchedulerException {
final Thread thread = new Thread(new Runnable() {
@Override
public void run() {
buildMetadataResolverAggregate();
}
});
thread.start();
final JobDetail job = JobBuilder.newJob(this.getClass())
.withIdentity(this.getClass().getSimpleName()).build();
final Trigger trigger = TriggerBuilder.newTrigger()
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInMinutes(this.refreshIntervalInMinutes)
.repeatForever()).build();
final SchedulerFactory schFactory = new StdSchedulerFactory();
final Scheduler sch = schFactory.getScheduler();
sch.start();
sch.scheduleJob(job, trigger);
}
/**
* 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;
}
protected <T extends Job> void schedule(final Class<T> reference, final Map<String, Object> jobMap)
throws JobExecutionException {
@SuppressWarnings("unchecked")
T jobInstance = (T) ApplicationContextProvider.getBeanFactory().
createBean(reference, AbstractBeanDefinition.AUTOWIRE_BY_TYPE, false);
String jobName = getClass().getName() + SecureRandomUtils.generateRandomUUID();
jobMap.put(JobManager.DOMAIN_KEY, AuthContextUtils.getDomain());
ApplicationContextProvider.getBeanFactory().registerSingleton(jobName, jobInstance);
JobBuilder jobDetailBuilder = JobBuilder.newJob(reference).
withIdentity(jobName).
usingJobData(new JobDataMap(jobMap));
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger().
withIdentity(JobNamer.getTriggerName(jobName)).
startNow();
try {
scheduler.getScheduler().scheduleJob(jobDetailBuilder.build(), triggerBuilder.build());
} catch (SchedulerException e) {
throw new JobExecutionException("Could not schedule, aborting", e);
}
}
private Trigger createTrigger(Scheduled scheduled, JobKey jobKey, String cronExpression) throws SchedulerException
{
UUID triggerKey = UUID.randomUUID();
if (!scheduled.cronExpression().endsWith(cronExpression))
{
createExpressionObserverJob(jobKey, triggerKey, scheduled.cronExpression(), cronExpression);
}
Trigger trigger = TriggerBuilder.newTrigger()
.forJob(jobKey)
.withIdentity(triggerKey.toString())
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
return trigger;
}
/**
* 创建复杂触发器
* @param jobName 作业名
* @param groupName 组名
* @param cronExpression cron表达式
* @param startTime 开始时间
* @param endTime 结束时间
* @return
*/
public static Trigger createCronTrigger(ExecutionContext executionContext, String cronExpression,Date startTime,Date endTime) {
TriggerBuilder<CronTrigger> triggerBuilder=newTrigger()
.withIdentity(GuidUtil.CreateGuid(), executionContext.getProcessDefinition().getId())
.withSchedule(cronSchedule(cronExpression));
if(startTime!=null){
triggerBuilder.startAt(startTime);
}
if(endTime!=null){
triggerBuilder.endAt(endTime);
}
CronTrigger trigger = triggerBuilder
.build();
return trigger;
}
public Trigger getTrigger() throws ParseException {
fixParameters();
TriggerBuilder<Trigger> builder = TriggerBuilder.newTrigger().forJob(name.trim(), group.trim()).withIdentity(triggerName.trim(), triggerGroup.trim())
.startAt(startTime).endAt(endTime)
.usingJobData(JobDataMapUtils.fromDataMapStr(dataMap));
if (repeatCount == -1) {
builder.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever()
.withIntervalInMilliseconds(intervalInMilliseconds));
} else {
builder.withSchedule(SimpleScheduleBuilder.simpleSchedule().withRepeatCount(repeatCount)
.withIntervalInMilliseconds(intervalInMilliseconds));
}
return builder.build();
}
/**
* 创建复杂触发器
*
* @param jobName
* 作业名
* @param groupName
* 组名
* @param cronExpression
* cron表达式
* @param startTime
* 开始时间
* @param endTime
* 结束时间
* @return
*/
public final static Trigger createCronTrigger(ListenerExecutionContext executionContext,
String cronExpression, Date startTime, Date endTime) {
TriggerBuilder<CronTrigger> triggerBuilder = newTrigger().withIdentity(GuidUtil.CreateGuid(), executionContext.getProcessInstanceId()).withSchedule(cronSchedule(cronExpression));
if (startTime != null) {
triggerBuilder.startAt(startTime);
}
if (endTime != null) {
triggerBuilder.endAt(endTime);
}
CronTrigger trigger = triggerBuilder.build();
return trigger;
}
@Override
public Trigger getTrigger()
{
try
{
return TriggerBuilder.newTrigger()
.withIdentity(getTriggerName(), getTriggerGroup())
.withSchedule(CronScheduleBuilder.cronSchedule(getCronExpression()))
.build();
}
// CronScheduleBuilder is throwing RuntimeException which is wrapping ParseException
catch (final RuntimeException e)
{
throw new InvalidCronExpression("Invalid chron expression: n" + getCronExpression());
}
}
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());
}
}
/**
* 注册 定时任务
* @param task 定时任务对象
* @throws SchedulerException
*/
private void scheduleJob(TSTimeTaskEntity task) throws SchedulerException {
//build 要执行的任务
JobDetail jobDetail = JobBuilder.newJob(MyClassLoader.getClassByScn(task.getClassName()))
.withIdentity(task.getId())
.storeDurably()
.requestRecovery()
.build();
//根据Cron表达式 build 触发时间对象
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCronExpression());
//build 任务触发器
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
.withIdentity("cron_" + task.getId())
.withSchedule(cronScheduleBuilder)//标明触发时间
.build();
//向调度器注册 定时任务
schedulerFactory.scheduleJob(jobDetail, cronTrigger);
}
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);
}
public void incur(ITaskService taskService, ITaskDescriptor taskDescriptor) throws TaskException{
// test if the runnable can be instantiated
taskService.instantiateRunnableById(taskDescriptor.getIdentifiedRunnableId());
String cron = taskDescriptor.getTriggerParameters().get("cron");
CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(cron);
JobKey jobKey = new JobKey(taskDescriptor.getId());
JobDataMap jobDataMap = new JobDataMap(taskDescriptor.getRunContext());
jobDataMap.put("taskDescriptor", taskDescriptor);
jobDataMap.put("taskService", taskService);
JobDetail jobDetail = JobBuilder.newJob(TriggerTaskJob.class).withIdentity(jobKey).build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(taskDescriptor.getId())
.withSchedule(cronSchedule).usingJobData(jobDataMap).build();
try {
sched.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void testAbilityToFireImmediatelyWhenStartedAfter() throws Exception {
List<Long> jobExecTimestamps = Collections.synchronizedList(new ArrayList<Long>());
CyclicBarrier barrier = new CyclicBarrier(2);
Scheduler sched = createScheduler("testAbilityToFireImmediatelyWhenStartedAfter", 5);
sched.getContext().put(BARRIER, barrier);
sched.getContext().put(DATE_STAMPS, jobExecTimestamps);
JobDetail job1 = JobBuilder.newJob(TestJobWithSync.class).withIdentity("job1").build();
Trigger trigger1 = TriggerBuilder.newTrigger().forJob(job1).build();
long sTime = System.currentTimeMillis();
sched.scheduleJob(job1, trigger1);
sched.start();
barrier.await(TEST_TIMEOUT_SECONDS, TimeUnit.SECONDS);
sched.shutdown(true);
long fTime = jobExecTimestamps.get(0);
assertTrue("Immediate trigger did not fire within a reasonable amount of time.",
(fTime - sTime < 7000L)); // This is dangerously subjective! but what else to do?
}
@Test
public void monthly2() {
Monthly monthly = scheduleFactory.monthly(new Date(), CalendarDay.days(1, 2, 3, 10, 11, 12));
TriggerBuilder triggerBuilder = underTest.convert(monthly);
Trigger trigger = triggerBuilder.build();
assertThat(trigger, instanceOf(CronTrigger.class));
String cronExpression = ((CronTrigger) trigger).getCronExpression();
assertThat(cronExpression, equalTo(
cronTimeParts(monthly.getStartAt()) + " 1,2,3,10,11,12 * ?"));
}
/**
* 创建定时任务
*/
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));
}
}
@Test
public void shouldRunJobWithNewGeneratedInvocationId() throws SchedulerException {
final JobDetail jobDetail = JobBuilder.newJob(TestJob.class).build();
final Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail).startNow().build();
scheduler.scheduleJob(jobDetail, trigger);
verify(jobBackend, timeout(10000)).put(eq(TraceeConstants.INVOCATION_ID_KEY), any(String.class));
}
@Test
public void monthly3() {
Monthly monthly = scheduleFactory.monthly(new Date(), Sets.newSet(CalendarDay.lastDay()));
TriggerBuilder triggerBuilder = underTest.convert(monthly);
Trigger trigger = triggerBuilder.build();
assertThat(trigger, instanceOf(CronTrigger.class));
String cronExpression = ((CronTrigger) trigger).getCronExpression();
assertThat(cronExpression, equalTo(cronTimeParts(monthly.getStartAt()) + " L * ?"));
}
@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");
}
@Test
public void shouldResetBackendOnError() throws SchedulerException {
final JobDetail jobDetail = JobBuilder.newJob(TestJob.class).build();
final Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail).startNow().build();
trigger.getJobDataMap().put("throwException", true);
scheduler.scheduleJob(jobDetail, trigger);
verify(jobBackend, timeout(10000)).put(eq(TraceeConstants.INVOCATION_ID_KEY), anyString());
verify(jobBackend, timeout(10000)).clear();
}
private boolean fireCronTrigger(TriggerKey triggerKey, JobDetail jobDetail, String cron, boolean replace, Map<String, Object> dataMap) {
try {
boolean isExists = scheduler.checkExists(triggerKey);
if (isExists) {
if (replace) {
LOGGER.warn("Fire corn trigger: replace trigger={}:{}.", triggerKey.getGroup(), triggerKey.getName());
scheduler.unscheduleJob(triggerKey);
} else {
LOGGER.info("Fire corn trigger: exist trigger={}:{}.", triggerKey.getGroup(), triggerKey.getName());
return false;
}
}
// 创建触发器，一分钟后开始执行
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey)
.forJob(jobDetail)
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.startAt(new Date(System.currentTimeMillis() + 60000))
.build();
if (dataMap != null && dataMap.size() > 0) {
trigger.getJobDataMap().putAll(dataMap);
}
scheduler.scheduleJob(trigger);
} catch (SchedulerException e) {
LOGGER.error("Fire corn trigger failed.", e);
return false;
}
return true;
}
@Override
public synchronized String schedule(SchedulableTask task) {
Subject subject = SecurityUtils.getSubject();
SchedulableTask subjectAwareTask = new SchedulableTask() {
@Override
public ScheduleBuilder<?> getScheduleBuilder() {
return task.getScheduleBuilder();
}
@Override
public void execute() {
ThreadContext.bind(subject);
task.execute();
}
};
try {
JobDetail job = JobBuilder.newJob(HelperTask.class)
.withIdentity(UUID.randomUUID().toString())
.build();
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(UUID.randomUUID().toString())
.withSchedule(subjectAwareTask.getScheduleBuilder())
.forJob(job)
.build();
trigger.getJobDataMap().put("task", subjectAwareTask);
quartz.scheduleJob(job, trigger);
return job.getKey().getName();
} catch (SchedulerException e) {
throw new RuntimeException(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);
}