下面列出了怎么用org.quartz.CronTrigger的API类实例代码及写法，或者点击链接到github查看源代码。
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 void initMsgPushJob(){
JobEntity job = new JobEntity(MsgLocalPushTask.class.getSimpleName(), "SYSTEM");
job.setDescription("消息推送服务 (实时推送)");
job.setInvokeTarget("msgLocalPushTask.execute()");
job.setCronExpression("0/3 * * * * ?");
job.setConcurrent(Global.NO);
job.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
job.setStatus(JobEntity.STATUS_PAUSED);
jobService.insert(job);
job = new JobEntity(MsgLocalMergePushTask.class.getSimpleName(), "SYSTEM");
job.setDescription("消息推送服务 (延迟推送)");
job.setInvokeTarget("msgLocalMergePushTask.execute()");
job.setCronExpression("0 0/30 * * * ?");
job.setConcurrent(Global.NO);
job.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
job.setStatus(JobEntity.STATUS_PAUSED);
jobService.insert(job);
}
/**
* 项目启动时，初始化定时器
*/
@PostConstruct
public void init()
{
List<SysJob> jobList = jobMapper.selectJobAll();
for (SysJob job : jobList)
{
CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, job.getJobId());
// 如果不存在，则创建
if (cronTrigger == null)
{
ScheduleUtils.createScheduleJob(scheduler, job);
}
else
{
ScheduleUtils.updateScheduleJob(scheduler, job);
}
}
}
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());
}
/**
* Schedule a job according cron information
*
* @param job
* The Job to schedule
* @param trigger
* The Cron trigger
* @return Date
*/
public Date scheduleJob( JobDetail job, CronTrigger trigger )
{
Date date = null;
if ( _scheduler != null )
{
try
{
date = _scheduler.scheduleJob( job, trigger );
AppLogService.info( "New job scheduled : " + job.getKey( ).getName( ) );
}
catch( SchedulerException e )
{
AppLogService.error( "Error scheduling job " + job.getKey( ).getName( ), e );
}
}
return date;
}
/**
* @see org.kuali.kfs.sys.batch.TriggerDescriptor#completeTriggerDescription(org.quartz.Trigger)
*/
protected void completeTriggerDescription(Trigger trigger) {
// prevent setting of the trigger information in test mode
try {
((CronTrigger) trigger).setTimeZone(getDateTimeService().getCurrentCalendar().getTimeZone());
if (!isTestMode()) {
((CronTrigger) trigger).setCronExpression(cronExpression);
}
else {
((CronTrigger) trigger).setCronExpression("0 59 23 31 12 ? 2099");
}
}
catch (ParseException e) {
throw new RuntimeException("Caught exception while trying to set the cronExpression attribute of a CronTrigger: " + getJobName(), e);
}
}
/**
* 项目启动时，初始化定时器
*/
@PostConstruct
public void init() {
try {
List<ScheduleJob> scheduleJobList = this.selectList(null);
for (ScheduleJob scheduleJob : scheduleJobList) {
CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, scheduleJob.getId());
//如果不存在，则创建
if (cronTrigger == null) {
ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
} else {
ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 开始任务调度
* @param task 任务
* @param taskCode 任务名称
* @throws ParseException
* @throws SchedulerException
* @throws ClassNotFoundException
*/
private void startTask(CmsTask task,String taskCode) throws ParseException, SchedulerException, ClassNotFoundException{
String cronExpress=manager.getCronExpressionFromDB(task.getId());
System.out.println(cronExpress);
if(cronExpress.indexOf("null")==-1){
JobDetail jobDetail = new JobDetail();
jobDetail.setName(taskCode);
jobDetail.setGroup(Scheduler.DEFAULT_GROUP);
jobDetail.setJobClass(getClassByTask(task.getJobClass()));
//任务需要参数attr属性
jobDetail.setJobDataMap(getJobDataMap(task.getAttr()));
CronTrigger cronTrigger = new CronTrigger("cron_" + taskCode,Scheduler.DEFAULT_GROUP, jobDetail.getName(),Scheduler.DEFAULT_GROUP);
cronTrigger.setCronExpression(cronExpress);
scheduler.scheduleJob(jobDetail, cronTrigger);
}
}
/**
* 启动定时任务，同步数据库的数据
*/
public void start() {
for (int index = 0; index < jobList.size(); index++) {
JobInfo jobInfo = jobList.get(index);
String logTitle = "[" + code + "]" + jobInfo.getName() + " ";
try {
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
JobDetail job = newJob(JobTask.class).withIdentity(MykitDbSyncConstants.JOB_PREFIX.concat(jobInfo.getName()), code).build();
job.getJobDataMap().put(MykitDbSyncConstants.SRC_DB, srcDb);
job.getJobDataMap().put(MykitDbSyncConstants.DEST_DB, destDb);
job.getJobDataMap().put(MykitDbSyncConstants.JOB_INFO, jobInfo);
job.getJobDataMap().put(MykitDbSyncConstants.LOG_TITLE, logTitle);
logger.info(jobInfo.getCron());
CronTrigger trigger = newTrigger().withIdentity(MykitDbSyncConstants.TRIGGER_PREFIX.concat(jobInfo.getName()), code).withSchedule(cronSchedule(jobInfo.getCron())).build();
sched.scheduleJob(job, trigger);
sched.start();
} catch (Exception e) {
e.printStackTrace();
logger.error(logTitle + e.getMessage());
logger.error(logTitle + " run failed");
continue;
}
}
}
private void wrapScheduleJob(ScheduleJob scheduleJob,Scheduler scheduler,JobKey jobKey,Trigger trigger){
try {
scheduleJob.setJobName(jobKey.getName());
scheduleJob.setJobGroup(jobKey.getGroup());
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
ScheduleJob job = (ScheduleJob)jobDetail.getJobDataMap().get("scheduleJob");
scheduleJob.setDesc(job.getDesc());
scheduleJob.setJobId(job.getJobId());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
scheduleJob.setJobStatus(triggerState.name());
if(trigger instanceof CronTrigger){
CronTrigger cronTrigger = (CronTrigger)trigger;
String cronExpression = cronTrigger.getCronExpression();
scheduleJob.setCronExpression(cronExpression);
}
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 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 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);
}
}
/**
* 获取正在运行的job任务
*
* @param scheduler scheduler
*/
public static List<JobInfo> getRunningJobs(Scheduler scheduler) throws SchedulerException {
return Optional.ofNullable(scheduler.getCurrentlyExecutingJobs()).orElse(Collections.emptyList()).stream().map(context -> {
JobDetail jobDetail = context.getJobDetail();
Trigger trigger = context.getTrigger();
JobKey jobKey = jobDetail.getKey();
JobInfo job = new JobInfo();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setDescription(String.format("触发器 ======== %s", trigger.getKey()));
try {
Trigger.TriggerState state = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(EnumUtils.getEnum(JobStatusEnums.class, state.name()).getCode());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
job.setCron(cronTrigger.getCronExpression());
return job;
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return null;
}).filter(Objects::nonNull).collect(Collectors.toList());
}
/**
* 项目启动时，初始化定时器
*/
@PostConstruct
public void init()
{
List<Job> jobList = jobMapper.selectJobAll();
for (Job job : jobList)
{
CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, job.getJobId());
// 如果不存在，则创建
if (cronTrigger == null)
{
ScheduleUtils.createScheduleJob(scheduler, job);
}
else
{
ScheduleUtils.updateScheduleJob(scheduler, job, cronTrigger);
}
}
}
/**
* 更新任务的时间表达式
*
* @param job 调度信息
*/
@Override
public int updateJob(Job job)
{
if(StrUtil.isNotEmpty(job.getUpdateBy())){
job.setUpdateBy(job.getUpdateBy());
}else{
job.setUpdateBy(ShiroUtils.getLoginName());
}
job.setUpdateTime(new Date());
int rows = jobMapper.updateJob(job);
if (rows > 0)
{
CronTrigger trigger = ScheduleUtils.getCronTrigger(scheduler, job.getJobId());
ScheduleUtils.updateScheduleJob(scheduler, job, trigger);
}
return rows;
}
/**
* 创建复杂触发器
* @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;
}
/**
* 项目启动时，初始化定时器
*/
@PostConstruct
public void init(){
EntityWrapper<QuartzTask> wrapper = new EntityWrapper<>();
wrapper.eq("del_flag",false);
List<QuartzTask> scheduleJobList = selectList(wrapper);
for(QuartzTask scheduleJob : scheduleJobList){
CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, scheduleJob.getId());
//如果不存在，则创建
if(cronTrigger == null) {
ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
}else {
ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
}
}
}
/**
* 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());
}
}
public void start() {
try {
SchedulerFactory sf = new StdSchedulerFactory();
scheduler = sf.getScheduler();
scheduler.start();
for (Map.Entry<String, Task> entry : tasks.entrySet()) {
Task task = entry.getValue();
JobDetail job = newJob(SchedulerJob.class)
.withIdentity(task.id)
.build();
CronTrigger trigger = newTrigger()
.withIdentity(task.id)
.withSchedule(cronSchedule(task.cron))
.build();
scheduler.scheduleJob(job, trigger);
}
} catch (SchedulerException e) {
throw new ApplicationException(e);
}
}
@Test
public void testDisallowConcurrent() throws Exception {
JobDetail job1 = createJob(SingletonSleepJob.class, "job1", "group1");
CronTrigger trigger1 = createCronTrigger("trigger1", "group1", "* * * * * ?");
CronTrigger trigger2 = createCronTrigger("trigger2", "group2", "* * * * * ?")
.getTriggerBuilder()
.forJob(job1)
.build();
Waiter waiter = new Waiter();
scheduler.getListenerManager().addTriggerListener(new CompleteListener(waiter), NameMatcher.triggerNameEquals(trigger1.getKey().getName()));
scheduler.scheduleJob(job1, trigger1);
//scheduler.scheduleJob(trigger2);
waiter.await(6000, 2);
assertThat(SingletonSleepJob.concurrentExecutions.get(), equalTo(0));
}
private ScheduleTask convertToScheduleTask(JobKey jobKey, Trigger trigger) throws SchedulerException {
ScheduleTask task = new ScheduleTask();
String[] jobname = jobKey.getName().split(":");
task.setId(Long.parseLong(jobname[0]));
task.setAppname(jobname[1]);
task.setName(jobname[2]);
//task.setGroup(jobKey.getGroup());
//task.setDesc("触发器[" + trigger.getKey() + "]");
//task.setStartTime(trigger.getStartTime()); //开始时间
//task.setEndTime(trigger.getEndTime()); //结束时间
task.setNextFireTime(trigger.getNextFireTime()); //下次触发时间
task.setPreviousFireTime(trigger.getPreviousFireTime()); //上次触发时间
if(trigger instanceof CronTrigger){
task.setCron(((CronTrigger)trigger).getCronExpression());
}
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
task.setStatus("N".equals(triggerState.name()) ? SeedConstants.QSS_STATUS_STOP : SeedConstants.QSS_STATUS_RUNNING);
return task;
}
/** 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);
}
}
public void start(){
for(int index = 0; index < jobList.size(); index++){
JobInfo jobInfo = jobList.get(index);
String logTitle = "[" + code + "]" + jobInfo.getName() + " ";
try{
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
JobDetail job = newJob(DataTask.class).withIdentity("job-" + jobInfo.getName(), code).build();
job.getJobDataMap().put("srcDb", srcDb);
job.getJobDataMap().put("destDb", destDb);
job.getJobDataMap().put("jobInfo", jobInfo);
job.getJobDataMap().put("logTitle", logTitle);
logger.info(jobInfo.getCron());
CronTrigger trigger = newTrigger()
.withIdentity("trigger-" + jobInfo.getName(), code)
.withSchedule(cronSchedule(jobInfo.getCron())).build();
sched.scheduleJob(job, trigger);
sched.start();
}catch(Exception e){
logger.info(logTitle + e.getMessage());
logger.info(logTitle + " run failed");
continue;
}
}
}
@Override
public Optional<CrontabEntry> getSchedule(IJobKey jobKey) throws IllegalStateException {
requireNonNull(jobKey);
try {
return Optional.of(Iterables.getOnlyElement(
FluentIterable.from(scheduler.getTriggersOfJob(jobKey(jobKey)))
.filter(CronTrigger.class)
.transform(Quartz::crontabEntry)));
} catch (SchedulerException e) {
LOG.error(
"Error reading job " + JobKeys.canonicalString(jobKey) + " cronExpression Quartz: " + e,
e);
return Optional.empty();
}
}
public int updateExtendedTriggerProperties(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
CronTrigger cronTrigger = (CronTrigger)trigger;
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(Util.rtp(UPDATE_CRON_TRIGGER, tablePrefix, schedNameLiteral));
ps.setString(1, cronTrigger.getCronExpression());
ps.setString(2, cronTrigger.getTimeZone().getID());
ps.setString(3, trigger.getKey().getName());
ps.setString(4, trigger.getKey().getGroup());
return ps.executeUpdate();
} finally {
Util.closeStatement(ps);
}
}
/**
* 스케줄러 Job등록
* @throws Exception
* @return void
*/
public void JobRegist() throws Exception {
Class<?> c = null;
// 등록할 스케줄 정보 설정
setSchList();
for (int j = 0; j < schDTO.length; j++) {
try {
c = Class.forName(schDTO[j].getTask_class());
jobDetail = new JobDetail(schDTO[j].getTask_id(), schDTO[j].getTask_group_id(), c);
trigger = new CronTrigger(schDTO[j].getTask_id(), schDTO[j].getTask_group_id());
trigger.setCronExpression(schDTO[j].getTask_expression());
scheduler.scheduleJob(jobDetail, trigger);
} catch (Exception e) {
throw e;
}
}
}
public static CompositeData toCompositeData(CronTrigger trigger) {
try {
return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES,
new Object[] {
trigger.getCronExpression(),
trigger.getTimeZone(),
trigger.getKey().getName(),
trigger.getKey().getGroup(),
trigger.getJobKey().getName(),
trigger.getJobKey().getGroup(),
trigger.getDescription(),
JobDataMapSupport.toTabularData(trigger
.getJobDataMap()),
trigger.getCalendarName(),
((OperableTrigger)trigger).getFireInstanceId(),
trigger.getMisfireInstruction(),
trigger.getPriority(), trigger.getStartTime(),
trigger.getEndTime(), trigger.getNextFireTime(),
trigger.getPreviousFireTime(),
trigger.getFinalFireTime() });
} catch (OpenDataException e) {
throw new RuntimeException(e);
}
}
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 testMisfireListener() throws Exception {
final String jobName = "oneJob";
JobDetail jobDetail = createJob(TestJob.class, jobName, "oneGroup");
final String triggerName = "trigger1";
final String everySecond = "* * * * * ?";
CronTrigger trigger = createCronTrigger(triggerName, "oneGroup", everySecond);
JobDetail sleepJob = createJob(SleepJob.class, "sleepJob", "twoGroup");
CronTrigger sleepTrigger = createCronTrigger("sleepTrigger", "twoGroup", everySecond);
Waiter waiter = new Waiter();
scheduler.scheduleJob(sleepJob, sleepTrigger);
scheduler.scheduleJob(jobDetail, trigger);
scheduler.getListenerManager().addTriggerListener(new MisfireListener(waiter), NameMatcher.triggerNameEquals(triggerName));
// wait for MisfireListener.triggerMisfired() to be called
waiter.await(2500);
}
/**
* <p>
* Insert the cron trigger data.
* </p>
*
* @param conn
* the DB Connection
* @param trigger
* the trigger to insert
* @return the number of rows inserted
*/
public int insertCronTrigger(Connection conn, CronTrigger trigger)
throws SQLException {
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(rtp(INSERT_CRON_TRIGGER));
ps.setString(1, trigger.getName());
ps.setString(2, trigger.getGroup());
ps.setString(3, trigger.getCronExpression());
ps.setString(4, trigger.getTimeZone().getID());
return ps.executeUpdate();
} finally {
closeStatement(ps);
}
}