下面列出了怎么用org.quartz.CronScheduleBuilder的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* 设置定时任务策略
*/
public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
throws TaskException
{
switch (job.getMisfirePolicy())
{
case ScheduleConstants.MISFIRE_DEFAULT:
return cb;
case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case ScheduleConstants.MISFIRE_DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + job.getMisfirePolicy()
+ "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
}
}
private CronScheduleBuilder handleCronScheduleMisfirePolicy(TaskInfo.TriggerInfo triggerInfo,
CronScheduleBuilder cb) throws TaskException {
switch (triggerInfo.getMisfirePolicy()) {
case DEFAULT:
return cb;
case IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + triggerInfo.getMisfirePolicy()
+ "' cannot be used in cron schedule tasks",
TaskException.Code.CONFIG_ERROR);
}
}
public List<String> getRecentTriggerTime(String cron) {
List<String> list = new ArrayList<String>();
if (!CronExpression.isValidExpression(cron)) {
return list;
}
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("date")
.withSchedule(CronScheduleBuilder.cronSchedule(cron)).build();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date startTime = cronTrigger.getStartTime();
for (int i = 0; i < 5; i++) {
Date time = cronTrigger.getFireTimeAfter(startTime);
list.add(sdf.format(time));
startTime = time;
}
return list;
}
/**
* 设置定时任务策略
*/
public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
throws TaskException
{
switch (job.getMisfirePolicy())
{
case ScheduleConstants.MISFIRE_DEFAULT:
return cb;
case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case ScheduleConstants.MISFIRE_DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + job.getMisfirePolicy()
+ "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
}
}
public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
throws TaskException
{
switch (job.getMisfirePolicy())
{
case ScheduleConstants.MISFIRE_DEFAULT:
return cb;
case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case ScheduleConstants.MISFIRE_DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + job.getMisfirePolicy() + "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
}
}
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);
}
}
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;
}
public static CronScheduleBuilder handleCronScheduleMisfirePolicy(Job job, CronScheduleBuilder cb)
throws TaskException
{
switch (job.getMisfirePolicy())
{
case ScheduleConstants.MISFIRE_DEFAULT:
return cb;
case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
return cb.withMisfireHandlingInstructionIgnoreMisfires();
case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
return cb.withMisfireHandlingInstructionFireAndProceed();
case ScheduleConstants.MISFIRE_DO_NOTHING:
return cb.withMisfireHandlingInstructionDoNothing();
default:
throw new TaskException("The task misfire policy '" + job.getMisfirePolicy() + "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
}
}
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();
}
}
/** Add new job. */
public static void addJob(BaseJobContext jobContext, String jobName, Class<? extends Job> jobClass, String cron) {
try {
Scheduler sched = schedulerFactory.getScheduler();
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, KE_JOB_GROUP_NAME).build();
jobDetail.getJobDataMap().put(AlarmQueue.JOB_PARAMS, jobContext);
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
triggerBuilder.withIdentity("ke_trigger_name_" + new Date().getTime(), "ke_trigger_group_" + new Date().getTime());
triggerBuilder.startNow();
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
CronTrigger trigger = (CronTrigger) triggerBuilder.build();
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@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());
}
}
/**
* Get a {@link ScheduleBuilder} that is configured to produce a
* schedule identical to this trigger's schedule.
*
* @see #getTriggerBuilder()
*/
@Override
public ScheduleBuilder<CronTrigger> getScheduleBuilder() {
CronScheduleBuilder cb = CronScheduleBuilder.cronSchedule(getCronExpression())
.inTimeZone(getTimeZone());
switch(getMisfireInstruction()) {
case MISFIRE_INSTRUCTION_DO_NOTHING : cb.withMisfireHandlingInstructionDoNothing();
break;
case MISFIRE_INSTRUCTION_FIRE_ONCE_NOW : cb.withMisfireHandlingInstructionFireAndProceed();
break;
}
return cb;
}
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());
}
}
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);
}
/**
* 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());
}
}
@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);
}
}
/**
* 注册 定时任务
* @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);
}
/**
* 创建定时任务
*/
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));
}
}
private static ScheduleBuilder<? extends Trigger> parseAtExpr(String atExpr) {
Matcher matcher = atExprPattern.matcher(atExpr);
if (!matcher.matches()) throw new RuntimeException(atExpr + " is not valid");
if (matcher.group(1).equals("??")) {
return CronScheduleBuilder.cronSchedule("0 " + matcher.group(2) + " * * * ?");
}
DateTimeFormatter formatter = DateTimeFormat.forPattern("HH:mm");
DateTime dateTime = formatter.parseDateTime(matcher.group().trim());
return CronScheduleBuilder.dailyAtHourAndMinute(dateTime.getHourOfDay(),
dateTime.getMinuteOfHour());
}
/**
* 创建定时任务
*/
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 Trigger getTrigger() throws ParseException {
fixParameters();
return TriggerBuilder.newTrigger()
.forJob(name.trim(), group.trim())
.withIdentity(triggerName.trim(), triggerGroup.trim())
.withSchedule(CronScheduleBuilder
.cronSchedule(cronExpression)
.withMisfireHandlingInstructionIgnoreMisfires())
.startAt(startTime).endAt(endTime)
.usingJobData(JobDataMapUtils.fromDataMapStr(dataMap))
.build();
}
@Bean
public Trigger sampleJobTrigger() {
// 每天凌晨2点开始生成每日账单
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0 2 * * ?");
return TriggerBuilder.newTrigger().forJob(sampleJobDetail()).withIdentity("orderTrigger")
.withSchedule(scheduleBuilder).build();
}
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 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 void scheduleBackup(BackupSetting backupSetting) {
if (backupTaskId != null)
taskScheduler.unschedule(backupTaskId);
if (backupSetting != null) {
backupTaskId = taskScheduler.schedule(new SchedulableTask() {
@Override
public void execute() {
File tempDir = FileUtils.createTempDir("backup");
try {
File backupDir = new File(Bootstrap.getSiteDir(), Upgrade.DB_BACKUP_DIR);
FileUtils.createDir(backupDir);
persistManager.exportData(tempDir);
File backupFile = new File(backupDir,
DateTimeFormat.forPattern(Upgrade.BACKUP_DATETIME_FORMAT).print(new DateTime()) + ".zip");
ZipUtils.zip(tempDir, backupFile);
} catch (Exception e) {
notifyBackupError(e);
throw ExceptionUtils.unchecked(e);
} finally {
FileUtils.deleteDir(tempDir);
}
}
@Override
public ScheduleBuilder<?> getScheduleBuilder() {
return CronScheduleBuilder.cronSchedule(backupSetting.getSchedule());
}
});
}
}
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, String taskName, TaskJob taskJob) {
JobDetail job = JobBuilder.newJob(TaskObjJob.class).withIdentity(taskName).build();
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(taskName)
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.startNow().build();
TaskObjJob.bindTriggerWithObj(trigger, taskJob);
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 the scheduler
* @param jobName the job name
* @param jobGroup the job group
* @param cronExpression the cron expression
* @param param the param
*/
private static void updateJob(Scheduler scheduler, String jobName, String jobGroup, String cronExpression, Object param) throws SchedulerException {
// 同步或异步
Class<? extends Job> jobClass = JobQuartzJobBean.class;
JobDetail jobDetail = scheduler.getJobDetail(getJobKey(jobName, jobGroup));
jobDetail = jobDetail.getJobBuilder().ofType(jobClass).build();
// 更新参数 实际测试中发现无法更新
JobDataMap jobDataMap = jobDetail.getJobDataMap();
jobDataMap.put("JobAdapter", param);
jobDetail.getJobBuilder().usingJobData(jobDataMap);
TriggerKey triggerKey = getTriggerKey(jobName, jobGroup);
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
// 忽略状态为PAUSED的任务,解决集群环境中在其他机器设置定时任务为PAUSED状态后,集群环境启动另一台主机时定时任务全被唤醒的bug
if (!JobEnums.PAUSE.name().equalsIgnoreCase(triggerState.name())) {
// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
}
}
private void scheduleJob(Scheduler scheduler) throws SchedulerException{
JobDetail jobDetail = JobBuilder.newJob(CronJob.class) .withIdentity("job1", "group1")
.usingJobData("serviceCode","Live lesson reminder1").build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1") .withSchedule(scheduleBuilder).build();
scheduler.scheduleJob(jobDetail,cronTrigger);
}