private void scheduleCronJob(String cronString, String elementId) {
try {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
scheduler = schedulerFactory.getScheduler();
scheduler.start();
JobDataMap dataMap = new JobDataMap();
dataMap.put("trigger", this);
jobName = "TriggerJob_" + elementId;
JobDetail job =
org.quartz.JobBuilder.newJob(CronEventTrigger.class)
.withIdentity(jobName, jobGroup)
.usingJobData(dataMap)
.build();
Trigger trigger =
org.quartz.TriggerBuilder.newTrigger()
.withIdentity("TriggerJob_" + elementId, jobGroup)
.withSchedule(CronScheduleBuilder.cronSchedule(cronString))
.build();
scheduler.scheduleJob(job, trigger);
} catch (SchedulerException e) {
log.error(
"Error while instantiating quartz scheduler for trigger '"
+ triggerDefinition.getId()
+ "',"
+ e.getMessage(),
e);
}
}
private void startScheduler() {
SchedulerFactory sf = new StdSchedulerFactory();
try {
sched = sf.getScheduler();
JobDetail notificationCleanupJob =
newJob(NotificationCleanupJob.class)
.withIdentity("notificationCleanupJob", "chatServer")
.build();
CronTrigger notificationTrigger =
newTrigger()
.withIdentity("notificationTrigger", "chatServer")
.withSchedule(
cronSchedule(
PropertyManager.getProperty(PropertyManager.PROPERTY_CRON_NOTIF_CLEANUP)))
.build();
sched.scheduleJob(notificationCleanupJob, notificationTrigger);
sched.start();
log.info("Scheduler Started");
} catch (SchedulerException e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
}
public void quartzTest() throws Exception {
JobDetail jobDetail =
JobBuilder.newJob(QuartsDemo.class).withIdentity("testJob_1", "group_1").build();
Trigger trigger =
TriggerBuilder.newTrigger()
.withIdentity("trigger_1", "group_1")
.startNow()
.withSchedule(
SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(1) // 时间间隔
.withRepeatCount(10) // 重复次数(将执行 10 次/ or //调用10次)
)
.build();
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
sched.scheduleJob(jobDetail, trigger);
sched.start();
Thread.currentThread().sleep(20000);
System.err.println("关闭 ");
sched.shutdown();
}
JobScheduler() throws JobSchedulerException {
org.quartz.spi.JobFactory jobFactory = new JobFactory();
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
try {
scheduler = schedulerFactory.getScheduler();
scheduler.setJobFactory(jobFactory);
} catch (SchedulerException e) {
throw new JobSchedulerException("An exception occurred during scheduler setup", e);
}
}
public void start(BootstrapContext ctx) throws ResourceAdapterInternalException {
log.debug("start quartz!!!");
// First we must get a reference to a scheduler
SchedulerFactory sf = new StdSchedulerFactory();
try {
holder.set(ctx.getWorkManager());
sched = sf.getScheduler();
SecurityActions.startScheduler(sched);
} catch (SchedulerException e) {
throw new ResourceAdapterInternalException(e);
} finally {
holder.set(null);
}
}
protected void stopScheduler() {
try {
SchedulerFactory f = DefaultSchedulerFactory.getInstance();
Scheduler s = f.getScheduler();
s.stop(null, null);
} catch (IOException ex) {
// Log info:
{
String message = "Failure to stop scheduler!";
log.log(Level.SEVERE, message, ex);
}
throw new RuntimeException(ex);
} catch (Throwable ex) {
// Log info:
{
String message = "Failure to stop scheduler!";
log.log(Level.SEVERE, message, ex);
}
throw new RuntimeException(ex);
}
}
public static void main(String[] args) {
// Configure Job
JobDetail jobDetail =
JobBuilder.newJob(HelloWorldJob.class).withIdentity("HelloWorldJob").build();
// Configure Trigger
Trigger trigger =
TriggerBuilder.newTrigger()
.withSchedule(
SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
.build();
// Start Scheduler
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
try {
Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.start();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 从Scheduler 移除当前的Job,修改Trigger
*
* @param jobDetail
* @param time
* @throws SchedulerException
* @throws ParseException
*/
public static void modifyJobTime(JobDetail jobDetail, String time)
throws SchedulerException, ParseException {
Scheduler sched = sf.getScheduler();
Trigger trigger = sched.getTrigger(jobDetail.getName(), TRIGGER_GROUP_NAME);
if (trigger != null) {
CronTrigger ct = (CronTrigger) trigger;
// 移除当前进程的Job
sched.deleteJob(jobDetail.getName(), jobDetail.getGroup());
// 修改Trigger
ct.setCronExpression(time);
System.out.println("CronTrigger getName " + ct.getJobName());
// 重新调度jobDetail
sched.scheduleJob(jobDetail, ct);
}
}
public static void startJob(String jobName, Job job, String time)
throws SchedulerException, ParseException {
Scheduler sched = sf.getScheduler();
JobDetail jobDetail = new JobDetail();
jobDetail.setName(jobName);
jobDetail.setGroup(JOB_GROUP_NAME);
jobDetail.setJobClass(job.getClass());
CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
trigger.setCronExpression(time);
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start();
}
}
public void run() throws Exception {
Logger log = LoggerFactory.getLogger(JobStateExample.class);
log.info("------- Initializing -------------------");
// First we must get a reference to a scheduler
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
log.info("------- Initialization Complete --------");
log.info("------- Scheduling Jobs ----------------");
// get a "nice round" time a few seconds in the future....
Date startTime = nextGivenSecondDate(null, 10);
// job1 will only run 5 times (at start time, plus 4 repeats), every 10 seconds
JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1").build();
SimpleTrigger trigger1 =
newTrigger()
.withIdentity("trigger1", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4))
.build();
// pass initialization parameters into the job
job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Green");
job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);
// schedule the job to run
Date scheduleTime1 = sched.scheduleJob(job1, trigger1);
log.info(
job1.getKey()
+ " will run at: "
+ scheduleTime1
+ " and repeat: "
+ trigger1.getRepeatCount()
+ " times, every "
+ trigger1.getRepeatInterval() / 1000
+ " seconds");
// job2 will also run 5 times, every 10 seconds
JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1").build();
SimpleTrigger trigger2 =
newTrigger()
.withIdentity("trigger2", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4))
.build();
// pass initialization parameters into the job
// this job has a different favorite color!
job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Red");
job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);
// schedule the job to run
Date scheduleTime2 = sched.scheduleJob(job2, trigger2);
log.info(
job2.getKey().toString()
+ " will run at: "
+ scheduleTime2
+ " and repeat: "
+ trigger2.getRepeatCount()
+ " times, every "
+ trigger2.getRepeatInterval() / 1000
+ " seconds");
log.info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
sched.start();
log.info("------- Started Scheduler -----------------");
log.info("------- Waiting 60 seconds... -------------");
try {
// wait five minutes to show jobs
Thread.sleep(60L * 1000L);
// executing...
} catch (Exception e) {
//
}
log.info("------- Shutting Down ---------------------");
sched.shutdown(true);
log.info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.getMetaData();
log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
}
/**
* Refreshes the job schedule with the current list of enabled jobs of the type to be scheduled.
*
* @param scheduler The scheduler to update.
* @return The updated scheduler.
*/
protected Scheduler _refreshJobSchedule(Scheduler scheduler) {
_disposeScheduler(scheduler);
String schedulerName = null;
Properties props = new Properties();
// Set quartz worker thread properties
props.put(
QUARTZ_THREADPOOL_COUNT,
_configuration.getValue(
Property.QUARTZ_THREADPOOL_COUNT.getName(),
Property.QUARTZ_THREADPOOL_COUNT.getDefaultValue()));
props.put(QUARTZ_THREAD_PRIORITY, QUARTZ_THREAD_PRIORITY_VALUE);
props.put(
StdSchedulerFactory
.PROP_SCHED_SCHEDULER_THREADS_INHERIT_CONTEXT_CLASS_LOADER_OF_INITIALIZING_THREAD,
true);
/* Have multiple scheduler instances for different job types, so that when
* we stop the previous instance of a scheduler during the refresh cycle it does not affect another scheduler.
*/
switch (Thread.currentThread().getName()) {
case "schedule-alerts":
default:
schedulerName = "AlertScheduler";
}
props.put(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, schedulerName);
SchedulerFactory schedulerFactory;
Scheduler result = null;
try {
schedulerFactory = new StdSchedulerFactory(props);
result = schedulerFactory.getScheduler();
} catch (Exception e) {
_logger.error("Exception in setting up scheduler: {}", e);
return result;
}
for (CronJob job : getEnabledJobs()) {
_logger.debug("Adding job to scheduler: {}", job);
try {
// Convert from linux cron to quartz cron expression
String quartzCronEntry =
"0 " + job.getCronEntry().substring(0, job.getCronEntry().length() - 1) + "?";
JobDetail jobDetail = JobBuilder.newJob(RunnableJob.class).build();
CronTrigger cronTrigger =
TriggerBuilder.newTrigger()
.withSchedule(CronScheduleBuilder.cronSchedule(quartzCronEntry))
.build();
// Pass parameter to quartz worker threads
jobDetail.getJobDataMap().put(RunnableJob.CRON_JOB, job);
jobDetail.getJobDataMap().put(RunnableJob.LOCK_TYPE, lockType);
jobDetail.getJobDataMap().put("AlertService", _alertService);
jobDetail.getJobDataMap().put("AuditService", _auditService);
result.scheduleJob(jobDetail, cronTrigger);
} catch (Exception ex) {
String msg = "Failed to schedule job {0} : {1}";
JPAEntity entity = JPAEntity.class.cast(job);
_auditService.createAudit(msg, entity, entity, ex.getMessage());
_logger.error("Failed to schedule job {} : {}", job, ex.getMessage());
}
}
try {
result.start();
} catch (SchedulerException e) {
_logger.error("Exception in starting scheduler: {}", e);
}
_logger.info("Job schedule refreshed.");
return result;
}
