quartz动态定时任务

Quartz是 OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2SE应用程序结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的java组建或EJBs。目前Quartz的最新版本为Quartz 2.2.1。

其它话就不说了，直接上代码。

1.spring中引入注册bean

<bean id="schedulerFactoryBean"

          class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

    </bean>

2.创建保存计划任务信息的实体类

public class ScheduleJob {
public static final String STATUS_RUNNING = "1";
public static final String STATUS_NOT_RUNNING = "0";
public static final String CONCURRENT_IS = "1";
public static final String CONCURRENT_NOT = "0";
private Integer jobId;

private Date createTime;

private Date updateTime;
/**
* 任务名称
*/
private String jobName;
/**
* 任务分组
*/
private String jobGroup;
/**
* 任务状态 是否启动任务
*/
private String jobStatus;
/**
* cron表达式
*/
private String cronExpression;
/**
* 描述
*/
private String description;
/**
* 任务执行时调用哪个类的方法 包名+类名
*/
private String beanClass;
/**
* 任务是否有状态
*/
private String isConcurrent;
/**
* spring bean
*/
private String springId;
/**
* 任务调用的方法名
*/
private String methodName;

private Integer attemperPro;//执行类型：0:不执行，1：每隔多少分钟执行，2：每隔多少小时执行,3:每天几点执行，4：每星期几执行

private String intervalTime;//执行时间或者间隔时间

public String getMethodName() {
return methodName;
}

public void setMethodName(String methodName) {
this.methodName = methodName;
}

public static String getStatusRunning() {
return STATUS_RUNNING;
}

public static String getStatusNotRunning() {
return STATUS_NOT_RUNNING;
}

public static String getConcurrentIs() {
return CONCURRENT_IS;
}

public static String getConcurrentNot() {
return CONCURRENT_NOT;
}

public Integer getJobId() {
return jobId;
}

public void setJobId(Integer jobId) {
this.jobId = jobId;
}

public Date getCreateTime() {
return createTime;
}

public void setCreateTime(Date createTime) {
this.createTime = createTime;
}

public Date getUpdateTime() {
return updateTime;
}

public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}

public String getJobName() {
return jobName;
}

public void setJobName(String jobName) {
this.jobName = jobName;
}

public String getJobGroup() {
return jobGroup;
}

public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}

public String getJobStatus() {
return jobStatus;
}

public void setJobStatus(String jobStatus) {
this.jobStatus = jobStatus;
}

public String getCronExpression() {
return cronExpression;
}

public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}

public String getBeanClass() {
return beanClass;
}

public void setBeanClass(String beanClass) {
this.beanClass = beanClass;
}

public String getIsConcurrent() {
return isConcurrent;
}

public void setIsConcurrent(String isConcurrent) {
this.isConcurrent = isConcurrent;
}

public String getSpringId() {
return springId;
}

public void setSpringId(String springId) {
this.springId = springId;
}

public Integer getAttemperPro() {
return attemperPro;
}

public void setAttemperPro(Integer attemperPro) {
this.attemperPro = attemperPro;
}

public String getIntervalTime() {
return intervalTime;
}

public void setIntervalTime(String intervalTime) {
this.intervalTime = intervalTime;
}

  该实体类与数据库中的表对应，在数据库中存储多个计划任务。

  注意：jobName 跟 groupName的组合应该是唯一的,beanClass springId至少有一个

3.项目启动时 启动

public class ApplicationContextListener implements ServletContextListener {

private ServletContext context = null;
/**
* Initialize the root web application context.
*
* @param event
*/
@Override
public void contextInitialized(ServletContextEvent event) {

QuartzContext.getInstance().setContext(event.getServletContext());

}
}

public class QuartzContext {
private final static QuartzContext instance = new QuartzContext();
private static ServletContext context;

private QuartzContext() {
}

public static QuartzContext getInstance() {
return instance;
}

public void setContext(ServletContext context) {
this.context = context;
}

public ServletContext getContext() {
return context;
}
}

<listener>
<description>项目启动时启动</description>
<listener-class>cn.com.web.listener.ApplicationContextListener</listener-class>
</listener>

public class JobTaskService {

private  final  static Logger log = Logger.getLogger(JobTaskService.class);

@Autowired
private SchedulerFactoryBean schedulerFactoryBean;

/**
* 从数据库中查询job
*/
public ScheduleJob getTaskById(Integer jobId) {
return mapper.selectByPrimaryKey(jobId);
}

/**
* 更改任务状态
*
* @throws org.quartz.SchedulerException
*/
public void changeStatus(Integer jobId, String cmd) {
try {
ScheduleJob job = getTaskById(jobId);
if (job == null) {
return;
}

if ("stop".equals(cmd)) {

deleteJob(job);

job.setJobStatus(ScheduleJob.STATUS_NOT_RUNNING);
} else if ("start".equals(cmd)) {
job.setJobStatus(ScheduleJob.STATUS_RUNNING);

addJob(job);

}
mapper.updateByPrimaryKeySelective(job);
} catch (SchedulerException e) {
e.printStackTrace();
}
}

/**
* 更改任务 cron表达式
*
* @throws SchedulerException
*/
public void updateCron(Integer jobId, String cron)  {
try{

ScheduleJob job = getTaskById(jobId);
if (job == null) {
return;
}
job.setCronExpression(cron);
if (ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
updateJobCron(job);
}
mapper.updateByPrimaryKeySelective(job);
}catch (SchedulerException e){

}
}

/**
* 添加任务
*
* @param job
* @throws SchedulerException
*/
public void addJob(ScheduleJob job) throws SchedulerException {
if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
return;
}

Scheduler scheduler = schedulerFactoryBean.getScheduler();
log.debug(scheduler + ".......................................................................................add");
TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

// 不存在，创建一个
if (null == trigger) {
//Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;
Class clazz = QuartzJobFactoryDisallowConcurrentExecution.class;
JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();

jobDetail.getJobDataMap().put("scheduleJob", job);

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();

scheduler.scheduleJob(jobDetail, trigger);
} else {
// Trigger已存在，那么更新相应的定时设置
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
}
}

@PostConstruct
public void init() throws Exception {

Scheduler scheduler = schedulerFactoryBean.getScheduler();

// 这里获取任务信息数据
List<ScheduleJob> jobList = mapper.getAll();

for (ScheduleJob job : jobList) {
addJob(job);
}
}

/**
* 获取所有计划中的任务列表
*
* @return
* @throws SchedulerException
*/
public List<ScheduleJob> getAllJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
for (JobKey jobKey : jobKeys) {
List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
ScheduleJob job = new ScheduleJob();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setDescription("触发器:" + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
}
return jobList;
}

/**
* 所有正在运行的job
*
* @return
* @throws SchedulerException
*/
public List<ScheduleJob> getRunningJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
for (JobExecutionContext executingJob : executingJobs) {
ScheduleJob job = new ScheduleJob();
JobDetail jobDetail = executingJob.getJobDetail();
JobKey jobKey = jobDetail.getKey();
Trigger trigger = executingJob.getTrigger();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setDescription("触发器:" + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
return jobList;
}

/**
* 暂停一个job
*
* @param scheduleJob
* @throws SchedulerException
*/
public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.pauseJob(jobKey);
}

/**
* 恢复一个job
*
* @param scheduleJob
* @throws SchedulerException
*/
public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.resumeJob(jobKey);
}

/**
* 删除一个job
*
* @param scheduleJob
* @throws SchedulerException
*/
public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.deleteJob(jobKey);

}

/**
* 立即执行job
*
* @param scheduleJob
* @throws SchedulerException
*/
public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.triggerJob(jobKey);
}

/**
* 更新job时间表达式
*
* @param scheduleJob
* @throws SchedulerException
*/
public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();

TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());

trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

scheduler.rescheduleJob(triggerKey, trigger);
}
}

@Component
@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job,Serializable {
public final Logger log = Logger.getLogger(this.getClass());

@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
//  TaskUtils.invokeMethod(scheduleJob);
ServletContext scontext = QuartzContext.getInstance().getContext();
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(scontext);
if(null != scheduleJob){
Integer jobId = scheduleJob.getJobId();//获取任务id ，然后执行对应的出来方法

if(1 == jobId){ // 这些自己写
RealTimeDownTask realTimeDownTask = (RealTimeDownTask) ctx.getBean("realTimeDownTask");
realTimeDownTask.downTask();
}
if(2 == jobId){ // 这些处理方法自己
RefreshClockTask refreshClockTask = (RefreshClockTask) ctx
23ff8
.getBean("refreshClockTask");
refreshClockTask.setDeviceTime();
}

}

@Component("realTimeDownTask")

public class RealTimeDownTask {
private static final Logger LOG = LoggerFactory.getLogger(RealTimeDownTask.class);

public void downTask(){
//具体处理方法
}

}

@Component("refreshClockTask")
public class RefreshClockTask {

private static final Logger logger = LoggerFactory.getLogger(RefreshClockTask.class);

public void setDeviceTime() {
//具体处理方法
}
}

-- ----------------------------
-- Table structure for pb_task_schedule_job
-- ----------------------------
DROP TABLE IF EXISTS `pb_task_schedule_job`;
CREATE TABLE `pb_task_schedule_job` (
`job_id` bigint(20) NOT NULL auto_increment,
`create_time` timestamp NULL default NULL,
`update_time` timestamp NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP,
`job_name` varchar(255) default NULL,
`job_group` varchar(255) default NULL,
`job_status` varchar(255) default NULL,
`cron_expression` varchar(255) NOT NULL,
`description` varchar(255) default NULL,
`bean_class` varchar(255) default NULL,
`is_concurrent` varchar(255) default NULL COMMENT '1',
`spring_id` varchar(255) default NULL,
`method_name` varchar(255) NOT NULL,
`attemper_pro` int(11) default NULL,
`interval_time` varchar(20) default NULL,
PRIMARY KEY  (`job_id`),
UNIQUE KEY `name_group` USING BTREE (`job_name`,`job_group`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

 有些数据库字段不一定用的上

，有需要demo的后期可以补上，今天就到这里